A nyers JSON adatok kifinomult XLSX jelentésekké alakítása gyakori igény a Python fejlesztők számára, akik elemző műszerfalakon dolgoznak. Aspose.BarCode Cloud SDK for Python egy erőteljes könyvtárat biztosít, amely egyszerűsíti a vonalkód generálását és a fájlkezelést a felhőben. Ebben az útmutatóban megtanulja a JSON-ról XLSX-re konvertálást Pythonban, a SDK beállításától a vonalkód képek generálásáig és a végső táblázat exportálásáig. A végére egy újrahasználható szkriptet kap, amely készen áll a termelési feladatokra.

Mielőtt elkezdené: Előfeltételek és telepítés

A tutorial követéséhez a következőkre van szüksége:

  • Python 3.7 vagy újabb telepítve a gépén.
  • Egy IDE vagy szövegszerkesztő a választásának megfelelően (VS Code, PyCharm, stb.).
  • Egy Aspose Cloud fiók Client Id és Client Secret értékekkel.
  • Internetkapcsolat a felhő API hívásokhoz.

Telepítse a szükséges csomagokat a pip segítségével:

pip install aspose-barcode-cloud openpyxl

Töltse le az SDK-t a hivatalos kiadási oldalról, ha a manuális telepítést részesíti előnyben: Download Aspose.BarCode Cloud SDK for Python.

Állítsa be hitelesítő adatait, mielőtt bármilyen API‑hívást végezne:

from asposebarcodecloud import Configuration

CLIENT_ID = "YOUR_CLIENT_ID"
CLIENT_SECRET = "YOUR_CLIENT_SECRET"

config = Configuration()
config.host = "https://api.aspose.cloud"
config.api_key["client_id"] = CLIENT_ID
config.api_key["client_secret"] = CLIENT_SECRET

A környezet készen áll, ezért továbbléphetünk a megvalósításra.

Lépésről lépésre felépítve: JSON XLSX konvertálása Pythonban

1. lépés: A forrás JSON fájl betöltése

Olvassa be a JSON tömböt, amely tartalmazza a exportálni kívánt adatokat.

import json

INPUT_JSON_PATH = "input.json"
with open(INPUT_JSON_PATH, "r", encoding="utf-8") as f:
    json_data = json.load(f)   # expects a list of dictionaries

2. lépés: A munkafüzet és a fejléc sor előkészítése

Hozzon létre egy Excel munkafüzetet az OpenPyXL segítségével, és írja be az oszlopfejléceket.

from openpyxl import Workbook
from openpyxl.utils import get_column_letter

wb = Workbook()
ws = wb.active
ws.title = "Data"

columns = list(json_data[0].keys())
columns.append("BarcodeImage")          # extra column for the barcode
for col_idx, col_name in enumerate(columns, start=1):
    ws.cell(row=1, column=col_idx, value=col_name)

3. lépés: Vonalkód képek generálása

Használja az Aspose.BarCode Cloud-ot, hogy minden rekordhoz PNG vonalkódot hozzon létre.
Az BarcodeApi.generate_barcode API-referencia a API-referenciában érhető el.

from asposebarcodecloud import BarcodeApi, GenerateBarcodeRequest, EncodeBarcodeType, ApiClient
from asposebarcodecloud.rest import ApiException

barcode_api = BarcodeApi(ApiClient(config))

def generate_barcode_image(text: str,
                           barcode_type: EncodeBarcodeType = EncodeBarcodeType.CODE_128) -> bytes:
    request = GenerateBarcodeRequest(text=text, type=barcode_type, format="png")
    try:
        response = barcode_api.generate_barcode(request)
        return response.read()
    except ApiException as e:
        print(f"Error generating barcode for '{text}': {e}")
        raise

4. lépés: Vonalkódok beszúrása a munkalapba

Gyorsítótárazza az azonos vonalkódokat a felesleges API-hívások elkerülése érdekében, majd ágyazza be a képet.

import io
from openpyxl.drawing.image import Image as XLImage

