Programmørens guide til Python-data og JSON

Hjem » Python » Programmørens guide til Python-data og JSON

JSON er stille og roligt blevet standardsproget for data på nettet, og hvis du skriver Python, støder du på det overalt: API'er, konfigurationsfiler, små "databaser" til sideprojekter, logfiler og endda testfixtures. Forståelse af, hvordan Pythons datatyper knyttes til JSON, og hvordan json modulet virkelig virker er en af ​​de færdigheder, der pludselig gør mange hverdagsopgaver enklere.

Denne guide gennemgår JSON fra en Python-programmørs synspunkt, forklarer, hvad JSON er, hvordan det relaterer sig til JavaScript, hvilke Python-typer det kan repræsentere, og hvordan man parser, genererer, pretty-printer, validerer og tilpasser JSON ved hjælp af jsonVi vil også se på virkelige use cases, som f.eks. at arbejde med filer og API'er, plus tricks til at håndtere indlejrede data og edge cases, f.eks. fejl eller særlige værdier. NaN og uendeligheder.

Hvad JSON er, og hvordan det relaterer sig til Python-data

JSON, en forkortelse for JavaScript Object Notation, er et tekstformat til strukturerede data der oprindeligt lånte sin syntaks fra JavaScript-objekter og -arrays. Trods JavaScript-rødderne er JSON sproguafhængig og understøttes af stort set alle moderne sprog, inklusive Python, hvilket gør det ideelt til udveksling af data mellem tjenester, klienter og servere.

Konceptuelt bruger JSON kun to sammensatte byggesten: JavaScript-koden objekt og JavaScript-koden matrixEt objekt opfører sig meget ligesom en Python-ordbog, og et array opfører sig som en Python-liste. Med disse to, plus et lille sæt primitive typer, kan JSON beskrive komplekse indlejrede datastrukturer.

Et objekt i JavaScript (og JSON) ser sådan ud: {"key1": value1, "key2": value2}Det er en samling af nøgle-værdi-par, hvor nøgler er strenge, og værdier kan være enhver gyldig JSON-værdi (inklusive andre objekter eller arrays). Dette svarer nøje til en Python-fil. dict.

Et array i JavaScript (og JSON) ligner en Python-liste: Det er en ordnet samling af værdier, igen ved hjælp af en hvilken som helst gyldig JSON-type. Objekter og arrays kan indlejres vilkårligt sammen for at modellere omfattende data såsom brugerprofiler, konfigurationstræer eller API-svar.

Kortlægningen mellem JSON-typer og Python-typer er meget ligetil, Derfor hører man sommetider folk spøgefuldt kalde det "PYON" (Python Object Notation). Når Python koder eller afkoder JSON, gælder følgende korrespondancer:

• JSON-objekt → Python dict
• JSON-matrix → Python list
• JSON-streng → Python str
• JSON-nummer (heltal) → Python int
• JSON-nummer (reelt) → Python float
• JSON true → Python True
• JSON false → Python False
• JSON null → Python None

En vigtig begrænsning er, at JSON-objektnøgler altid er strenge, så hvis du koder en Python dict Med nøgler, der ikke er strenge (f.eks. heltal eller tupler), vil disse nøgler blive tvunget til at være strenge eller forårsage fejl afhængigt af dine indstillinger. JSON er fantastisk til at bevare strukturerede data som konfigurationer eller poster, men det er ikke en generel pickling-mekanisme for vilkårlige Python-objekter.

Pythons indbyggede json-modul

Python leveres med et standardbiblioteksmodul kaldet json, hvilket giver dig alt hvad du behøver for at arbejde med JSON: parsing af strenge, indlæsning fra filer, serialisering af Python-objekter og tilpasning af, hvordan data kodes og afkodes. Du behøver ingen eksterne afhængigheder til typiske JSON-opgaver.

De fire kernefunktioner, du vil bruge det meste af tiden, er: json.dumps() og json.dump() til at konvertere Python-objekter til JSON, og json.loads() og json.load() for at gå fra JSON tilbage til Python-typer. "S"-versionerne fungerer med strenge, mens versionerne uden "s" fungerer med fillignende objekter.

