Guia del programador per a dades de Python i JSON

Inici » Python » Guia del programador per a dades de Python i JSON

JSON s'ha convertit discretament en l'idioma predeterminat per a les dades a la web, i si esteu escrivint Python, us hi trobeu per tot arreu: API, fitxers de configuració, petites "bases de dades" per a projectes secundaris, registres i fins i tot proves. Comprendre com els tipus de dades de Python es mapen a JSON i com json El mòdul realment funciona és una d'aquelles habilitats que de sobte simplifica moltes tasques quotidianes.

Aquesta guia explica JSON des del punt de vista d'un programador de Python. explicant què és JSON, com es relaciona amb JavaScript, quins tipus de Python pot representar i com analitzar, generar, imprimir, validar i personalitzar JSON mitjançant jsonTambé analitzarem casos d'ús del món real com ara treballar amb fitxers i API, a més de trucs per gestionar dades imbricades i casos límit com ara errors o valors especials com ara NaN i infinits.

Què és JSON i com es relaciona amb les dades de Python

JSON, abreviatura de JavaScript Object Notation, és un format de text per a dades estructurades que originalment va manllevar la seva sintaxi d'objectes i matrius de JavaScript. Malgrat les arrels de JavaScript, JSON és agnòstic a l'idioma i és compatible amb pràcticament tots els llenguatges moderns, inclòs Python, cosa que el fa ideal per intercanviar dades entre serveis, clients i servidors.

Conceptualment, JSON utilitza només dos blocs de construcció compostos: l' objecte JavaScript i la matriu JavaScript . Un objecte es comporta de manera molt semblant a un diccionari de Python, i una matriu es comporta com una llista de Python. Amb aquests dos, més un petit conjunt de tipus primitius, JSON pot descriure estructures de dades imbricades complexes.

Un objecte en JavaScript (i JSON) té aquest aspecte: {"key1": value1, "key2": value2}És una col·lecció de parells clau-valor, on les claus són cadenes i els valors poden ser qualsevol valor JSON vàlid (inclosos altres objectes o matrius). Això correspon estretament a un Python. dict.

Una matriu en JavaScript (i JSON) és similar a una llista de Python: És una col·lecció ordenada de valors, que utilitza qualsevol tipus JSON vàlid. Junts, els objectes i les matrius es poden imbricar arbitràriament per modelar dades riques com ara perfils d'usuari, arbres de configuració o respostes d'API.

La correspondència entre els tipus JSON i els tipus Python és molt senzilla, i per això de vegades se sent a la gent anomenar-ho en broma "PYON" (Python Object Notation). Quan Python codifica o descodifica JSON, s'apliquen les correspondències següents:

• Objecte JSON → Pitó dict
• Matriu JSON → Pitó list
• Cadena JSON → Pitó str
• Número JSON (enter) → Pitó int
• Número JSON (real) → Pitó float
• JSON true → Pitó True
• JSON false → Pitó False
• JSON null → Pitó None

Una limitació important és que les claus dels objectes JSON sempre són cadenes de text, així que si codifiqueu un Python dict amb claus que no siguin de cadena (per exemple, nombres enters o tuples), aquestes claus es convertiran en cadenes o generaran errors segons la configuració. JSON és excel·lent per a la persistència de dades estructurades com ara configuracions o registres, però és no un mecanisme general de pickling per a objectes arbitraris de Python.

Mòdul JSON integrat de Python

Python inclou un mòdul de biblioteca estàndard anomenat json, que us proporciona tot el que necessiteu per treballar amb JSON: anàlisi de cadenes, càrrega des de fitxers, serialització d'objectes Python i personalització de la codificació i descodificació de les dades. No necessiteu cap dependència externa per a les tasques típiques de JSON.

Les quatre funcions bàsiques que utilitzaràs la major part del temps són: json.dumps() i json.dump() per convertir objectes de Python a JSON, i json.loads() i json.load() per tornar de JSON a tipus Python. Les versions amb "s" funcionen amb cadenes, mentre que les versions sense "s" funcionen amb objectes semblants a fitxers.

