JSON to Python
Buat Python dataclass dari JSON
Input JSON
Output Python
Apa Itu Konversi JSON ke Python Dataclass?
Konversi JSON ke Python dataclass mengambil objek JSON mentah dan menghasilkan sekumpulan definisi Python dataclass dengan anotasi tipe yang akurat. Modul dataclasses Python, yang diperkenalkan dalam PEP 557 (Python 3.7), menghasilkan metode __init__, __repr__, dan __eq__ secara otomatis dari field class yang dianotasi. Saat Anda bekerja dengan API JSON, file konfigurasi, atau antrean pesan, dataclass memberikan struktur bertipe pada data Anda yang dapat diverifikasi oleh editor dan pemeriksa tipe seperti mypy pada saat pengembangan.
Fungsi json.loads() Python mengembalikan dict dan list biasa. Ini memang berfungsi, tetapi tidak memiliki informasi tipe: kunci yang salah eja mengembalikan None alih-alih memunculkan error, dan editor Anda tidak dapat melengkapi nama field secara otomatis. Dataclass menyelesaikan masalah ini dengan memetakan setiap kunci JSON ke field bernama dan bertipe. Objek JSON bersarang menjadi definisi dataclass terpisah, array menjadi anotasi List[T], dan nilai null menjadi Optional[T] dengan nilai default None.
Menulis definisi ini secara manual adalah pekerjaan yang mekanis. Anda membaca JSON, menentukan tipe setiap field dari nilainya, mengonversi kunci dari camelCase atau snake_case ke konvensi Python, dan menangani kasus khusus seperti field nullable dan array dengan tipe campuran. Sebuah konverter melakukan semua ini dalam hitungan milidetik. Anda menempelkan JSON, mendapatkan kode dataclass yang benar, dan bisa langsung melanjutkan.
Mengapa Menggunakan Konverter JSON ke Python?
Menerjemahkan struktur JSON ke definisi class Python secara manual berarti menebak tipe dari data sampel, mengurutkan ulang field agar yang wajib ada sebelum yang opsional, dan memperbarui semuanya saat API berubah. Sebuah konverter menghilangkan gesekan tersebut.
Kasus Penggunaan JSON ke Python
Pemetaan Tipe JSON ke Python
Setiap nilai JSON dipetakan ke anotasi tipe Python yang spesifik. Tabel di bawah menunjukkan cara konverter menerjemahkan setiap tipe JSON, dengan sintaks modul typing (Python 3.7+) dan sintaks bawaan yang tersedia mulai Python 3.10.
| Tipe JSON | Contoh | Python (typing) | Python 3.10+ |
|---|---|---|---|
| string | "hello" | str | str |
| number (integer) | 42 | int | int |
| number (float) | 3.14 | float | float |
| boolean | true | bool | bool |
| null | null | Optional[str] | str | None |
| object | {"k": "v"} | @dataclass class | nested model |
| array of strings | ["a", "b"] | List[str] | list[str] |
| array of objects | [{"id": 1}] | List[Item] | list[Item] |
| mixed array | [1, "a"] | List[Any] | list[Any] |
Referensi Decorator Dataclass
Decorator @dataclass menerima beberapa parameter yang mengubah perilaku class yang dihasilkan. Referensi ini mencakup opsi yang paling relevan saat bekerja dengan data yang berasal dari JSON.
| Decorator / Field | Perilaku | Gunakan Saat |
|---|---|---|
| @dataclass | Generates __init__, __repr__, __eq__ from field annotations | Standard dataclasses |
| @dataclass(frozen=True) | Makes instances immutable (hashable, no attribute reassignment) | Config objects, dict keys |
| @dataclass(slots=True) | Uses __slots__ for lower memory and faster attribute access | Python 3.10+, large datasets |
| @dataclass(kw_only=True) | All fields require keyword arguments in __init__ | Python 3.10+, many fields |
| field(default_factory=list) | Sets a mutable default without sharing state between instances | List/dict/set defaults |
dataclass vs Pydantic vs TypedDict
Python memiliki tiga cara umum untuk mendefinisikan struktur bertipe dari JSON. Masing-masing cocok untuk kasus penggunaan yang berbeda. Dataclass adalah opsi dari library standar tanpa dependensi eksternal. Pydantic menambahkan validasi saat runtime. TypedDict menganotasi dict biasa tanpa membuat class baru.
Contoh Kode
Contoh-contoh ini menunjukkan cara menggunakan dataclass yang dihasilkan dalam Python, cara membuatnya secara programatik dari JavaScript, dan cara menggunakan pendekatan alternatif seperti Pydantic dan alat CLI.
from dataclasses import dataclass
from typing import List, Optional
import json
@dataclass
class Address:
street: str
city: str
zip: str
@dataclass
class User:
id: int
name: str
email: str
active: bool
score: float
address: Address
tags: List[str]
metadata: Optional[str] = None
raw = '{"id":1,"name":"Alice","email":"alice@example.com","active":true,"score":98.5,"address":{"street":"123 Main St","city":"Springfield","zip":"12345"},"tags":["admin","user"],"metadata":null}'
data = json.loads(raw)
# Reconstruct nested objects manually
addr = Address(**data["address"])
user = User(**{**data, "address": addr})
print(user.name) # -> Alice
print(user.address) # -> Address(street='123 Main St', city='Springfield', zip='12345')// Minimal JSON-to-Python-dataclass generator in JS
function jsonToPython(obj, name = "Root") {
const classes = [];
function infer(val, fieldName) {
if (val === null) return "Optional[str]";
if (typeof val === "string") return "str";
if (typeof val === "number") return Number.isInteger(val) ? "int" : "float";
if (typeof val === "boolean") return "bool";
if (Array.isArray(val)) {
const first = val.find(v => v !== null);
return first ? `List[${infer(first, fieldName + "Item")}]` : "List[Any]";
}
if (typeof val === "object") {
const clsName = fieldName.charAt(0).toUpperCase() + fieldName.slice(1);
build(val, clsName);
return clsName;
}
return "Any";
}
function build(obj, cls) {
const fields = Object.entries(obj).map(([k, v]) => ` ${k}: ${infer(v, k)}`);
classes.push(`@dataclass\nclass ${cls}:\n${fields.join("\n")}`);
}
build(obj, name);
return classes.join("\n\n");
}
const data = { id: 1, name: "Alice", scores: [98, 85] };
console.log(jsonToPython(data, "User"));
// @dataclass
// class User:
// id: int
// name: str
// scores: List[int]from pydantic import BaseModel
from typing import List, Optional
class Address(BaseModel):
street: str
city: str
zip: str
class User(BaseModel):
id: int
name: str
email: str
active: bool
score: float
address: Address
tags: List[str]
metadata: Optional[str] = None
# Pydantic parses and validates JSON in one step
raw = '{"id":1,"name":"Alice","email":"alice@example.com","active":true,"score":98.5,"address":{"street":"123 Main St","city":"Springfield","zip":"12345"},"tags":["admin","user"],"metadata":null}'
user = User.model_validate_json(raw)
print(user.name) # -> Alice
print(user.model_dump_json()) # -> re-serializes to JSON# Install the generator
pip install datamodel-code-generator
# Generate dataclasses from a JSON file
datamodel-codegen --input data.json --output models.py --output-model-type dataclasses.dataclass
# Generate Pydantic models instead
datamodel-codegen --input data.json --output models.py
# From a JSON string via stdin
echo '{"id": 1, "name": "Alice", "tags": ["admin"]}' | \
datamodel-codegen --output-model-type dataclasses.dataclass
# Output:
# @dataclass
# class Model:
# id: int
# name: str
# tags: List[str]