Att arbeta med JSON och Pandas DataFrame är vanligt inom dataanalys, rapportering och ETL-pipelines. Medan Pandas tillhandahåller readjson för grundläggande avparsing, kan det ha svårt med djupt nästlade strukturer, mycket stora filer eller Excel-först arbetsflöden. Här hjälper Aspose.Cells för Python till. Det erbjuder en rik JSON-till-Excel pipeline, som du enkelt kan integrera med Pandas för att få rena DataFrames för analys. I det här blogginlägget kommer du att lära dig hur man konverterar JSON till Pandas-dataframes i Python.

Python-bibliotek för att konvertera JSON till Pandas DataFrame

Aspose.Cells för Python via .NET är en kraftfull kalkylblads-API som inte kräver Microsoft Excel. Förutom klassisk Excel-automation stöder den direkt JSON-import och -export, vilket gör den idealisk när du vill konvertera JSON till en Pandas DataFrame och senare spara eller bearbeta den i Excel.

Med Aspose.Cells kan du:

  • Importera JSON till kalkylblad med JsonUtility, med alternativ för att hantera arrayer och nästlade strukturer.
  • Konvertera arbetsbladets intervall till Pandas DataFrames för analys och visualisering.
  • Skapa, ladda och hantera JSON i Excel-filer, som passar in i analysramar.
  • Exportera DataFrames tillbaka till Excel (XLSX, CSV, ODS, PDF) för rapportering.

Kort sagt gör biblioteket det enkelt att flytta data från JSON till Excel för rapportering, medan du använder Pandas för djupare analys. JsonUtility importerar JSON till ett kalkylblad, och JsonLayoutOptions styr hur arrayer och nästlade objekt expanderar.

Convert JSON to DataFrame

Aspose.Cells importerar JSON direkt till ett kalkylblad. Du läser sedan rubrikraden och dataraderna för att bygga en Pandas DataFrame.

Följ stegen nedan för att konvertera JSON till en pandas DataFrame:

  1. Skapa en arbetsbok och hämta det första kalkylbladet.
  2. Konfigurera JsonLayoutOptions för att behandla arrayer som tabeller.
  3. Import the JSON string at row 0, column 0.
  4. Använd den första raden som kolumnrubriker.
  5. Extract remaining rows as data.
  6. Bygg en Pandas DataFrame.

Följande kodexempel visar hur man konverterar JSON till en pandas DataFrame i Python:

import pandas as pd
import aspose.cells as ac

# Skapa en ny arbetsbok och hämta det första kalkylbladet (0-baserad index)
wb = ac.Workbook()
ws = wb.worksheets.get(0)

# Konfigurera hur JSON ska läggas ut i arbetsbladet
options = ac.utility.JsonLayoutOptions()
options.array_as_table = True           # Treat a top-level JSON array as a table (rows/columns)

# Exempel JSON-array av enkla objekt
json_data = '[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]'

# Importera JSON till kalkylbladet som börjar på rad=0, kol=0 (cell A1)
ac.utility.JsonUtility.import_data(json_data, ws.cells, 0, 0, options)

# Lokalisera den första raden som innehåller data (detta kommer att bli vår rubrikrad)
header_idx = ws.cells.min_data_row

# Extrahera rubrikvärden från den raden för att använda som DataFrame kolumnnamn
columns = [cell.value for cell in ws.cells.rows[header_idx]]

# Extrahera alla efterföljande rader som data (hoppa över rubrikraden)
data = [
    [cell.value for cell in row]
   for idx, row in enumerate(ws.cells.rows)
    if row and idx != header_idx
]

# Bygg DataFrame med de insamlade rubrikerna och raderna
df = pd.DataFrame(data, columns=columns)

# Display the result
print(df)

Output

    id   name
0  1.0  Alice
1  2.0    Bob

Convert Nested JSON to Pandas DataFrame

Om din JSON innehåller nästlade objekt, importerar Aspose.Cells JSON till ett kalkylblad med hjälp av JsonUtility, som du sedan kan exportera till en DataFrame. JsonLayoutOptions styr hur Arrayer och nästlade objekt expanderas.

Följ stegen nedan för att konvertera nästlad JSON till en pandas DataFrame:

  1. Skapa en arbetsbok och välj det första kalkylbladet.
  2. Ställ in nödvändiga JsonLayoutOptions-egenskaper som arrayastable=True, ignorearraytitle=True, ignoreobjecttitle=True och keptschema=True.
  3. Importera den nästlade JSON på rad 0, kolumn 0.
  4. Detektera det använda området och läs rubrikraden över hela spännvidden.
  5. Läs alla efterföljande rader över samma spännvidd (fast bredd).
  6. Bygg DataFrame; valfritt kasta dtyper (t.ex. total till numerisk).

Följande kodexempel visar hur man konverterar inbäddad JSON till en pandas DataFrame i Python:

import pandas as pd
import aspose.cells as ac

# Skapa arbetsbok och hämta första kalkylbladet
wb = ac.Workbook()
ws = wb.worksheets.get(0)

# Layoutalternativ för nästlad JSON
opt = ac.utility.JsonLayoutOptions()
opt.array_as_table = True  # Treat 'orders' array as a table (rows)
opt.ignore_array_title = True  # Do not place a title row for the 'orders' array
opt.ignore_object_title = True  # Do not place extra title rows for nested objects (e.g., 'buyer')
opt.kept_schema = True  # Keep a stable set of columns even if some records miss fields

# Steg 3: Din nästlade JSON
nested = '''
{
  "batch": "A1",
  "orders": [
    {"orderId": "1001", "total": "49.90", "buyer": {"city": "NYC", "zip": "10001"}},
    {"orderId": "1002", "total": "79.00", "buyer": {"city": "Boston", "zip": "02108"}}
  ]
}
'''