json encoder understøtter som standard et specifikt sæt Python-typer, nemlig dict, list, tuple (som arrays), str, tal (int, floatog heltals-/float-afledte enums) og de tre specielle singletons True, Falseog NoneDisse konverteres til deres JSON-ækvivalenter i henhold til den tidligere beskrevne kortlægning.

Hvis du har brug for at serialisere brugerdefinerede objekter eller datatyper, Modulets design er udvideligt: ​​du kan underklasse JSON-encoderen og implementere default() metode, eller send en brugerdefineret default funktion i json.dump() / json.dumps()Den brugerdefinerede hook skal returnere noget, der kan serialiseres med JSON (som en dict or list), eller hæv TypeError hvis den ikke ved, hvordan den skal håndtere det givne objekt.

Under motorhjelmen tilbyder modulet også metoder som f.eks. encode() og iterencode(), som konverterer Python-data til JSON-strenge, med iterencode() hvilket giver de kodede dele trinvis. Disse bruges mindre almindeligt direkte, men er værd at kende til, hvis du har brug for at streame meget store JSON-svar.

Konvertering af Python-objekter til JSON

Når du vil konvertere Python-data til JSON-tekst, bruger du json.dump() or json.dumps(), afhængigt af om du vil skrive direkte til en fil eller hente en JSON-streng i hukommelsen. Begge funktioner deler de samme kerneparametre, der giver dig mulighed for at kontrollere, hvordan konverteringen opfører sig.

funktionen json.dump(obj, fp, ...) tager et Python-objekt og et fillignende objekt, og skriver en JSON-repræsentation af obj til den fil. Dens modstykke i hukommelsen, json.dumps(obj, ...), returnerer en JSON-streng i stedet for at skrive til en fil. De accepterer begge en række nøgleordsargumenter, f.eks. skipkeys, ensure_ascii, check_circular, allow_nan, indent, separators, defaultog sort_keys.

Hver af disse muligheder justerer kodningens adfærd på måder, der er meget vigtige i virkelige projekter: Du kan vælge, om du vil springe ugyldige nøgler over, gennemtvinge ASCII-output, pretty-printe resultatet, kontrollere whitespace, definere brugerdefineret serialisering for ikke-standardobjekter eller stabilisere nøglerækkefølge til test og diffs.

Her er hvad de vigtigste parametre betyder i praksis:

• skipkeys: hvis indstillet til True, ordbogsnøgler, der ikke er af typen str, int, float, bool or None springes lydløst over i stedet for at hæve TypeErrorHvis du foretrækker fejlhurtig opførsel, når tasterne er mærkelige, skal du lade den være som False.
• ensure_ascii: hvornår True (standard), ikke-ASCII-tegn og ikke-udskrivbare tegn escapes (f.eks. som \uXXXX) så outputtet forbliver ren ASCII. Når FalseUnicode-tegn skrives som de er, hvilket normalt er bedre til menneskelæsbare konfigurationer eller logfiler.
• check_circular: if True, kontrollerer encoderen for cirkulære referencer i lister, diktater og brugerdefinerede kodede objekter for at forhindre uendelig rekursion. Indstiller den til False deaktiverer dette sikkerhedsnet og kan føre til en RecursionError hvis dine strukturer er selvrefererende.
• allow_nan: if True, specielle flydende kommaværdier som f.eks. NaN, Infinityog -Infinity er tilladt og kodet på en JavaScript-kompatibel måde, selvom de ikke er strengt gyldige JSON ifølge specifikationen. Hvis False, forsøg på at kode sådanne værdier vil øge ValueError.
• indent: et ikke-negativt heltal (eller en streng), der styrer smuk udskrivning. Et positivt tal betyder, at mange mellemrum pr. indlejret niveau. En streng (som "\t") bruges direkte til indrykning. None (standardindstillingen) vælger den mest kompakte repræsentation uden ekstra linjeskift ud over hvad der er nødvendigt.
• separators: en tuple (item_separator, key_separator) styring af tegnsætning og mellemrum mellem elementer og mellem nøgler og værdier. For den tætteste JSON bruger du typisk (",", ":") for at fjerne alle valgfrie mellemrum.
• default: en funktion, der modtager et objekt, som encoderen ikke ved, hvordan den skal håndtere. Den skal returnere en JSON-serialiserbar erstatning (som en dict or list), eller hæv TypeErrorDette er den primære metode til at gøre dine egne klasser serialiserbare.
• sort_keys: if True, ordbøger er kodet med sorterede nøgler. Dette er yderst praktisk til regressionstest og reproducerbare output, hvor man ønsker, at JSON-dumps skal være stabile på tværs af kørsler.

