Programmētāja ceļvedis Python datiem un JSON

Sākums » Pitons » Programmētāja ceļvedis Python datiem un JSON

JSON ir klusi kļuvis par noklusējuma valodu datiem tīmeklī, un, ja rakstāt Python, jūs ar to saskaraties visur: API, konfigurācijas failos, mazās "datubāzēs" blakusprojektiem, žurnālos un pat testēšanas iekārtās. Izpratne par to, kā Python datu tipi atbilst JSON un kā json Modulis tiešām darbojas, ir viena no tām prasmēm, kas pēkšņi vienkāršo daudzus ikdienas uzdevumus.

Šajā rokasgrāmatā ir aprakstīts JSON no Python programmētāja viedokļa. izskaidrojot, kas ir JSON, kā tas ir saistīts ar JavaScript, kādus Python tipus tas var attēlot, un kā parsēt, ģenerēt, skaisti izdrukāt, validēt un pielāgot JSON, izmantojot jsonMēs aplūkosim arī reālās pasaules lietošanas gadījumus, piemēram, darbu ar failiem un API, kā arī trikus ligzdotu datu apstrādei un perifēros gadījumus, piemēram, kļūdas vai īpašas vērtības, piemēram, NaN un bezgalības.

Kas ir JSON un kā tas ir saistīts ar Python datiem

JSON, saīsinājums no JavaScript Object Notation, ir teksta formāts strukturētiem datiem. kas sākotnēji aizguva savu sintaksi no JavaScript objektiem un masīviem. Neskatoties uz JavaScript saknēm, JSON ir valodas ziņā neitrāls un to atbalsta praktiski visas mūsdienu valodas, tostarp Python, padarot to ideāli piemērotu datu apmaiņai starp pakalpojumiem, klientiem un serveriem.

Konceptuāli JSON izmanto tikai divus saliktus pamatelementus: JavaScript objekts un JavaScript masīvsObjekts uzvedas līdzīgi kā Python vārdnīca, un masīvs uzvedas kā Python saraksts. Ar šiem diviem, kā arī nelielu primitīvo tipu kopu, JSON var aprakstīt sarežģītas ligzdotas datu struktūras.

Objekts JavaScript (un JSON) valodā izskatās šādi: {"key1": value1, "key2": value2}Tā ir atslēgu-vērtību pāru kolekcija, kur atslēgas ir virknes un vērtības var būt jebkura derīga JSON vērtība (ieskaitot citus objektus vai masīvus). Tas atbilst Python. dict.

Masīvs JavaScript (un JSON) valodā ir līdzīgs Python sarakstam: Tā ir sakārtota vērtību kolekcija, atkal izmantojot jebkuru derīgu JSON tipu. Objektus un masīvus var patvaļīgi ligzdot, lai modelētu bagātīgus datus, piemēram, lietotāju profilus, konfigurācijas kokus vai API atbildes.

JSON tipu un Python tipu kartēšana ir ļoti vienkārša, Tāpēc dažreiz dzird cilvēkus jokojot to saucam par “PYON” (Python Object Notation). Kad Python kodē vai dekodē JSON, ir spēkā šādas atbilstības:

• JSON objekts → Pitons dict
• JSON masīvs → Pitons list
• JSON virkne → Pitons str
• JSON numurs (vesels skaitlis) → Pitons int
• JSON numurs (reāls) → Pitons float
• JSON true → Pitons True
• JSON false → Pitons False
• JSON null → Pitons None

Viens svarīgs ierobežojums ir tas, ka JSON objektu atslēgas vienmēr ir virknes, tātad, ja jūs kodējat Python dict Izmantojot atslēgas, kas nav virknes (piemēram, veselus skaitļus vai kortežus), šīs atslēgas tiks piespiestas virkņu formātam vai radīs kļūdas atkarībā no jūsu iestatījumiem. JSON ir lieliski piemērots strukturētu datu, piemēram, konfigurāciju vai ierakstu, saglabāšanai, taču tas ir nav vispārējs kodināšanas mehānisms patvaļīgiem Python objektiem.

Python iebūvētais JSON modulis