L' json el codificador admet un conjunt específic de tipus de Python per defecte, és a dir dict, list, tuple (com a matrius), str, números (int, float, i enumeracions derivades d'enters/float), i els tres singletons especials True, Falsei NoneAquests es converteixen als seus equivalents JSON segons el mapatge descrit anteriorment.

Si necessiteu serialitzar objectes o tipus de dades personalitzats, El disseny del mòdul és extensible: podeu crear una subclasse del codificador JSON i implementar-lo default() mètode o passar un mètode personalitzat default funció en json.dump() / json.dumps()Aquest hook personalitzat hauria de retornar alguna cosa serialitzable amb JSON (com ara un dict or list), o augmentar TypeError si no sap com manejar l'objecte donat.

Sota el capó, el mòdul també ofereix mètodes com ara encode() i iterencode(), que converteixen dades de Python a cadenes JSON, amb iterencode() generant les peces codificades de manera incremental. Aquestes s'utilitzen directament amb menys freqüència, però val la pena conèixer-les si necessiteu transmetre respostes JSON molt grans.

Conversió d'objectes de Python a JSON

Quan voleu convertir dades de Python en text JSON, feu servir json.dump() or json.dumps(), depenent de si voleu escriure directament a un fitxer o obtenir una cadena JSON a la memòria. Ambdues funcions comparteixen els mateixos paràmetres bàsics que us permeten controlar com es comporta la conversió.

La funció json.dump(obj, fp, ...) pren un objecte Python i un objecte semblant a un fitxer, i escriu una representació JSON de obj a aquest fitxer. La seva contrapart en memòria, json.dumps(obj, ...), retorna una cadena JSON en comptes d'escriure a un fitxer. Tots dos accepten una sèrie d'arguments de paraula clau com ara skipkeys, ensure_ascii, check_circular, allow_nan, indent, separators, defaulti sort_keys.

Cadascuna d'aquestes opcions modifica el comportament de la codificació de maneres que importen molt en projectes reals: podeu triar si voleu ometre les claus no vàlides, forçar la sortida ASCII, imprimir el resultat de manera bonica, controlar els espais en blanc, definir la serialització personalitzada per a objectes no estàndard o estabilitzar l'ordre de les claus per a proves i diferències.

Això és el que signifiquen els paràmetres principals en termes pràctics:

• skipkeys: si s'estableix a True, claus de diccionari que no són de tipus str, int, float, bool or None s'ometen silenciosament en comptes de pujar TypeErrorSi preferiu un comportament ràpid quan les claus són estranyes, deixeu-ho com False.
• ensure_ascii: Quan True (per defecte), els caràcters que no són ASCII i no imprimibles s'escapen (per exemple, com a \uXXXX) de manera que la sortida es manté en ASCII pur. Quan False, els caràcters Unicode s'escriuen tal com són, cosa que sol ser millor per a configuracions o registres llegibles per humans.
• check_circular: if True, el codificador comprova si hi ha referències circulars a les llistes, dictats i objectes codificats personalitzats per evitar la recursivitat infinita. Si s'estableix a False desactiva aquesta xarxa de seguretat i pot conduir a una RecursionError si les teves estructures són autoreferencials.
• allow_nan: if True, valors especials de coma flotant com ara NaN, Infinityi -Infinity estan permesos i codificats de manera compatible amb JavaScript, tot i que no són JSON estrictament vàlids segons l'especificació. Si False, intentar codificar aquests valors augmentarà ValueError.
• indent: un enter no negatiu (o una cadena) que controla la impressió bonica. Un nombre positiu significa que hi ha molts espais per nivell imbricat. Una cadena (com ara "\t") s'utilitza directament per a la indentació. None (per defecte) tria la representació més compacta, sense salts de línia addicionals més enllà del que cal.
• separators: una tupla (item_separator, key_separator) controlant la puntuació i els espais en blanc entre elements i entre claus i valors. Per al JSON més ajustat, normalment s'utilitza (",", ":") per eliminar tots els espais opcionals.
• default: una funció que rep qualsevol objecte que el codificador no sap com gestionar. Ha de retornar un reemplaçament serialitzable amb JSON (com ara un dict or list), o augmentar TypeErrorAquest és el ganxo principal per fer que les teves pròpies classes siguin serialitzables.
• sort_keys: if True, els diccionaris es codifiquen amb claus ordenades. Això és extremadament útil per a proves de regressió i sortides reproduïbles, on voleu que els dumps JSON siguin estables entre execucions.