Som en konkret illustration kan du forestille dig, at du har en blandet Python-liste indeholder heltal og en ordbog med et navn, et id og en flydende komma-score. Du kan oprette og gemme JSON således:

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))

Den udskrevne JSON vil være pænt formateret takket være indent=4, viser hvert listeelement og ordbogsnøgle på sin egen linje. Dette gør fejlfinding og manuel redigering meget nemmere sammenlignet med en enkelt, tæt tekstlinje.

Parsing af JSON tilbage i Python

For at gå fra JSON-tekst tilbage til Python-objekter, du bruger det matchende funktionspar: json.load() (for fillignende objekter) og json.loads() (for JSON-strenge). Disse funktioner analyserer inputtet og genskaber Python-typer i henhold til den samme mapping-tabel som før.

Signaturerne ser nogenlunde sådan ud: json.load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw) og json.loads(s, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw)På et grundlæggende niveau kan du kalde dem med blot JSON-inputtet, men de ekstra argumenter åbner døren for mere avanceret parsing-adfærd.

Kroge som object_hook og object_pairs_hook lader dig tilpasse, hvordan JSON-objekter omdannes til Python-strukturer, ved at give dig enten den afkodede dict eller en liste over (key, value) par henholdsvis. Dette er nyttigt, hvis du vil opbygge brugerdefinerede klasser direkte fra JSON eller bevare rækkefølgen på en bestemt måde.

Andre konverterbare værdier såsom parse_float, parse_intog parse_constant giver dig mulighed for at kontrollere, hvordan tal og særlige tokens fortolkes. For eksempel kan du bruge Decimal i stedet for float for monetære værdier, eller transformere "NaN", "inf"og "-inf" til vagtobjekter efter eget valg.

I forlængelse af det tidligere eksempel kan du læse den JSON-fil, du skrev, således:

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

Det resulterende output vil være en almindelig Python-liste og ordbog, for eksempel , som du kan manipulere med alle de sædvanlige Python-operationer. Fra din kodes perspektiv er det igen "bare data".

Hvilke typer Python kan konvertere til JSON

Ikke alle Python-objekter kan omdannes til JSON med det samme, så det er nyttigt at huske det tilladte sæt. Praktiske encodere understøtter de almindelige container- og skalartyper, plus boolske værdier og Noneog knytte dem til det minimale sæt af JSON-typer.

Som standard kan du trygt overføre følgende Python-objekter til json.dumps():

• dict (kodet som JSON-objekter)
• list og tuple (kodet som JSON-arrays)
• str (kodet som JSON-strenge)
• int og float (kodet som JSON-tal)
• True og False (kodet som true og false)
• None (kodet som null)

Når Python koder disse, er mappingen tilbage til JSON ligetil, og omvendt ved afkodning. For eksempel en Python tuple bliver et JSON-array, og du får et list tilbage på indlæsning. Enums afledt fra int or float kan også kodes som tal.

Alt andet kræver enten en specialfremstilling default handleren (for at omdanne objekter til en serialiserbar repræsentation) eller vil forårsage TypeErrorDette er designet: JSON er beregnet til data, ikke til vilkårlige objektgrafer med adfærd og metoder, som man kunne serialisere med pickle.

For det meste af det daglige arbejde dækker denne delmængde af typer størstedelen af ​​​​anvendelsessager, inklusive API-nyttelast, konfigurationstræer, brugerpræferencer, grundlæggende logfiler og små "databaselignende" filer til prototyper eller enkeltbrugerværktøjer.

Smuk udskrivning, kompakt output og ordnede taster

