การทำงานกับ JSON และ Pandas DataFrame เป็นเรื่องปกติในงานวิเคราะห์ข้อมูล การรายงาน และท่อส่ง ETL ในขณะที่ Pandas มี readjson สำหรับการแปลงข้อมูลพื้นฐาน แต่ก็อาจมีปัญหากับโครงสร้างที่ซ้อนกันลึก ไฟล์ขนาดใหญ่มาก หรือเวิร์กโฟลว์ที่เน้น Excel ซึ่งนี่คือจุดที่ Aspose.Cells for Python เข้ามาช่วย มันมีท่อส่ง JSON-to-Excel ที่มีความสามารถ ซึ่งคุณสามารถรวมเข้ากับ Pandas ได้อย่างง่ายดายเพื่อให้ได้ DataFrames ที่สะอาดสำหรับการวิเคราะห์ ในบล็อกโพสต์นี้ คุณจะได้เรียนรู้วิธีการแปลง JSON เป็น DataFrames ของ Pandas ใน Python

Python Library to Convert JSON to Pandas DataFrame

Aspose.Cells for Python via .NET เป็น API สเปรดชีตที่ทรงพลังซึ่งไม่ต้องการ Microsoft Excel นอกเหนือจากการทำงานอัตโนมัติตามแบบคลาสสิก Excel แล้วยังสนับสนุนการนำเข้าและส่งออก JSON โดยตรง ทำให้เหมาะสำหรับเมื่อคุณต้องการแปลง JSON เป็น Pandas DataFrame และเก็บหรือประมวลผลใน Excel ในภายหลัง

ด้วย Aspose.Cells คุณสามารถ:

  • นำเข้า JSON ลงในแผ่นงานโดยใช้ JsonUtility พร้อมตัวเลือกในการจัดการอาร์เรย์และโครงสร้างที่ซ้อนกัน
  • แปลงช่วงเวิร์กชีตเป็น Pandas DataFrames สำหรับการวิเคราะห์และการแสดงผล
  • สร้าง โหลด และจัดการ JSON ภายในไฟล์ Excel ซึ่งเหมาะกับกระบวนการวิเคราะห์
  • ส่งออก DataFrames กลับไปยัง Excel (XLSX, CSV, ODS, PDF) สำหรับการรายงาน

โดยสรุปแล้ว ไลบรารีทำให้การโยกย้ายข้อมูลจาก JSON ไปยัง Excel สำหรับการรายงานเป็นเรื่องง่าย ในขณะที่คุณใช้ Pandas สำหรับการวิเคราะห์ที่ลึกซึ้งกว่า JsonUtility นำเข้า JSON ไปยังแผ่นงาน และ JsonLayoutOptions ควบคุมวิธีการที่อาร์เรย์และวัตถุที่ซ้อนกันขยายออกไป

แปลง JSON เป็น DataFrame

Aspose.Cells นำเข้าข้อมูล JSON โดยตรงเข้าสู่แผ่นงาน จากนั้นคุณจะอ่านแถวหัวเรื่องและแถวข้อมูลเพื่อสร้าง Pandas DataFrame

ทำตามขั้นตอนด้านล่างเพื่อนำ JSON ไปแปลงเป็น pandas DataFrame:

  1. สร้างสมุดงานและดึงเวิร์กชีตแรกออกมา
  2. กำหนดค่า JsonLayoutOptions เพื่อให้จัดการกับอาร์เรย์ในรูปแบบของตาราง
  3. นำเข้าค่า JSON ที่แถว 0 คอลัมน์ 0
  4. ใช้แถวแรกเป็นหัวข้อคอลัมน์。
  5. Extract remaining rows as data.
  6. สร้าง DataFrame ของ Pandas।

ตัวอย่างโค้ดด้านล่างนี้แสดงวิธีการแปลง JSON เป็น pandas DataFrame ใน Python:

import pandas as pd
import aspose.cells as ac

# สร้างสมุดงานใหม่และรับแผ่นงานแรก (ดัชนีเริ่มต้นที่ 0)
wb = ac.Workbook()
ws = wb.worksheets.get(0)

# กำหนดว่า JSON ควรจัดเลย์เอาต์อย่างไรในแผ่นงาน
options = ac.utility.JsonLayoutOptions()
options.array_as_table = True           # Treat a top-level JSON array as a table (rows/columns)

# ตัวอย่างอาร์เรย์ JSON ของวัตถุที่เรียบง่าย
json_data = '[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]'