barcode_cache = {}
for row_idx, record in enumerate(json_data, start=2):
    # write regular fields
    for col_idx, field_name in enumerate(columns[:-1], start=1):
        ws.cell(row=row_idx, column=col_idx, value=record.get(field_name, ""))

# barcode generation / caching
    barcode_source = str(record.get("code", f"row{row_idx}"))
    img_bytes = barcode_cache.get(barcode_source) or generate_barcode_image(barcode_source)
    barcode_cache[barcode_source] = img_bytes

img_stream = io.BytesIO(img_bytes)
    img = XLImage(img_stream)
    img.width, img.height = 150, 50          # optional size adjustment
    img_cell = f"{get_column_letter(len(columns))}{row_idx}"
    ws.add_image(img, img_cell)

5. lépés: Oszlopok automatikus méretezése és a munkafüzet mentése

Fejezze be a fájlt, és írja a lemezre.

for col_idx in range(1, len(columns) + 1):
    column_letter = get_column_letter(col_idx)
    ws.column_dimensions[column_letter].width = 20

OUTPUT_XLSX_PATH = "output.xlsx"
wb.save(OUTPUT_XLSX_PATH)
print(f"Conversion complete. XLSX saved to '{OUTPUT_XLSX_PATH}'.")

Ezekkel a lépésekkel a JSON‑ról XLSX‑re konvertálás befejeződött, és minden sor most már egy Aspose.BarCode által generált vonalkódképet tartalmaz.

Teljes JSON‑t XLSX‑re konvertáló szkript Pythonban - Teljes kódpélda

Az alábbi példa bemutatja a JSON‑ról XLSX‑re konvertálás végponttól végpontig történő megvalósítását az Aspose.BarCode Cloud SDK for Python használatával.

import json
import os
import io
from typing import Dict, Any, List

import asposebarcodecloud
from asposebarcodecloud import (
    BarcodeApi,
    GenerateBarcodeRequest,
    EncodeBarcodeType,
    Configuration,
    ApiClient,
)
from asposebarcodecloud.rest import ApiException

from openpyxl import Workbook
from openpyxl.drawing.image import Image as XLImage
from openpyxl.utils import get_column_letter

# -------------------- Aspose.BarCode Cloud Setup --------------------
# Replace these placeholders with your actual Aspose Cloud credentials.
CLIENT_ID = "YOUR_CLIENT_ID"
CLIENT_SECRET = "YOUR_CLIENT_SECRET"

config = Configuration()
config.host = "https://api.aspose.cloud"
config.api_key["client_id"] = CLIENT_ID
config.api_key["client_secret"] = CLIENT_SECRET

barcode_api = BarcodeApi(ApiClient(config))

def generate_barcode_image(text: str, barcode_type: EncodeBarcodeType = EncodeBarcodeType.CODE_128) -> bytes:
    """
    Calls Aspose.BarCode Cloud to generate a barcode image for the given text.
    Returns raw PNG bytes.
    """
    request = GenerateBarcodeRequest(
        text=text,
        type=barcode_type,
        format="png"
    )
    try:
        response = barcode_api.generate_barcode(request)
        # response is a file-like object; read its content.
        return response.read()
    except ApiException as e:
        print(f"Error generating barcode for '{text}': {e}")
        raise

# -------------------- JSON to XLSX Conversion --------------------
INPUT_JSON_PATH = "input.json"
OUTPUT_XLSX_PATH = "output.xlsx"

# Load JSON data (expects a list of dictionaries)
with open(INPUT_JSON_PATH, "r", encoding="utf-8") as f:
    json_data: List[Dict[str, Any]] = json.load(f)

if not isinstance(json_data, list):
    raise ValueError("JSON root must be an array of objects.")

# Prepare workbook
wb = Workbook()
ws = wb.active
ws.title = "Data"

# Determine column order from first record
columns = list(json_data[0].keys())
# Append a column for the barcode image
barcode_column_name = "BarcodeImage"
columns.append(barcode_column_name)

# Write header row
for col_idx, col_name in enumerate(columns, start=1):
    ws.cell(row=1, column=col_idx, value=col_name)