Python komplektā ietilpst standarta bibliotēkas modulis ar nosaukumu json, kas nodrošina visu nepieciešamo darbam ar JSON: virkņu parsēšanu, ielādi no failiem, Python objektu serializēšanu un datu kodēšanas un dekodēšanas pielāgošanu. Tipiskiem JSON uzdevumiem nav nepieciešama ārēja atkarība.

Četras galvenās funkcijas, kuras izmantosiet visbiežāk, ir: json.dumps() un json.dump() lai konvertētu Python objektus uz JSON, un json.loads() un json.load() lai pārietu no JSON atpakaļ uz Python tipiem. “s” versijas darbojas ar virknēm, savukārt versijas bez “s” darbojas ar failiem līdzīgiem objektiem.

The json kodētājs pēc noklusējuma atbalsta noteiktu Python tipu kopu, proti dict, list, tuple (kā masīvi), str, skaitļi (int, floatun no veseliem/pludiņa skaitļiem atvasinātus uzskaitījumus), un trīs īpašos singletonus True, False, un NoneTie tiek konvertēti uz to JSON ekvivalentiem saskaņā ar iepriekš aprakstīto kartēšanu.

Ja nepieciešams serializēt pielāgotus objektus vai datu tipus, moduļa dizains ir paplašināms: jūs varat apakšklasēt JSON kodētāju un ieviest default() metodi vai nododiet pielāgotu default funkcionēt json.dump() / json.dumps()Šim pielāgotajam āķim vajadzētu atgriezt kaut ko JSON serializējamu (piemēram, dict or list) vai paaugstināt TypeError ja tas nezina, kā rīkoties ar doto objektu.

Zem pārsega modulis piedāvā arī tādas metodes kā encode() un iterencode(), kas konvertē Python datus uz JSON virknēm ar iterencode() iegūstot kodētās daļas pakāpeniski. Tie tiek retāk izmantoti tieši, taču par tiem ir vērts zināt, ja nepieciešams straumēt ļoti lielas JSON atbildes.

Python objektu konvertēšana uz JSON

Kad vēlaties pārvērst Python datus JSON tekstā, jūs izmantojat json.dump() or json.dumps(), atkarībā no tā, vai vēlaties rakstīt tieši failā vai iegūt JSON virkni atmiņā. Abām funkcijām ir vienādi pamatparametri, kas ļauj kontrolēt konvertēšanas darbību.

Funkcija json.dump(obj, fp, ...) ņem Python objektu un faila veida objektu, un raksta JSON attēlojumu obj uz šo failu. Tā atmiņā esošais analogs, json.dumps(obj, ...), atgriež JSON virkni, nevis raksta failā. Abas metodes pieņem virkni atslēgvārdu argumentu, piemēram, skipkeys, ensure_ascii, check_circular, allow_nan, indent, separators, default, un sort_keys.

Katra no šīm opcijām maina kodēšanas darbību veidos, kas ir ļoti svarīgi reālos projektos: Varat izvēlēties, vai izlaist nederīgas atslēgas, piespiest ASCII izvadi, izdrukāt rezultātu ar skaistu attēlu, kontrolēt atstarpes, definēt pielāgotu serializāciju nestandarta objektiem vai stabilizēt atslēgu secību testēšanai un diferenciāļiem.

Lūk, ko galvenie parametri nozīmē praksē:

• skipkeys: ja iestatīts uz True, vārdnīcas atslēgas, kas nav šāda veida str, int, float, bool or None tiek klusi izlaisti, nevis pacelti TypeErrorJa vēlaties ātru darbību, kad taustiņi ir dīvaini, atstājiet to kā norādīts. False.
• ensure_ascii: kad True (pēc noklusējuma), ne-ASCII un nedrukājamās rakstzīmes tiek atsoļotas (piemēram, kā \uXXXX), tāpēc izvade paliek tīra ASCII. Kad FalseUnikoda rakstzīmes tiek rakstītas “tādās, kādas tās ir”, kas parasti ir labāk piemērotas cilvēkam lasāmām konfigurācijām vai žurnāliem.
• check_circular: if True, kodētājs pārbauda apļveida atsauces sarakstos, diktātos un pielāgotos kodētos objektos, lai novērstu bezgalīgu rekursiju. Iestatot to uz False atspējo šo drošības tīklu un var novest pie RecursionError ja jūsu struktūras ir pašreferenciālas.
• allow_nan: if True, īpašas peldošā komata vērtības, piemēram, NaN, Infinity, un -Infinity ir atļauti un kodēti JavaScript saderīgā veidā, pat ja tie nav stingri derīgi JSON saskaņā ar specifikāciju. Ja False, mēģinot kodēt šādas vērtības, tiks paaugstināts ValueError.
• indent: nenegatīvs vesels skaitlis (vai virkne), kas kontrolē skaisto drukāšanu. Pozitīvs skaitlis nozīmē, ka katrā ligzdotajā līmenī ir daudz atstarpju. Virkne (piemēram, "\t") tiek izmantots tieši atkāpei. None (pēc noklusējuma) izvēlas viskompaktāko attēlojumu bez papildu jaunām rindiņām papildus nepieciešamajam.
• separators: kortežs (item_separator, key_separator) kontrolējot pieturzīmes un atstarpes starp vienumiem un starp atslēgām un vērtībām. Visprecīzākajam JSON parasti tiek izmantots (",", ":") lai noņemtu visas neobligātās atstarpes.
• default: funkcija, kas saņem jebkuru objektu, ar kuru kodētājs nezina, kā rīkoties. Tai ir jāatgriež JSON serializējams aizstājējs (piemēram, dict or list) vai paaugstināt TypeErrorŠis ir galvenais āķis, lai padarītu savas klases serializējamas.
• sort_keys: if True, vārdnīcas tiek kodētas ar sakārtotām atslēgām. Tas ir ārkārtīgi ērti regresijas testiem un reproducējamiem rezultātiem, kur vēlaties, lai JSON izgāztuves būtu stabilas dažādās palaišanas reizēs.

Kā konkrētu piemēru iedomājieties, ka jums ir jaukts Python saraksts. satur veselus skaitļus un vārdnīcu ar nosaukumu, ID un peldošā komata vērtību. JSON varētu izveidot un saglabāt šādi:

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

Izdrukātais JSON fails būs labi formatēts, pateicoties indent=4, parādot katru saraksta elementu un vārdnīcas atslēgu savā rindā. Tas ievērojami atvieglo atkļūdošanu un manuālu rediģēšanu, salīdzinot ar vienu, blīvu teksta rindu.

JSON parsēšana atpakaļ Python valodā

Lai atgrieztos no JSON teksta atpakaļ uz Python objektiem, jūs izmantojat atbilstošo funkciju pāri: json.load() (failiem līdzīgiem objektiem) un json.loads() (JSON virknēm). Šīs funkcijas parsē ievadi un atjauno Python tipus saskaņā ar to pašu kartēšanas tabulu kā iepriekš.

Paraksti izskatās aptuveni šādi: json.load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw) un json.loads(s, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw)Pamatlīmenī tos var izsaukt tikai ar JSON ievadi, taču papildu argumenti paver durvis uz sarežģītāku parsēšanas darbību.

Āķi, piemēram object_hook un object_pairs_hook ļauj pielāgot, kā JSON objekti tiek pārvērsti Python struktūrās, pasniedzot jums vai nu dekodēto dict vai saraksts ar (key, value) pāriem attiecīgi. Tas ir noderīgi, ja vēlaties veidot pielāgotas klases tieši no JSON vai saglabāt secību noteiktā veidā.

Citi izsaucamie elementi, piemēram, parse_float, parse_int, un parse_constant ļauj kontrolēt, kā tiek interpretēti skaitļi un īpašie žetoni. Piemēram, jūs varētu vēlēties izmantot Decimal vietā float naudas vērtībām vai pārveidot "NaN", "inf", un "-inf" jūsu izvēlētajos sardzes objektos.

Turpinot iepriekšējo piemēru, varat nolasīt JSON failu, ko uzrakstījāt, šādi:

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

Iegūtais rezultāts būs parasts Python saraksts un vārdnīca, piemēram , ko var manipulēt ar visām parastajām Python darbībām. No jūsu koda viedokļa tie atkal ir “tikai dati”.

Kādus tipus Python var konvertēt uz JSON