# นำเข้า JSON ลงในแผ่นงานเริ่มต้นที่แถว=0, คอลัมน์=0 (เซลล์ A1)
ac.utility.JsonUtility.import_data(json_data, ws.cells, 0, 0, options)

# หาตารางแถวแรกที่มีข้อมูล (นี่จะเป็นแถวหัวของเรา)
header_idx = ws.cells.min_data_row

# ดึงค่าหัวเรื่องจากแถวดังกล่าวมาใช้เป็นชื่อคอลัมน์ของ DataFrame
columns = [cell.value for cell in ws.cells.rows[header_idx]]

# ดึงข้อมูลแถวถัดไปทั้งหมด (ข้ามแถวหัวข้อ)
data = [
    [cell.value for cell in row]
   for idx, row in enumerate(ws.cells.rows)
    if row and idx != header_idx
]

# สร้าง DataFrame โดยใช้ส่วนหัวและแถวที่เก็บรวบรวมไว้
df = pd.DataFrame(data, columns=columns)

# แสดงผลลัพธ์
print(df)

Output

    id   name
0  1.0  Alice
1  2.0    Bob

แปลง JSON แบบซ้อนเป็น Pandas DataFrame

หาก JSON ของคุณมีวัตถุที่ซ้อนกัน Aspose.Cells จะนำเข้า JSON ลงในแผ่นงานโดยใช้ JsonUtility ซึ่งคุณสามารถส่งออกไปยัง DataFrame ได้ ตัวเลือก JsonLayoutOptions จะควบคุมว่าทำไมอาร์เรย์และวัตถุที่ซ้อนจะถูกขยายอย่างไร

ทำตามขั้นตอนด้านล่างเพื่อแปลง JSON ที่ซ้อนกันเป็น pandas DataFrame:

  1. สร้างสมุดงานและเลือกแผ่นงานแรก
  2. ตั้งค่าคุณสมบัติ JsonLayoutOptions ที่จำเป็นเช่น arrayastable=True , ignorearraytitle=True , ignoreobjecttitle=True และ keptschema=True .
  3. นำเข้า JSON ที่ซ้อนกันที่แถว 0 คอลัมน์ 0
  4. ตรวจสอบช่วงที่ถูกใช้และอ่านแถวหัวข้อข้ามช่วงทั้งหมด
  5. อ่านแถวถัดไปทั้งหมดในช่วงเดียวกัน (ความกว้างคงที่)
  6. สร้าง DataFrame; สามารถแปลงประเภทข้อมูล (เช่น total เป็นตัวเลข) ได้ตามต้องการ

ตัวอย่างโค้ดด้านล่างแสดงวิธีการแปลง JSON ที่ซ้อนกันเป็น pandas DataFrame ใน Python:

import pandas as pd
import aspose.cells as ac

# สร้างสมุดงานและรับแผ่นงานแรก
wb = ac.Workbook()
ws = wb.worksheets.get(0)

# ตัวเลือกเลเอาต์สำหรับ 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