# Cache to avoid regenerating identical barcodes
barcode_cache: Dict[str, bytes] = {}

# Process each JSON record
for row_idx, record in enumerate(json_data, start=2):
    # Write regular fields
    for col_idx, field_name in enumerate(columns[:-1], start=1):
        value = record.get(field_name, "")
        ws.cell(row=row_idx, column=col_idx, value=value)

# Generate or retrieve barcode image for a specific field (e.g., "code")
    barcode_source = str(record.get("code", f"row{row_idx}"))
    if barcode_source in barcode_cache:
        img_bytes = barcode_cache[barcode_source]
    else:
        img_bytes = generate_barcode_image(barcode_source)
        barcode_cache[barcode_source] = img_bytes

# Insert barcode image into the last column of the current row
    img_stream = io.BytesIO(img_bytes)
    img = XLImage(img_stream)
    # Adjust image size (optional)
    img.width, img.height = 150, 50
    img_cell = f"{get_column_letter(len(columns))}{row_idx}"
    ws.add_image(img, img_cell)

# Auto‑size columns (basic heuristic)
for col_idx, _ in enumerate(columns, start=1):
    column_letter = get_column_letter(col_idx)
    ws.column_dimensions[column_letter].width = 20

# Save workbook
wb.save(OUTPUT_XLSX_PATH)

print(f"Conversion complete. XLSX saved to '{OUTPUT_XLSX_PATH}'.")

Megjegyzés: Ez a kódrészlet a fő funkciót mutatja be. Mielőtt a projektjében használná, győződjön meg róla, hogy frissíti a fájl útvonalakat (input.json, output.xlsx, stb.) a tényleges helyeknek megfelelően, ellenőrizze, hogy minden szükséges függőség megfelelően telepítve van, és alaposan tesztelje a fejlesztői környezetben. Ha problémákba ütközik, kérjük, tekintse meg a hivatalos dokumentációt vagy vegye fel a kapcsolatot a támogatási csapattal segítségért.

Azonos feladat végrehajtása cURL-lel és a REST API-val

Ha inkább tiszta REST megközelítést részesít előnyben, ugyanazt az eredményt néhány cURL parancs segítségével érheti el. A munkafolyamat tükrözi a Python megvalósítást: szerezzen be egy hozzáférési tokent, töltse fel a JSON fájlt, generáljon vonalkódokat, hozza létre az XLSX fájlt, és töltse le az eredményt.

1. Hitelesítés és hozzáférési token lekérése

curl -X POST "https://api.aspose.cloud/connect/token" \
     -H "Content-Type: application/x-www-form-urlencoded" \
     -d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET"

A válasz tartalmazza az access_token-t, amelyet a további hívások során használni fog.

2. A forrás JSON fájl feltöltése az Aspose Cloud Storage-be

curl -X PUT "https://api.aspose.cloud/v3.0/storage/file/input.json" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     --data-binary @input.json

3. Vonalkód kép generálása egy mintaértékhez

curl -X POST "https://api.aspose.cloud/v3.0/barcode/generate" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "text": "SampleCode123",
           "type": "Code128",
           "format": "png"
         }' \
     -o barcode.png

4. JSON konvertálása XLSX formátumba az Aspose.Cells Cloud használatával

curl -X POST "https://api.aspose.cloud/v3.0/cells/convert?format=xlsx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"FileName":"input.json"}' \
     -o output.xlsx

5. Töltse le a keletkezett XLSX fájlt

curl -X GET "https://api.aspose.cloud/v3.0/storage/file/output.xlsx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -o output.xlsx

Ezek a parancsok bemutatják, hogyan lehet ugyanazt a JSON‑ról XLSX‑re konverziót végrehajtani kód írása nélkül. További részletekért tekintse meg a hivatalos API dokumentációt.

A konverziós beállítások konfigurálása az optimális eredmények érdekében