Ne katru Python objektu var uzreiz pārvērst JSON formātā, tāpēc ir lietderīgi atcerēties atļauto kopu. Praktiski kodētāji atbalsta izplatītos konteineru un skalāros tipus, kā arī Būla un Noneun kartējiet tos uz minimālo JSON tipu kopu.

Pēc noklusējuma jūs varat droši nodot šādus Python objektus json.dumps():

• dict (kodēti kā JSON objekti)
• list un tuple (kodēts kā JSON masīvi)
• str (kodēts kā JSON virknes)
• int un float (kodēti kā JSON skaitļi)
• True un False (kodēts kā true un false)
• None (kodēts kā null)

Kad Python kodē šos, kartēšana atpakaļ uz JSON ir vienkārša, un otrādi, dekodējot. Piemēram, Python tuple kļūst par JSON masīvu, un jūs iegūstat list atpakaļ ielādes laikā. Uzskaitījumi, kas iegūti no int or float var kodēt arī kā skaitļus.

Visam pārējam ir nepieciešama pielāgošana default apdarinātājs (lai objektus pārvērstu serializējamā attēlojumā) vai izraisīs TypeErrorTas ir paredzēts pēc būtības: JSON ir paredzēts datiem, nevis patvaļīgiem objektu grafikiem ar uzvedību un metodēm, piemēram, serializāciju, izmantojot pickle.

Lielākajā daļā ikdienas darba šī tipu apakškopa aptver lielāko daļu lietošanas gadījumu, tostarp API vērtumi, konfigurācijas koki, lietotāju preferences, pamata žurnāli un mazi “datubāzes tipa” faili prototipiem vai viena lietotāja rīkiem.

Skaista drukāšana, kompakta izvade un sakārtotas atslēgas

Neapstrādāta JSON izvade parasti ir pilnīgi derīga, bet grūti lasāma. jo tas bieži tiek ģenerēts bez liekas atstarpes. Kļūdu noteikšanai, reģistrēšanai vai koplietošanai ar citiem izstrādātājiem bieži vien ir nepieciešams lasāms, ievilkts JSON fails, nevis vienrindas teksts.

The indent parametrs json.dumps() ir galvenais sviras efekts skaistai drukāšanai, ļaujot jums norādīt Python, cik atstarpju (vai kādu virkni) izmantot katrā atkāpes līmenī. Tipiska izvēle ir indent=4, lai gan dažas koda bāzes dod priekšroku divām atstarpēm vai tabulēšanas rakstzīmēm; stilistiskās konvencijas dažādos projektos atšķiras.

The separators arguments ļauj vēl precīzāk noregulēt atstarpes, dodot kortežu, piemēram, (", ", ": ") pēc noklusējuma lietotājam draudzīgai izvadei. Ja vēlaties pēc iespējas kompaktāku attēlojumu, piemēram, lai samazinātu lietderīgās slodzes lielumu tīklā, varat iestatīt separators=(",", ":") lai noņemtu atstarpes pēc komatiem un koliem.

Ja jums rūp deterministiska izvade, piemēram, vienības testos vai momentuzņēmumu salīdzinājumos, aktivizējot sort_keys=True liek kodētājam izvadīt vārdnīcas atslēgas sakārtotā secībā. Tādā veidā divi izpildes cikli, kas ģenerē semantiski identiskus datus, neatšķiras tikai tāpēc, ka vārdnīcas izvadīja atslēgas citā secībā.

Kopā indent, separators, un sort_keys dod jums lielu kontroli par to, vai jūsu JSON ir optimizēts iekārtām (kompakts, bez atstarpēm) vai cilvēkiem (ar atkāpi, izlīdzināts, ar stabilu formu visās palaišanas reizēs).

Ligzdoti dati, parsēšanas stratēģijas un piekļuves modeļi

Reālajā pasaulē JSON valodā plakanas struktūras ir izņēmums; Parasti jums būs darīšana ar ligzdotiem objektiem un masīviem. Iedomājieties tipisku lietotāja ierakstu e-komercijas lietojumprogrammā: personiskā informācija, ligzdotas piegādes adreses, ligzdota norēķinu informācija un, iespējams, pasūtījumu saraksts, no kuriem katrs pats par sevi ir sarežģīta struktūra.