Rå JSON-output er typisk fuldt gyldigt, men svært at læse. da den ofte genereres uden unødvendigt mellemrum. Til fejlfinding, logføring eller deling med andre udviklere ønsker du ofte læsbar, indrykket JSON i stedet for en one-liner.

indent parameter af json.dumps() er den vigtigste løftestang til smukt tryk, så du kan fortælle Python, hvor mange mellemrum (eller hvilken streng) der skal bruges pr. indrykningsniveau. Et typisk valg er indent=4, selvom nogle kodebaser foretrækker to mellemrum eller tabulatortegn, varierer stilistiske konventioner mellem projekter.

separators argumentet giver dig mulighed for at finjustere mellemrum yderligere, giver en tuple som (", ", ": ") som standard for brugervenligt output. Hvis du ønsker den mest kompakte repræsentation som muligt – for eksempel for at trimme nyttelaststørrelsen over netværket – kan du indstille separators=(",", ":") at fjerne mellemrum efter kommaer og kolon.

Når du er interesseret i deterministisk output, for eksempel i enhedstests eller snapshot-sammenligninger, aktivering sort_keys=True får encoderen til at udskrive ordbogsnøgler i sorteret rækkefølge. På den måde adskiller to kørsler, der producerer semantisk identiske data, sig ikke, bare fordi ordbøger tilfældigvis udsender nøgler i forskellig rækkefølge.

Sammen, indent, separatorsog sort_keys give dig en masse kontrol om din JSON er optimeret til maskiner (kompakt, ingen mellemrum) eller til mennesker (indrykket, justeret, med en stabil form på tværs af kørsel).

Indlejrede data, parsingstrategier og adgangsmønstre

I JSON i den virkelige verden er flade strukturer undtagelsen; Du vil normalt have at gøre med indbyggede objekter og arrays. Tænk på en typisk brugerpost i en e-handelsapplikation: personlige oplysninger, indbyggede leveringsadresser, indbyggede faktureringsoplysninger og måske en liste over ordrer, som hver især er en kompleks struktur i sig selv.

Når JSON afkodes til Python, bliver indlejrede data til kombinationer af ordbøger og lister, og du kan tilgå den ved hjælp af standard indeks- og nøgleopslag. For overfladiske strukturer er dette ligetil: data, data, og så videre.

For dybt indlejrede eller dynamiske strukturer foretrækker du måske en mere generisk tilgang, såsom at skrive en lille rekursiv funktion, der søger efter nøgler, eller som gennemgår et træ af diktater og lister. Rekursive løsninger er ofte kortere og lettere at læse end iterative løsninger, når man gennemløber vilkårligt indlejrede data.

Ikke-indlejret (flad) JSON er nemmere at tilgå direkte med hardcodede nøgler, hvilket kan være helt fint for små forsyningsvirksomheder, eller når du har fuld kontrol over inputtet. Når man bruger eksterne API'er, er det dog almindeligt at skrive små hjælpefunktioner, der indkapsler strukturen, så man ikke drysser kæder på tværs af hele din kodebase.

Uanset dybden, den samme json.loads() adfærd gælder: Funktionen accepterer en JSON-streng og producerer native Python-typer, som du derefter manipulerer med almindelige Python-værktøjer. Der kræves ingen særlig syntaks ud over normal dict og list indeksering.

Arbejde med JSON-filer: Læsning, skrivning og tilføjelse

JSON laver et overraskende praktisk letvægtslagringsformat til små projekter, konfigurationsfiler eller scripts, der skal bevare en eller anden vedvarende tilstand. I stedet for at række direkte ud efter en fuld database, kan man ofte slippe afsted med en eller to JSON-filer i et stykke tid.

At skrive JSON til en fil er normalt en proces i to trin: serialiser Python-data med json.dumps() eller direkte med json.dump(), og sørg derefter for, at den resulterende streng skrives til disken. Hvis du kalder open('data.json', 'w'), får du et filhandle i skrivetilstand, der enten opretter filen eller afkorter den, hvis den allerede findes.