# Importera vid A1 (rad=0, kol=0) med hjälp av alternativen ovanför
ac.utility.JsonUtility.import_data(nested, ws.cells, 0, 0, opt)

# Detect used range
first_row = ws.cells.min_data_row
first_col = ws.cells.min_data_column
last_row = ws.cells.max_data_row
last_col = ws.cells.max_data_column

# Läs rubrikraden över hela den använda kolumnbredden (fast bredd)
raw_columns = [ws.cells.get(first_row, c).value for c in range(first_col, last_col + 1)]

# Gör rubriker säkra: ersätt None/tomt med \"Kolumn{n}\" och kasta till str
columns = [
    (str(v) if v is not None and str(v).strip() != "" else f"Column{idx + 1}")
   for idx, v in enumerate(raw_columns)
]

# Läs datarader över samma intervall (fast bredd garanterar justering)
data = []
for r in range(first_row + 1, last_row + 1):
    row_vals = [ws.cells.get(r, c).value for c in range(first_col, last_col + 1)]
    data.append(row_vals)

# Bygg DataFrame
df = pd.DataFrame(data, columns=columns)

# Valfritt: städa upp kolumnnamn (t.ex. ersätt mellanrum)
df.columns = [str(c).strip() for c in df.columns]

# Valfri typning:
# - Håll ZIP-koder som strängar (ledande nollor är viktiga)
# - Konvertera totalsummor till numeriska (tvinga icke-numeriska till NaN)
for col in list(df.columns):
    if col.lower().endswith("total"):
        df[col] = pd.to_numeric(df[col], errors="coerce")

# Print
print(df)

Output

     A1  1001  49.90     NYC  10001
0  None  1002  79.00  Boston  02108

Notera: Om du aktiverar convertnumericordate=True, kan numeriska strängar (t.ex. totalsummor) konverteras till siffror, men postnummer som \"02108\" kan förlora ledande nollor. Håll det False om du behöver postnummer som strängar.

Konvertera Excel till Pandas DataFrame via JSON

Exportera valfritt Excel-intervall till JSON med Aspose.Cells, och ladda sedan den JSON:en i Pandas som en DataFrame. Detta är användbart när du behöver en strukturerad JSON-överföring för tjänster eller pipelines.

Följ stegen nedan för att konvertera Excel till en pandas DataFrame via JSON:

  1. Skapa ett nytt kalkylblad, hämta det första arbetsbladet och lägg till exempelvärden.
  2. Skapa JsonSaveOptions med standardinställningar.
  3. Exportera det använda området till en JSON-sträng med metoden exportrangetojson().
  4. Läs JSON-strängen i en DataFrame med hjälp av metoden pd.readjson(io.StringIO(jsontext)).
  5. Inspektera eller bearbeta DataFrame som behövs.

Följande kodexempel visar hur man konverterar Excel till en pandas DataFrame via JSON i Python:

import io
import pandas as pd
from aspose.cells.utility import JsonUtility  # JSON export utility
from aspose.cells import Workbook, JsonSaveOptions, License

# Skapa en ny arbetsbok och få tillgång till det första kalkylbladet
workbook = Workbook()
worksheet = workbook.worksheets.get(0)

# Hämta cellerna i kalkylbladet
cells = worksheet.cells

# Populate a small table (headers + rows)
cells.get("A1").value = "Name"
cells.get("B1").value = "Age"
cells.get("C1").value = "City"

cells.get("A2").value = "Alice"
cells.get("B2").value = 25
cells.get("C2").value = "New York"

cells.get("A3").value = "Bob"
cells.get("B3").value = 30
cells.get("C3").value = "San Francisco"

cells.get("A4").value = "Charlie"
cells.get("B4").value = 35
cells.get("C4").value = "Los Angeles"

# Ställ in JSON-sparalternativ (standardinställningarna är bra för en enkel tabell)
json_save_options = JsonSaveOptions()

# Exportera det använda området till en JSON-sträng
# maxdisplayrange hämtar det fulla rektangulära området som innehåller data
json_text = JsonUtility.export_range_to_json(cells.max_display_range, json_save_options)

# Läs JSON-strängen i en Pandas DataFrame
#    Pandas kan direkt tolka en JSON-sträng
df = pd.read_json(io.StringIO(json_text))

# Använda DataFrame
print(df)

Output

      Name  Age           City
0    Alice   25       New York
1      Bob   30  San Francisco
2  Charlie   35    Los Angeles

Få en gratis licens

Utvärdera Aspose.Cells för Python via .NET utan funktionsbegränsningar genom att använda en gratis tillfällig licens. Besök temporary license page för att låsa upp full funktionalitet, inklusive JSON-import (JsonUtility), layoutkontroll (JsonLayoutOptions), bevarande av schema och numerisk/datumkonvertering.

Ytterligare gratis resurser

Du kan använda resurserna nedan för att fördjupa dig i JSON-import, layoutalternativ och andra Excel-manipulationer med Aspose.Cells för Python.

Slutsats

Att konvertera JSON till Pandas DataFrames blir enkelt med Aspose.Cells för Python. Du får pålitlig hantering av nästlade strukturer, alternativ för schemasstabilitet och en enkel väg för Excel-export när det behövs. Kombinera flexibiliteten i Pandas med JSON/Excel-processen i Aspose.Cells för att förenkla databehandling och låsa upp kraftfull analys i Python.

Om du har frågor, besök vårt free support forum.Vi är glada att hjälpa dig.

Se Även