Atkodējot JSON Python valodā, ligzdotie dati kļūst par vārdnīcu un sarakstu kombinācijām, un jūs varat tam piekļūt, izmantojot standarta indeksu un atslēgu meklēšanu. Seklām struktūrām tas ir vienkārši: data, data, un tā tālāk.

Dziļi ligzdotām vai dinamiskām struktūrām jūs varētu vēlēties vispārīgāku pieeju, piemēram, nelielas rekursīvas funkcijas rakstīšana, kas meklē atslēgas vai staigā pa diktātu un sarakstu koku. Rekursīvie risinājumi bieži vien ir īsāki un vieglāk lasāmi nekā iteratīvie, šķērsojot patvaļīgi ligzdotus datus.

Neligzdotam (plakanam) JSON ir vieglāk piekļūt tieši, izmantojot cietkodētas atslēgas, kas var būt pilnīgi piemērots mazām utilītprogrammām vai tad, ja pilnībā kontrolējat ievadi. Tomēr, izmantojot ārējās API, ir ierasts rakstīt mazas palīgfunkcijas, kas iekapsulē struktūru, lai jūs to nekaisītu. ķēdes visā jūsu koda bāzē.

Neatkarīgi no dziļuma, tas pats json.loads() uzvedība ir spēkā: Funkcija pieņem JSON virkni un ģenerē vietējos Python tipus, kurus pēc tam var manipulēt ar parastajiem Python rīkiem. Nav nepieciešama īpaša sintakse papildus parastajai sintaksei. dict un list indeksēšana.

Darbs ar JSON failiem: lasīšana, rakstīšana un pievienošana

JSON nodrošina pārsteidzoši ērtu un vieglu glabāšanas formātu maziem projektiem, konfigurācijas failiem vai skriptiem, kuriem jāuztur pastāvīgs stāvoklis. Tā vietā, lai uzreiz meklētu pilnu datubāzi, bieži vien diezgan ilgu laiku var iztikt ar vienu vai diviem JSON failiem.

JSON ierakstīšana failā parasti ir divpakāpju process: serializēt Python datus ar json.dumps() vai tieši ar json.dump()un pēc tam pārliecinieties, vai iegūtā virkne tiek ierakstīta diskā. Ja izsaucat open('data.json', 'w'), rakstīšanas režīmā jūs saņemat faila turi, kas vai nu izveido failu, vai arī saīsina to, ja tāds jau pastāv.

Ligzdotām struktūrām protokols neatšķiras no plakanajiem datiem: tu joprojām lieto to pašu json.dump() izsaukums, un ligzdotās sarakstu un diktātu kombinācijas tiek kodētas rekursīvi. Vienīgais lēmums, kas parasti jāpieņem, ir tas, cik lielu atkāpi vēlaties lasāmības uzlabošanai, salīdzinot ar faila lielumu.

JSON lasīšana no faila ir apgriezta: atveriet failu teksta režīmā, nodot faila objektu json.load(), un jūs atgūstat savu Python datu struktūru. Atkal, uzvedība nav atkarīga no ligzdošanas dziļuma — dekodētājs visu to apstrādā jūsu vietā.

Ja jums ir jāpievieno JSON dati esošajiem failiem, Lietas kļūst niansētākas. Pats JSON neatbalsta “straumēšanas pievienošanu” vienkāršā veidā, jo visam failam ir jābūt derīgam JSON. Bieži tiek glabāts ierakstu masīvs un lasīt/modificēt/rakstīts viss masīvs vai izmantot ar rindām atdalītu JSON, kur katra rinda ir atsevišķs JSON objekts, kuram var pievienot, nepārrakstot iepriekšējās rindas.

JSON reālajā pasaulē: API, krātuve un apmaiņa

Kad sākat veidot reālas lietojumprogrammas, JSON ātri kļūst par saikni kas savieno tīmekļa klientus un serverus, mikropakalpojumus un trešo pušu API. Tas ir vērtīgs gan tāpēc, ka ir kompakts, gan tāpēc, ka cilvēki to joprojām var samērā viegli lasīt un rediģēt.