Aspose.BarCode Cloud több paramétert kínál, amelyeket testre szabhat a projektjéhez:

  • Vonalkód típusa - Válasszon a következők közül EncodeBarcodeType.CODE_128, EncodeBarcodeType.QR, EncodeBarcodeType.PDF_417, stb.
  • Képformátum - A PNG az alapértelmezett, de a format mező módosításával kérhet jpeg vagy gif formátumot.
  • Kép mérete - Állítsa be a img.width és img.height értékeket a szkriptben a felbontás szabályozásához.
  • Oszlop szélessége - Módosítsa a ws.column_dimensions[column_letter].width értéket, hogy hosszabb szöveget is elférjen.

Példa a vonalkód típusának és a képformátum módosítására:

def generate_barcode_image(text: str,
                           barcode_type: EncodeBarcodeType = EncodeBarcodeType.QR,
                           image_format: str = "jpeg") -> bytes:
    request = GenerateBarcodeRequest(
        text=text,
        type=barcode_type,
        format=image_format
    )
    response = barcode_api.generate_barcode(request)
    return response.read()

Nagy JSON adathalmazok teljesítményének optimalizálása

Amikor több ezer rekorddal dolgozik, vegye figyelembe ezeket az optimalizációkat:

  1. Stream JSON a teljes fájl betöltése helyett - Használja az ijson-t a rekordok iterálásához anélkül, hogy a teljes listát a memóriában tartaná.
  2. Ismétlődő vonalkódok gyorsítótárazása - A mintakódban található barcode_cache szótár megakadályozza az azonos értékekhez tartozó duplikált API hívásokat.
  3. Képek okos átméretezése - A kisebb vonalkód képek csökkentik a memóriahasználatot és felgyorsítják a munkafüzet mentését.
  4. Sorok kötegelt írása - Az OpenPyXL lehetővé teszi a sorok kötegelt írását; az írások csoportosítása csökkentheti a terhelést.

Ezeknek a tippeknek az alkalmazása biztosítja, hogy a konverzió gyors és memóriahatékony maradjon még a hatalmas adathalmazok esetén is.

Következtetés

JSON to XLSX konvertálása Pythonban egyszerűvé válik, ha kihasználod az Aspose.BarCode Cloud SDK for Python erejét. Ez az útmutató végigvezetett a környezet beállításán, a vonalkód generálásán, a munkafüzet létrehozásán és a teljesítményhangoláson, szilárd alapot biztosítva a jelentéskészítő csővezetékek felépítéséhez. Ne feledd, hogy a termelési telepítésekhez kereskedelmi licenc szükséges; a termékoldalon megtekintheted az árképzési lehetőségeket, vagy ideiglenes licencet szerezhetsz a ideiglenes licenc oldal oldalról. A megadott kóddal és a legjobb gyakorlatok ajánlásaival készen állsz, hogy megbízható adatexport funkciót integrálj az alkalmazásaidba.

GYIK

  • Hogyan valósíthatom meg a JSON‑t XLSX‑re konvertálást Pythonban anélkül, hogy saját vonalkódlogikát írnám?
    Használja az Aspose.BarCode Cloud SDK‑t a vonalkódok automatikus generálásához, és kombinálja az OpenPyXL‑lel az Excel létrehozásához, ahogyan a teljes kódrészletben bemutatott.

  • Mi a javasolt módja a hiányzó mezők kezelésének a JSON bemenetben?
    Hozzáférés a szótár értékeihez a record.get("field_name", "") használatával, amely alapértelmezett üres karakterláncot ad, megakadályozva a futásidejű hibákat a munkalap feltöltése során.

  • Vannak korlátok a feldolgozható JSON fájl méretére?
    A felhő API-nak nincs szigorú korlátja, de nagyon nagy fájlok esetén a JSON‑t streamelni kell, és a vonalkódokat cache‑elni, ahogyan a teljesítmény szakaszban le van írva.

  • Szükségem van külön licencre az Aspose.Cells használatához az XLSX fájl létrehozásakor?
    Nem. Az XLSX generálása helyileg történik az OpenPyXL segítségével, így csak az Aspose.BarCode Cloud SDK igényel licencet a felhőhívásokhoz.

További információk