For indlejrede strukturer er protokollen ikke anderledes end flade data: du bruger stadig det samme json.dump() opkald, og de indlejrede kombinationer af lister og diktater kodes rekursivt. Den eneste beslutning, du normalt skal træffe, er, hvor meget indrykning du ønsker for læsbarhed versus filstørrelse.

At læse JSON fra en fil er omvendt: åbn filen i teksttilstand, send filobjektet til json.load(), og du får din Python-datastruktur tilbage. Igen er adfærden uafhængig af hvor dybt nestingen går – dekoderen håndterer alt det for dig.

Hvis du har brug for at tilføje JSON-data til eksisterende filer, Tingene bliver mere nuancerede. JSON i sig selv understøtter ikke "streaming append" på en triviel måde, fordi hele filen skal være gyldig JSON. Et almindeligt mønster er at gemme et array af poster og læse/ændre/skrive til hele arrayet, eller at bruge linjesepareret JSON, hvor hver linje er et separat JSON-objekt, som du kan tilføje til uden at omskrive tidligere linjer.

JSON i den virkelige verden: API'er, lagring og udveksling

Når du først begynder at bygge rigtige applikationer, bliver JSON hurtigt limen der forbinder webklienter og -servere, mikrotjenester og tredjeparts-API'er. Den er værdsat både fordi den er kompakt, og fordi mennesker stadig kan læse og redigere den rimelig nemt.

I API-interaktion er JSON langt det mest almindelige payloadformat, især i RESTful-tjenester. Python-applikationer bruger typisk biblioteker som requests at sende HTTP-anmodninger og modtage JSON-svar, og parser derefter disse svar med json.loads() eller med hjælpemetoder, der omslutter det.

JSON er også et populært format til konfigurationsfiler og logfiler, hvor dens strukturerede nøgleværdi-natur gør den langt mere udtryksfuld end almindelig tekst, samtidig med at den forbliver enkel sammenlignet med komplette databaser. Systemkomponenter kan dele konfiguration via JSON, og logaggregatorer kan analysere JSON-logfiler for lettere at filtrere eller analysere dem.

Et andet vigtigt anvendelsesscenarie er serialisering og deserialisering af datastrukturer, konvertere in-memory-samlinger til JSON-strenge (serialisering) og derefter rekonstruere dem senere (deserialisering). Sådan gemmer du brugerpræferencer, overføre strukturerede beskeder gennem køer eller send indbyggede objekter på tværs af tjenestegrænser, forudsat at du holder dig til JSON-kompatible typer eller leverer brugerdefinerede encodere.

Ud over JSON alene skal Python-kode ofte konvertere mellem JSON og andre formater, såsom XML, CSV eller almindelig tekst. For eksempel kan du læse CSV fra et ældre system, transformere det til en liste over diktater og derefter dumpe det som JSON til en moderne API. Eller du kan hente JSON fra en API, normalisere det og skrive CSV, som analytikere kan indlæse i regneark.

Formatering, validering og ekstra operationer på JSON

Når du er blevet fortrolig med grundlæggende læsning og skrivning, Der er en række små, men nyttige handlinger, du kan udføre på JSON-data for at forbedre din arbejdsgang: formatering for læsbarhed, udjævning af indbyggede strukturer, validering af, at en streng virkelig er JSON, og sortering af data for konsistente sammenligninger.

Smukt print med json.dumps(..., indent=...) er det første skridt, hvilket giver dig pænt fordelte hierarkier, der gør det nemmere at få øje på strukturelle problemer med et hurtigt blik. Dette er især nyttigt under fejlfinding eller når du deler eksempler i dokumentation.

Udfladning af indlejret JSON kan gøre downstream-behandling og -analyse nemmere. især hvis du har brug for at konvertere dataene til tabelform som CSV eller indtaste dem i værktøjer, der forventer nøgle-værdi-par i stedet for dybt indlejrede objekter. Du implementerer typisk selv fladning ved hjælp af rekursion eller iterativ gennemgang af diktater og lister.

Validering af JSON handler ofte om at forsøge at parse det og fange undtagelser, især hvis du bare verificerer, at en streng er syntaktisk korrekt. For mere grundige kontroller kan du bruge JSON Schema og eksterne biblioteker, men i mange tilfælde en simpel try/except omkring json.loads() er nok.