Com a il·lustració concreta, imagineu que teniu una llista mixta de Python que conté nombres enters i un diccionari amb un nom, un identificador i una puntuació de coma flotant. Podríeu crear i emmagatzemar JSON així:

import pathlib
import json

path = pathlib.Path("myTextFile.json")
data =

with path.open(mode="wt") as f:
    json.dump(data, f)

print(json.dumps(data, indent=4))

El JSON imprès estarà ben formatat gràcies a indent=4, mostrant cada element de la llista i clau del diccionari a la seva pròpia línia. Això fa que la depuració i l'edició manual siguin molt més fàcils en comparació amb una sola línia de text densa.

Anàlisi de JSON de nou a Python

Per tornar del text JSON als objectes de Python, utilitzeu el parell de funcions corresponent: json.load() (per a objectes semblants a fitxers) i json.loads() (per a cadenes JSON). Aquestes funcions analitzen l'entrada i recreen els tipus Python segons la mateixa taula de mapatge que abans.

Les signatures tenen aproximadament aquest aspecte: json.load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw) i json.loads(s, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw)A un nivell bàsic, podeu cridar-los només amb l'entrada JSON, però els arguments addicionals obren la porta a un comportament d'anàlisi sintàctica més avançat.

Ganxos com object_hook i object_pairs_hook permet personalitzar com es converteixen els objectes JSON en estructures de Python, alimentant-te amb el descodificat dict o una llista de (key, value) parells respectivament. Això és útil si voleu crear classes personalitzades directament des de JSON o conservar l'ordre d'una manera específica.

Altres invocables com ara parse_float, parse_inti parse_constant us permeten controlar com s'interpreten els números i els tokens especials. Per exemple, podeu utilitzar Decimal en lloc de float per valors monetaris o transformar "NaN", "inf"i "-inf" en objectes sentinelles de la vostra elecció.

Continuant amb l'exemple anterior, podeu llegir el fitxer JSON que heu escrit així:

with path.open(mode="rt") as f:
    data = json.load(f)
print(data)

El resultat serà una llista i un diccionari normals de Python, per exemple , que podeu manipular amb totes les operacions habituals de Python. Des de la perspectiva del vostre codi, són "només dades" de nou.

Quins tipus de Python pot convertir a JSON

No tots els objectes de Python es poden convertir en JSON de seguida. per tant, és útil recordar el conjunt permès. Els codificadors pràctics admeten els tipus comuns de contenidor i escalar, a més de booleans i Nonei mapeu-los al conjunt mínim de tipus JSON.

Per defecte, podeu passar amb seguretat els següents objectes de Python a json.dumps():

• dict (codificat com a objectes JSON)
• list i tuple (codificat com a matrius JSON)
• str (codificat com a cadenes JSON)
• int i float (codificat com a números JSON)
• True i False (codificat com a true i false)
• None (codificat com a null)

Quan Python codifica aquests, el mapatge de tornada a JSON és senzill, i viceversa en descodificar. Per exemple, un Python tuple es converteix en una matriu JSON i obtens un list de nou a la càrrega. Enumeracions derivades de int or float també es poden codificar com a números.

Tota la resta necessita una personalització default manipulador (per convertir els objectes en una representació serialitzable) o provocarà TypeErrorAixò és per disseny: JSON està pensat per a dades, no per a gràfics d'objectes arbitraris amb comportament i mètodes com els que podríeu serialitzar utilitzant pickle.

Per a la majoria de la feina diària, aquest subconjunt de tipus cobreix la majoria de casos d'ús, incloent-hi càrregues útils d'API, arbres de configuració, preferències d'usuari, registres bàsics i petits fitxers "semblants a bases de dades" per a prototips o eines d'un sol usuari.