API mijiedarbībā JSON ir visizplatītākais lietderīgās slodzes formāts, īpaši RESTful pakalpojumos. Python lietojumprogrammas parasti izmanto tādas bibliotēkas kā requests lai nosūtītu HTTP pieprasījumus un saņemt JSON atbildes, pēc tam parsējiet šīs atbildes ar json.loads() vai ar palīgmetodēm, kas to aptver.

JSON ir arī populārs konfigurācijas failu un žurnālu formāts, kur tā strukturētā atslēgas-vērtības daba padara to daudz izteiksmīgāku nekā vienkāršs teksts, vienlaikus saglabājot vienkāršību salīdzinājumā ar pilnām datubāzēm. Sistēmas komponenti var koplietot konfigurāciju, izmantojot JSON, un žurnālu apkopotāji var parsēt JSON žurnālus, lai tos vieglāk filtrētu vai analizētu.

Vēl viens liels lietošanas gadījums ir datu struktūru serializācija un deserializācija, atmiņā esošo kolekciju konvertēšana JSON virknēs (serializācija) un pēc tam to rekonstrukcija vēlāk (deserializācija). Tādā veidā tiek saglabātas lietotāja preferences, pārsūtīt strukturētus ziņojumus caur rindām vai sūtīt ligzdotus objektus pāri pakalpojumu robežām, ja vien jūs izmantojat ar JSON saderīgus tipus vai nodrošināt pielāgotus kodētājus.

Papildus JSON vien, Python kodam bieži ir jāveic konvertēšana starp JSON un citiem formātiem, piemēram, XML, CSV vai vienkāršs teksts. Piemēram, jūs varat nolasīt CSV failu no mantotas sistēmas, pārveidot to par diktātu sarakstu un pēc tam izgūt kā JSON failu modernai API. Vai arī jūs varat izgūt JSON failu no API, normalizēt to un rakstīt CSV failu, lai analītiķi to varētu ielādēt izklājlapās.

JSON formatēšana, validācija un papildu darbības

Kad esat apguvis pamata lasīšanas un rakstīšanas prasmes, Ir virkne mazu, bet noderīgu darbību, ko varat veikt ar JSON datiem, lai uzlabotu savu darbplūsmu: formatēšana lasāmības uzlabošanai, ligzdotu struktūru saplacināšana, virknes JSON validācija un datu kārtošana konsekventai salīdzināšanai.

Skaista druka ar json.dumps(..., indent=...) ir pirmais solis, sniedzot jums ērti izvietotas hierarhijas, kas atvieglo strukturālu problēmu pamanīšanu uzreiz. Tas ir īpaši noderīgi atkļūdošanas laikā vai piemēru kopīgošanā dokumentācijā.

Ligzdotā JSON saplacināšana var atvieglot lejupējo apstrādi un analīzi, it īpaši, ja dati ir jāpārveido tabulas formātā, piemēram, CSV, vai jāievada rīkos, kas sagaida atslēgu-vērtību pārus, nevis dziļi ligzdotus objektus. Parasti saplacināšanu ieviešat pats, izmantojot rekursiju vai iteratīvu šķērsošanu diktātiem un sarakstiem.

JSON validēšana bieži vien nozīmē mēģinājumu to parsēt un noķert izņēmumus. it īpaši, ja jūs tikai pārbaudāt, vai virkne ir sintaktiski pareiza. Stingrākām pārbaudēm varat izmantot JSON shēmu un ārējās bibliotēkas, taču daudzos gadījumos vienkārša try/except apkārt json.loads() ir pietiekami.

JSON datu kārtošana pēc noteiktām vērtībām vai atslēgām var palīdzēt, salīdzinot atbildes. ģenerējot stabilus momentuzņēmumus testiem vai vienkārši nodrošinot, ka līdzīgi objekti ir grupēti kopā. Pirms izmešanas varat kārtot pamatā esošos Python sarakstus un diktātus vai paļauties uz sort_keys=True kad uzmanība tiek pievērsta atslēgu secībai objektos.

Kļūdu apstrāde, strādājot ar JSON