Sortering af JSON-data efter bestemte værdier eller nøgler kan hjælpe, når man sammenligner svar, generere stabile snapshots til tests, eller blot sørge for, at lignende objekter grupperes sammen. Du kan enten sortere de underliggende Python-lister og diktater før dumping eller stole på sort_keys=True når fokus er på nøgleorden i objekter.

Fejlhåndtering ved arbejde med JSON

Selv velstrukturerede systemer kan støde på misdannede JSON-filer eller uventede data. så robust fejlhåndtering omkring JSON-parsing og -kodning er afgørende. Python udtrykker disse problemer via undtagelser, og den idiomatiske måde at håndtere dem på er at pakke operationer ind i try...except blokke.

Når man afkoder JSON, er det mest almindelige problem ugyldig syntaks, såsom manglende anførselstegn omkring ejendomsnavne eller efterfølgende kommaer. json modulet vil give en afkodningsfejl (typisk json.JSONDecodeError), som du kan fange og logge eller konvertere til brugervenlige beskeder.

For eksempel kan det resultere i en fejl som: at forsøge at parse en brudt streng: Failed to decode JSON: Expecting property name enclosed in double quotes: line 1 column 29 (char 28)Denne type besked fortæller dig ikke blot, at parsningen mislykkedes, men også hvor i inputtet parseren blev forvirret.

På kodningssiden kan du støde på TypeError når man forsøger at serialisere ikke-understøttede typer, or ValueError hvis du forbyder NaN og uendeligheder via allow_nan=False men dine data indeholder sådanne værdier. Cirkulære referencer i containere kan også udløse RecursionError hvis du deaktiverer cirkulære kontroller.

Bedste praksis er at behandle JSON-operationer som fejlbarlige I/O, Især når du læser fra netværkskilder eller eksterne filer: Antag altid, at noget kan gå galt, og find undtagelser i overensstemmelse hermed, og tilføj muligvis valideringslag for at håndhæve mere specifikke begrænsninger på dine data. json.loads() eller API-hjælpemetoder i try...except blokke beskytter resten af ​​din kode mod kaskadefejl og lader dig vende tilbage brugervenlige JSON-fejl til klienter, når det er passende.

Brug af JSON med web-API'er i Python

De fleste web-API'er, du kommunikerer med fra Python, vil sende og modtage JSON, og den typiske udviklingsstak kombinerer requests bibliotek (til HTTP) med json modul (til parsing og generering af JSON). Denne kombination gør API-integration meget naturlig.

Et almindeligt mønster er at kalde et API-slutpunkt, kontroller, at svarstatuskoden angiver succes, og derefter parse JSON-kroppenDerfra kan du få adgang til felter, håndtere indlejrede data og kortlægge svaret i dine egne domænemodeller eller se objekter.

Fejlhåndtering bliver ekstra vigtig, når der er tale om netværksopkald, fordi du kan støde på ikke blot ugyldig JSON, men også timeouts, forbindelsesfejl eller serversidefejl, der reagerer med HTML i stedet for JSON. json.loads() eller API-hjælpemetoder i try...except blokke beskytter resten af ​​din kode mod kaskadefejl.

Når den er parset, opfører API JSON sig præcis som enhver anden Python-datastruktur, så alle de teknikker, der er diskuteret tidligere – pretty printing, flattening, validering, sortering – gælder direkte. At være tryg ved at skifte mellem Python-data og JSON er et enormt produktivitetsløft, når du forbinder tjenester. Hvis du fokuserer på at bygge rigtige applikationerAt være opmærksom på JSON-håndteringsmønstre tidligt vil spare fejlfindingstid senere.

JSON i Python handler mindre om et enkelt funktionskald og mere om en værktøjskasse: Tydelige typetilknytninger, fleksible kodningsparametre, hooks til brugerdefinerede typer, simpel, men kraftfuld fil-I/O og robuste mønstre til parsing, formatering og validering af data fra omverdenen, alt sammen noget, der gør JSON til et naturligt valg for Python-programmører, der arbejder med moderne datadrevne applikationer.