Impressió bonica, sortida compacta i tecles ordenades

La sortida JSON en brut sol ser completament vàlida però difícil de llegir, ja que sovint es genera sense espais en blanc innecessaris. Per a la depuració, el registre o la compartició amb altres desenvolupadors, sovint es vol un JSON llegible i amb sagnat en lloc d'un sol codi.

L' indent paràmetre de json.dumps() és la palanca principal per a una impressió bonica, que us permet dir a Python quants espais (o quina cadena) utilitzar per nivell d'indentació. Una opció típica és indent=4, tot i que algunes bases de codi prefereixen dos espais o caràcters de tabulació; les convencions estilístiques varien entre projectes.

L' separators l'argument et permet ajustar encara més els espais en blanc, donant una tupla com (", ", ": ") per defecte per a una sortida fàcil d'usar. Si voleu la representació més compacta possible (per exemple, per retallar la mida de la càrrega útil a la xarxa), podeu definir separators=(",", ":") per eliminar els espais després de les comes i els dos punts.

Quan us interessa la sortida determinista, per exemple en proves unitàries o comparacions d'instantànies, activació sort_keys=True fa que el codificador generi les claus del diccionari en ordre ordenat. D'aquesta manera, dues execucions que produeixen dades semànticament idèntiques no difereixen només perquè els diccionaris hagin generat claus en una seqüència diferent.

Junts, indent, separatorsi sort_keys et donen molt de control sobre si el vostre JSON està optimitzat per a màquines (compacte, sense espais en blanc) o per a humans (indentat, alineat, amb una forma estable entre execucions).

Dades imbricades, estratègies d'anàlisi sintàctica i patrons d'accés

En JSON del món real, les estructures planes són l'excepció; normalment es tracta d'objectes i matrius imbricats. Penseu en un registre d'usuari típic en una aplicació de comerç electrònic: informació personal, adreces d'enviament imbricades, detalls de facturació imbricats i potser una llista de comandes, cadascuna de les quals és una estructura complexa per si mateixa.

Quan es descodifica JSON en Python, les dades imbricades es converteixen en combinacions de diccionaris i llistes. i hi podeu accedir mitjançant cerques estàndard d'índex i clau. Per a estructures superficials, això és senzill: data, data, I així successivament.

Per a estructures profundament imbricades o dinàmiques, és possible que preferiu un enfocament més genèric, com ara escriure una petita funció recursiva que cerqui claus o que recorri un arbre de dicts i llistes. Les solucions recursives sovint són més curtes i fàcils de llegir que les iteratives quan es recorren dades imbricades arbitràriament.

És més fàcil accedir directament a JSON no imbricat (pla) amb claus codificades. cosa que pot anar perfectament bé per a petites utilitats o quan controleu completament l'entrada. Tanmateix, quan es consumeixen API externes, és habitual escriure petites funcions auxiliars que encapsulen l'estructura, de manera que no s'escampen cadenes per tota la base de codi.

Independentment de la profunditat, el mateix json.loads() s'aplica el comportament: La funció accepta una cadena JSON i produeix tipus Python nadius que després manipuleu amb eines Python normals. No cal cap sintaxi especial més enllà de la normal. dict i list indexació.

Treballar amb fitxers JSON: lectura, escriptura i addició

JSON és un format d'emmagatzematge lleuger i sorprenentment útil per a projectes petits, fitxers de configuració o scripts que necessiten mantenir un estat persistent. En comptes d'anar directament a una base de dades completa, sovint podeu utilitzar un o dos fitxers JSON durant força temps.

Escriure JSON a un fitxer sol ser un procés de dos passos: serialitzar dades de Python amb json.dumps() o directament amb json.dump()i, a continuació, assegureu-vos que la cadena resultant s'escriu al disc. Si truqueu open('data.json', 'w'), obteniu un identificador de fitxer en mode d'escriptura que crea el fitxer o el trunca si ja existeix.

Per a estructures imbricades, el protocol no és diferent de les dades planes: encara fas servir el mateix json.dump() crida, i les combinacions imbricades de llistes i dicts es codifiquen recursivament. L'única decisió que normalment cal prendre és quanta indentació es vol per a la llegibilitat en funció de la mida del fitxer.