# ขั้นตอนที่ 3: 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"}}
  ]
}
'''

# นำเข้าที่ A1 (แถว=0, คอลัมน์=0) โดยใช้ตัวเลือกด้านบน
ac.utility.JsonUtility.import_data(nested, ws.cells, 0, 0, opt)

# ตรวจหาช่วงที่ใช้แล้ว
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

# อ่านแถวหัวข้อข้ามช่วงคอลัมน์ที่ใช้งานทั้งหมด (ความกว้างคงที่)
raw_columns = [ws.cells.get(first_row, c).value for c in range(first_col, last_col + 1)]

# ทำให้หัวข้อปลอดภัย: แทนที่ None/ว่างด้วย \"Column{n}\" และทำการแปลงเป็น 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)
]

# อ่านแถวข้อมูลข้ามช่วงเดียวกัน (ความกว้างที่กำหนดช่วยให้การจัดเรียงตรง)
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)

# สร้าง DataFrame
df = pd.DataFrame(data, columns=columns)

# ทางเลือก: จัดระเบียบชื่อคอลัมน์ (เช่น เปลี่ยนช่องว่าง)
df.columns = [str(c).strip() for c in df.columns]

# Optional typing:
# - เก็บ ZIP เป็นสตริง (ตัวเลขนำหน้าสำคัญ)
# - แปลงผลรวมเป็นตัวเลข (บังคับให้ค่าที่ไม่ใช่ตัวเลขเป็น 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

หมายเหตุ: หากคุณเปิดใช้งาน convertnumericordate=True สตริงที่ดูเหมือนตัวเลข (เช่น ยอดรวม) อาจแปลงเป็นตัวเลข แต่รหัสไปรษณีย์เช่น \"02108\" อาจสูญเสียศูนย์นำหน้า ให้ตั้งค่าเป็น False หากคุณต้องการให้รหัสไปรษณีย์เป็นสตริง.

แปลง Excel เป็น Pandas DataFrame ผ่าน JSON

ส่งออกช่วง Excel ใดๆ เป็น JSON ด้วย Aspose.Cells จากนั้นโหลด JSON นั้นเข้าไปใน Pandas เป็น DataFrame สิ่งนี้มีประโยชน์เมื่อต้องการการส่งผ่าน JSON ที่มีโครงสร้างสำหรับบริการหรือสายงาน

ปฏิบัติตามขั้นตอนด้านล่างเพื่อแปลง Excel เป็น pandas DataFrame ผ่าน JSON:

  1. สร้างสมุดงานใหม่ รับแผ่นงานแรกและเพิ่มค่าตัวอย่าง
  2. สร้าง JsonSaveOptions ด้วยค่าที่ตั้งไว้เป็นค่าเริ่มต้น。
  3. ส่งออกช่วงที่ใช้ไปยัง JSON สตริงด้วยวิธี exportrangetojson()
  4. อ่านสตริง JSON ลงใน DataFrame โดยใช้วิธี pd.readjson(io.StringIO(jsontext))
  5. ตรวจสอบหรือประมวลผล DataFrame ตามที่จำเป็น

ตัวอย่างรหัสต่อไปนี้แสดงวิธีการแปลง Excel เป็น pandas DataFrame ผ่าน JSON ใน Python:

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

# สร้างสมุดงานใหม่และเข้าถึงแผ่นงานแรก
workbook = Workbook()
worksheet = workbook.worksheets.get(0)

# รับเซลล์ของเวิร์กชีต
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"

# ตั้งค่าตัวเลือกการบันทึก JSON (ค่าเริ่มต้นใช้ได้สำหรับตารางธรรมดา)
json_save_options = JsonSaveOptions()

# ส่งออกช่วงที่ใช้ไปยังสตริง JSON
# maxdisplayrange คว้าพื้นที่สี่เหลี่ยมผืนผ้าทั้งหมดที่มีข้อมูล
json_text = JsonUtility.export_range_to_json(cells.max_display_range, json_save_options)

# อ่านสตริง JSON ลงใน Pandas DataFrame
#    แพนด้าสามารถแยกวิเคราะห์สตริง JSON ได้โดยตรง
df = pd.read_json(io.StringIO(json_text))

# ใช้ DataFrame
print(df)

Output

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

รับใบอนุญาตฟรี

ประเมิน Aspose.Cells for Python ผ่าน .NET โดยไม่มีข้อจำกัดด้านฟีเจอร์ โดยการใช้ใบอนุญาตชั่วคราวฟรี เยี่ยมชม temporary license page เพื่อปลดล็อกฟังก์ชันการทำงานทั้งหมด รวมถึงการนำเข้า JSON (JsonUtility), การควบคุมเลย์เอาต์ (JsonLayoutOptions), การรักษาโครงสร้าง และการแปลงตัวเลข/วันที่

ทรัพยากรฟรีเพิ่มเติม

คุณสามารถใช้ทรัพยากรด้านล่างเพื่อทำความเข้าใจเกี่ยวกับการนำเข้า JSON ตัวเลือกการจัดเลย์เอาต์ และการจัดการ Excel อื่น ๆ ด้วย Aspose.Cells for Python

สรุป

การแปลง JSON เป็น Pandas DataFrames จะกลายเป็นเรื่องง่ายด้วย Aspose.Cells for Python คุณจะได้รับการจัดการที่เชื่อถือได้สำหรับโครงสร้างที่ซ้อนกัน ตัวเลือกสำหรับความเสถียรของสคีมา และเส้นทางที่ง่ายสำหรับการส่งออกเป็น Excel เมื่อต้องการ รวมความยืดหยุ่นของ Pandas กับท่อส่ง JSON/Excel ใน Aspose.Cells เพื่อทำให้การประมวลผลข้อมูลง่ายขึ้นและปลดล็อกการวิเคราะห์ที่ทรงพลังใน Python

หากคุณมีคำถาม โปรดเยี่ยมชม ฟอรัมสนับสนุนฟรี ของเรา เรายินดีที่จะช่วยคุณ

ดูเพิ่มเติม