Pat labi strukturētas sistēmas var sastapties ar nepareizi veidotu JSON vai negaidītiem datiem, tāpēc stabila kļūdu apstrāde JSON parsēšanas un kodēšanas laikā ir ļoti svarīga. Python šīs problēmas izsaka, izmantojot izņēmumus, un idiomātiskais veids, kā tās risināt, ir ietvert darbības try...except bloki.

Atšifrējot JSON, visbiežāk sastopamā problēma ir nederīga sintakse, piemēram, trūkstošas ​​pēdiņas ap īpašību nosaukumiem vai komati beigās. json modulis radīs dekodēšanas kļūdu (parasti json.JSONDecodeError), kurus varat uztvert un reģistrēt vai pārveidot lietotājam draudzīgos ziņojumos.

Piemēram, mēģinot parsēt bojātu virkni, var rasties šāda kļūda: Failed to decode JSON: Expecting property name enclosed in double quotes: line 1 column 29 (char 28)Šāda veida ziņojums norāda ne tikai to, ka parsēšana neizdevās, bet arī to, kur ievades vietā parsētājs nonāca neskaidrībā.

Kodēšanas pusē jūs varētu trāpīt TypeError mēģinot serializēt neatbalstītus tipus, or ValueError ja jūs neatļaujat NaN un bezgalības caur allow_nan=False taču jūsu dati satur šādas vērtības. Apļveida atsauces konteineros var arī izraisīt RecursionError ja atspējojat apļveida pārbaudes.

Labākā prakse ir uzskatīt JSON operācijas par kļūdainām I/O darbībām, īpaši lasot no tīkla avotiem vai ārējiem failiem: vienmēr pieņemiet, ka kaut kas varētu noiet greizi, un attiecīgi fiksējiet izņēmumus, iespējams, pievienojot validācijas slāņus, lai ieviestu specifiskākus ierobežojumus jūsu datiem. json.loads() vai API palīgmetodes try...except bloki aizsargā pārējo kodu no kaskādes kļūmēm un ļauj atgriezties lietotājam draudzīgas JSON kļūdas klientiem, kad tas ir piemēroti.

JSON izmantošana ar tīmekļa API valodā Python

Lielākā daļa tīmekļa API, ar kurām sazināties no Python, nosūtīs un saņems JSON, un tipiskais izstrādes steks apvieno requests bibliotēka (HTTP) ar json modulis (JSON parsēšanai un ģenerēšanai). Šī kombinācija padara API integrāciju ļoti dabisku.

Bieži sastopama shēma ir API galapunkta izsaukšana, pārbaudiet, vai atbildes statusa kods norāda uz panākumiem, un pēc tam parsēt JSON pamattekstuNo turienes varat piekļūt laukiem, apstrādāt ligzdotus datus un kartēt atbildi savos domēna modeļos vai skata objektos.

Kļūdu apstrāde kļūst īpaši svarīga, ja ir iesaistīti tīkla zvani, jo var rasties ne tikai nederīgs JSON, bet arī taimauti, savienojuma kļūdas vai servera puses kļūmes, kas atbild ar HTML, nevis JSON. Ietīšana json.loads() vai API palīgmetodes try...except bloki aizsargā pārējo kodu no kaskādes kļūmēm.

Pēc parsēšanas API JSON darbojas tāpat kā jebkura cita Python datu struktūra, tātad visas iepriekš apspriestās metodes — skaista drukāšana, saplacināšana, validācija, kārtošana — ir tieši piemērojamas. Ērta pārslēgšanās starp Python datiem un JSON ievērojami palielina produktivitāti, savienojot pakalpojumus kopā. Ja jūs koncentrējaties uz reālu lietojumprogrammu veidošana, pievēršot uzmanību JSON apstrādes modeļiem agrīnā stadijā, vēlāk ietaupīsiet atkļūdošanas laiku.

JSON Python valodā ir mazāk par vienu funkcijas izsaukumu un vairāk par rīklodziņu: Skaidras tipu kartēšanas, elastīgi kodēšanas parametri, pielāgotu tipu piesaistes, vienkārša, bet jaudīga failu ievade/izvade un stabili modeļi datu parsēšanai, formatēšanai un validēšanai no ārpasaules — tas viss padara JSON par dabisku piemērotību Python programmētājiem, kas strādā ar modernām datu vadītām lietojumprogrammām.