Llegir JSON d'un fitxer és a l'invers: obrir el fitxer en mode text, passar l'objecte de fitxer a json.load(), i recuperes l'estructura de dades de Python. De nou, el comportament és independent de la profunditat de l'imbricació: el descodificador s'encarrega de tot això.

Si cal afegir dades JSON a fitxers existents, les coses es tornen més matisades. El JSON en si mateix no admet la "streaming append" de manera trivial perquè tot el fitxer ha de ser un JSON vàlid. Un patró comú és emmagatzemar una matriu de registres i llegir/modificar/escriure tota la matriu, o utilitzar JSON delimitat per línies on cada línia és un objecte JSON separat al qual es pot afegir sense reescriure les línies anteriors.

JSON al món real: API, emmagatzematge i intercanvi

Un cop comenceu a crear aplicacions reals, JSON es converteix ràpidament en el nexe que connecta clients i servidors web, microserveis i API de tercers. Es valora tant perquè és compacte com perquè els humans encara el poden llegir i editar amb una facilitat raonable.

En la interacció amb API, JSON és, amb diferència, el format de càrrega útil més comú. especialment en serveis RESTful. Les aplicacions Python solen utilitzar biblioteques com ara requests per enviar sol·licituds HTTP i rebre respostes JSON, i després analitza aquestes respostes amb json.loads() o amb mètodes auxiliars que l'embolcallin.

JSON també és un format popular per a fitxers de configuració i registres, on la seva naturalesa estructurada i de valor-clau el fa molt més expressiu que el text sense format, alhora que es manté simple en comparació amb les bases de dades completes. Els components del sistema poden compartir la configuració mitjançant JSON, i els agregadors de registres poden analitzar els registres JSON per filtrar-los o analitzar-los més fàcilment.

Un altre cas d'ús important és la serialització i la deserialització d'estructures de dades, convertint col·leccions en memòria en cadenes JSON (serialització) i reconstruint-les posteriorment (deserialització). D'aquesta manera s'emmagatzemen les preferències de l'usuari, es transmeten missatges estructurats a través de cues o s'envien objectes imbricats a través dels límits del servei, sempre que s'utilitzin tipus compatibles amb JSON o es proporcionin codificadors personalitzats.

Més enllà de JSON, el codi Python sovint necessita convertir entre JSON i altres formats, com ara XML, CSV o text sense format. Per exemple, podeu llegir CSV d'un sistema antic, transformar-lo en una llista de dicts i després abocar-lo com a JSON per a una API moderna. O podeu extreure JSON d'una API, normalitzar-lo i escriure CSV perquè els analistes el carreguin en fulls de càlcul.

Formatació, validació i operacions addicionals en JSON

Un cop us sentiu còmodes amb la lectura i l'escriptura bàsiques, hi ha un munt d'operacions petites però útils que podeu realitzar amb dades JSON per millorar el vostre flux de treball: formatar per a la llegibilitat, aplanar estructures imbricades, validar que una cadena realment és JSON i ordenar les dades per a comparacions coherents.

Impressió bonica amb json.dumps(..., indent=...) és el primer pas, oferint-vos jerarquies ben espaiades que faciliten la detecció de problemes estructurals d'un cop d'ull. Això és especialment útil durant la depuració o quan compartiu exemples a la documentació.

L'aplanament de JSON imbricat pot facilitar el processament i l'anàlisi posteriors, sobretot si cal convertir les dades en format tabular com ara CSV o introduir-les en eines que esperen parells clau-valor en lloc d'objectes imbricats profundament. Normalment, l'aplanament s'implementa mitjançant la recursivitat o el recorregut iteratiu sobre dicts i llistes.

Validar JSON sovint es redueix a intentar analitzar-lo i detectar excepcions, sobretot si només esteu verificant que una cadena és sintàcticament correcta. Per a comprovacions més rigoroses, podeu utilitzar esquema JSON i biblioteques externes, però en molts casos un simple try/except al voltant json.loads() és suficient.

Ordenar les dades JSON per valors o claus particulars pot ser útil a l'hora de comparar respostes. generant instantànies estables per a proves o simplement assegurant-vos que objectes similars estiguin agrupats. Podeu ordenar les llistes i els dictats subjacents de Python abans de fer el dump o confiar en sort_keys=True quan l'atenció se centra en l'ordre clau dins dels objectes.

Gestió d'errors en treballar amb JSON

Fins i tot els sistemes ben estructurats poden trobar JSON mal formats o dades inesperades. per tant, una gestió robusta d'errors al voltant de l'anàlisi i la codificació JSON és crucial. Python expressa aquests problemes mitjançant excepcions, i la manera idiomàtica de tractar-los és embolicar les operacions en try...except blocs.

Quan es descodifica JSON, el problema més comú és la sintaxi no vàlida. com ara cometes que falten al voltant dels noms de les propietats o comes finals. El/La json el mòdul generarà un error de descodificació (normalment json.JSONDecodeError), que podeu capturar i registrar o convertir en missatges fàcils d'utilitzar.

Per exemple, intentar analitzar una cadena trencada pot donar lloc a un error com ara: Failed to decode JSON: Expecting property name enclosed in double quotes: line 1 column 29 (char 28)Aquest tipus de missatge no només indica que l'anàlisi ha fallat, sinó també en quin punt de l'entrada s'ha confós l'analitzador.

Pel que fa a la codificació, podríeu trobar TypeError quan s'intenta serialitzar tipus no compatibles, or ValueError si ho rebutges NaN i infinits a través de allow_nan=False però les vostres dades contenen aquests valors. Les referències circulars en contenidors també poden activar RecursionError si desactiveu les comprovacions circulars.

La millor pràctica és tractar les operacions JSON com a E/S fal·libles. especialment quan es llegeix des de fonts de xarxa o fitxers externs: sempre s'assumeix que alguna cosa pot anar malament i es detecten les excepcions en conseqüència, possiblement afegint capes de validació per aplicar restriccions més específiques a les dades. json.loads() o mètodes auxiliars de l'API en try...except els blocs protegeixen la resta del codi de fallades en cascada i permeten tornar errors JSON fàcils d'usar als clients quan sigui oportú.

Ús de JSON amb API web en Python

La majoria de les API web amb què comuniqueu des de Python enviaran i rebran JSON, i la pila de desenvolupament típica combina el requests biblioteca (per a HTTP) amb la json mòdul (per analitzar i generar JSON). Aquesta combinació fa que la integració de l'API sembli molt natural.

Un patró comú és cridar un punt final de l'API, comprovar que el codi d'estat de la resposta indiqui un èxit i, a continuació, analitzar el cos JSON . Des d'allà podeu accedir als camps, gestionar dades imbricades i assignar la resposta als vostres propis models de domini o objectes de vista.

La gestió d'errors esdevé especialment important quan hi ha trucades de xarxa. perquè no només podeu trobar JSON no vàlid, sinó també temps d'espera, errors de connexió o errors del servidor que responen amb HTML en lloc de JSON. Acoblament json.loads() o mètodes auxiliars de l'API en try...except Els blocs protegeixen la resta del codi de fallades en cascada.

Un cop analitzada, l'API JSON es comporta igual que qualsevol altra estructura de dades de Python, de manera que totes les tècniques comentades anteriorment (impressió bonica, aplanament, validació, ordenació) s'apliquen directament. Sentir-se còmode movent-se entre dades de Python i JSON és un gran augment de la productivitat quan es connecten serveis. Si us centreu en la creació d'aplicacions reals , prestar atenció als patrons de gestió de JSON aviat estalviarà temps de depuració més endavant.

JSON a Python no es basa tant en una sola crida a una funció sinó més en una caixa d'eines: assignacions de tipus clares, paràmetres de codificació flexibles, hooks per a tipus personalitzats, E/S de fitxers senzilles però potents i patrons robustos per analitzar, formatar i validar dades del món exterior, tot això fa que JSON sigui una opció natural per als programadors de Python que treballen amb aplicacions modernes basades en dades.