Gabay ng Programmer sa Data ng Python at JSON

Tahanan » Python » Gabay ng Programmer sa Data at JSON ng Python

Tahimik na naging default na wika ang JSON para sa data sa web, at kung nagsusulat ka ng Python, makakasalubong mo ito kahit saan: mga API, mga configuration file, maliliit na "database" para sa mga side project, mga log, at maging ang mga test fixture. Pag-unawa kung paano nagmamapa ang mga data type ng Python sa JSON at kung paano ang json Ang "Modyul na Talagang Gumagana" ay isa sa mga kasanayang biglang nagpapadali sa maraming pang-araw-araw na gawain.

Tinatalakay ng gabay na ito ang JSON mula sa pananaw ng isang Python programmer, ipinapaliwanag kung ano ang JSON, kung paano ito nauugnay sa JavaScript, kung aling mga uri ng Python ang maaari nitong katawanin, at kung paano i-parse, bumuo, mag-pretty-print, mag-validate, at mag-customize ng JSON gamit ang jsonTitingnan din natin ang mga totoong gamit tulad ng paggamit ng mga file at API, kasama ang mga trick para sa paghawak ng nested data at mga edge case tulad ng mga error o mga espesyal na value tulad ng NaN at mga kawalang-hanggan.

Ano ang JSON at Paano Ito Nauugnay sa Data ng Python

Ang JSON, pinaikling bahagi ng JavaScript Object Notation, ay isang format ng teksto para sa nakabalangkas na datos na orihinal na humiram ng syntax nito mula sa mga object at array ng JavaScript. Sa kabila ng pinagmulan ng JavaScript, ang JSON ay walang kinalaman sa wika at sinusuportahan ng halos lahat ng modernong wika, kabilang ang Python, na ginagawa itong mainam para sa pagpapalitan ng datos sa pagitan ng mga serbisyo, kliyente, at server.

Sa konsepto, ang JSON ay gumagamit lamang ng dalawang pinagsamang bloke ng pagbuo: ang JavaScript object at ang JavaScript array . Ang isang object ay kumikilos na halos kapareho ng isang diksyunaryo ng Python, at ang array ay kumikilos na parang isang listahan ng Python. Gamit ang dalawang ito, kasama ang isang maliit na hanay ng mga primitive na uri, maaaring ilarawan ng JSON ang mga kumplikadong nested data structure.

Ganito ang hitsura ng isang bagay sa JavaScript (at JSON): {"key1": value1, "key2": value2}Ito ay isang koleksyon ng mga pares ng key-value, kung saan ang mga key ay mga string at ang mga value ay maaaring maging anumang wastong JSON value (kabilang ang iba pang mga object o array). Ito ay halos kapareho ng isang Python. dict.

Ang isang array sa JavaScript (at JSON) ay katulad ng isang listahan sa Python: Ito ay isang nakaayos na koleksyon ng mga halaga, muli gamit ang anumang wastong uri ng JSON. Kapag pinagsama-sama, ang mga bagay at array ay maaaring i-nest nang arbitraryo upang imodelo ang mayamang datos tulad ng mga profile ng gumagamit, mga puno ng configuration, o mga tugon ng API.

Ang pagmamapa sa pagitan ng mga uri ng JSON at mga uri ng Python ay napakasimple, kaya naman minsan ay maririnig mo ang mga taong pabiro na tinatawag itong "PYON" (Python Object Notation). Kapag nag-e-encode o nagde-decode ng JSON ang Python, ang mga sumusunod na pagtutugma ay nalalapat:

• Bagay na JSON → Sawa dict
• Pagsasaayos ng JSON → Sawa list
• JSON string → Sawa str
• Numero ng JSON (integer) → Sawa int
• Numero ng JSON (totoo) → Sawa float
• JSON true → Sawa True
• JSON false → Sawa False
• JSON null → Sawa None

Isang mahalagang limitasyon ay ang mga JSON object key ay palaging mga string, kaya kung mag-encode ka ng Python dict para sa mga non-string key (hal., mga integer o tuple), ang mga key na iyon ay mapipilitang mag-string o magdulot ng mga error depende sa iyong mga setting. Mahusay ang JSON para sa pagpapanatili ng nakabalangkas na data tulad ng mga configuration o record, ngunit ito ay hindi isang pangkalahatang mekanismo ng pag-atsara para sa mga arbitraryong bagay sa Python.

Built-in na json Module ng Python

Ang Python ay may kasamang karaniwang module ng library na tinatawag na json, na nagbibigay sa iyo ng lahat ng kailangan mo para magamit ang JSON: pag-parse ng mga string, paglo-load mula sa mga file, pag-serialize ng mga Python object, at pag-customize kung paano naka-encode at naka-decode ang data. Hindi mo kailangan ng anumang external dependency para sa mga tipikal na gawain sa JSON.

Ang apat na pangunahing tungkulin na gagamitin mo sa halos lahat ng oras ay: json.dumps() at json.dump() para sa pag-convert ng mga bagay sa Python patungong JSON, at json.loads() at json.load() para sa pagbalik mula sa JSON pabalik sa mga uri ng Python. Ang mga bersyong "s" ay gumagana gamit ang mga string, habang ang mga bersyong walang "s" ay gumagana sa mga bagay na parang file.

Ang json Sinusuportahan ng encoder ang isang partikular na hanay ng mga uri ng Python bilang default, katulad dict, list, tuple (bilang mga array), str, mga numero (int, float, at mga enum na nagmula sa integer/float), at ang tatlong espesyal na singleton True, False, at NoneAng mga ito ay kino-convert sa kanilang mga katumbas na JSON ayon sa pagmamapa na inilarawan kanina.

Kung kailangan mong i-serialize ang mga custom na object o data type, Ang disenyo ng modyul ay maaaring palawigin: maaari mong i-subclass ang JSON encoder at ipatupad ang default() pamamaraan, o magpasa ng isang pasadyang default gumana sa json.dump() / json.dumps()Ang custom hook na iyon ay dapat magbalik ng isang bagay na JSON-serializable (tulad ng isang dict or list), o itaas TypeError kung hindi nito alam kung paano pangasiwaan ang ibinigay na bagay.

Sa ilalim ng hood, nag-aalok din ang modyul ng mga pamamaraan tulad ng encode() at iterencode(), na nagko-convert ng datos ng Python patungo sa mga JSON string, na may iterencode() unti-unting nagbubunga ng mga naka-encode na piraso. Ang mga ito ay hindi gaanong karaniwang ginagamit nang direkta ngunit mahalagang malaman kung kailangan mong mag-stream ng napakalaking mga tugon ng JSON.

Pag-convert ng mga Python Object sa JSON

Kapag gusto mong gawing JSON text ang data ng Python, gamitin mo json.dump() or json.dumps(), depende kung gusto mong magsulat nang direkta sa isang file o kumuha ng JSON string sa memorya. Parehong may parehong core parameter ang parehong function na nagbibigay-daan sa iyong kontrolin kung paano kumikilos ang conversion.

Ang function na json.dump(obj, fp, ...) kumukuha ng isang Python object at isang file-like object, at nagsusulat ng representasyon ng JSON ng obj sa file na iyon. Ang katumbas nito sa memorya, json.dumps(obj, ...), ay nagbabalik ng JSON string sa halip na magsulat sa isang file. Pareho silang tumatanggap ng serye ng mga argumento ng keyword tulad ng skipkeys, ensure_ascii, check_circular, allow_nan, indent, separators, default, at sort_keys.

Binabago ng bawat isa sa mga opsyong ito ang gawi sa pag-encode sa mga paraang napakahalaga sa mga totoong proyekto: maaari mong piliin kung lalaktawan ang mga invalid key, pilitin ang ASCII output, i-pretty-print ang resulta, kontrolin ang whitespace, tukuyin ang custom serialization para sa mga hindi karaniwang object, o patatagin ang pagkakasunod-sunod ng key para sa pagsubok at mga diff.

Narito ang kahulugan ng mga pangunahing parameter sa praktikal na mga termino:

• skipkeys: kung nakatakda sa True, mga susi ng diksyunaryo na hindi uri str, int, float, bool or None ay tahimik na nilalaktawan sa halip na itinataas TypeErrorKung mas gusto mo ang mabilis na paggana kapag kakaiba ang mga key, iwanan ito bilang False.
• ensure_ascii: kailan True (ang default), ang mga karakter na hindi ASCII at hindi mai-print ay tinatakasan (hal. bilang \uXXXX) kaya ang output ay mananatiling purong ASCII. Kapag False, ang mga karakter sa Unicode ay isinusulat nang walang pagbabago, na kadalasang mas mainam para sa mga config o log na nababasa ng tao.
• check_circular: if True, sinusuri ng encoder ang mga pabilog na sanggunian sa mga listahan, dict, at mga custom na naka-encode na bagay upang maiwasan ang walang katapusang recursion. Itinatakda ito sa False hindi pinapagana ang lambat na pangkaligtasan na iyon at maaaring humantong sa isang RecursionError kung ang iyong mga istruktura ay tumutukoy sa sarili.
• allow_nan: if True, mga espesyal na halaga ng lumulutang na punto tulad ng NaN, Infinity, at -Infinity ay pinapayagan at naka-encode sa paraang tugma sa JavaScript, kahit na hindi sila mahigpit na balidong JSON ayon sa detalye. Kung False, ang pagtatangkang i-encode ang mga naturang halaga ay magpapataas ng ValueError.
• indent: isang hindi negatibong integer (o isang string) na kumokontrol sa pretty printing. Ang positibong numero ay nangangahulugan na maraming espasyo sa bawat nested level. Ang isang string (tulad ng "\t") ay direktang ginagamit para sa indentation. None (ang default) ay pumipili ng pinaka-compact na representasyon, nang walang karagdagang mga bagong linya na lampas sa kinakailangan.
• separators: isang tuple (item_separator, key_separator) pagkontrol sa bantas at espasyo sa pagitan ng mga item at sa pagitan ng mga key at value. Para sa pinakamahigpit na JSON, karaniwan mong ginagamit (",", ":") para tanggalin ang lahat ng opsyonal na espasyo.
• default: isang function na tumatanggap ng anumang object na hindi alam ng encoder kung paano hawakan. Dapat itong magbalik ng JSON-serializable replacement (tulad ng isang dict or list), o itaas TypeErrorIto ang pangunahing paraan para gawing serializable ang sarili mong mga klase.
• sort_keys: if True, ang mga diksyonaryo ay naka-encode gamit ang mga key na nakaayos. Ito ay lubos na kapaki-pakinabang para sa mga regression test at mga reproducible output, kung saan gusto mong maging stable ang mga JSON dumps sa lahat ng run.

Bilang konkretong paglalarawan, isipin na mayroon kang isang halo-halong listahan ng Python na naglalaman ng mga integer at isang diksyunaryo na may pangalan, id, at floating-point score. Maaari kang lumikha at mag-imbak ng JSON tulad nito:

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

Ang naka-print na JSON ay magiging maayos ang pagkaka-format salamat sa indent=4, ipinapakita ang bawat aytem sa listahan at susi ng diksyunaryo sa sarili nitong linya. Ginagawa nitong mas madali ang pag-debug at manu-manong pag-edit kumpara sa isang siksik na linya ng teksto.

Pag-parse ng JSON Pabalik sa Python

Para bumalik mula sa JSON text papunta sa mga Python object, Ginagamit mo ang pares ng mga function na tumutugma: json.load() (para sa mga bagay na parang file) at json.loads() (para sa mga JSON string). Sinusuri ng mga function na ito ang input at muling nililikha ang mga uri ng Python ayon sa parehong mapping table gaya ng dati.

Ang mga lagda ay halos ganito ang hitsura: json.load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw) at json.loads(s, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw)Sa pangunahing antas, maaari mo silang tawagin gamit lamang ang input ng JSON, ngunit ang mga karagdagang argumento ay nagbubukas ng pinto patungo sa mas advanced na pag-parse.

Mga kawit na parang object_hook at object_pairs_hook hinahayaan kang i-customize kung paano ginagawang mga istrukturang Python ang mga JSON object, sa pamamagitan ng pagpapakain sa iyo ng alinman sa na-decode dict o isang listahan ng (key, value) mga pares ayon sa pagkakabanggit. Ito ay kapaki-pakinabang kung gusto mong bumuo ng mga pasadyang klase nang direkta mula sa JSON o mapanatili ang pagkakasunod-sunod sa isang partikular na paraan.

Iba pang mga maaaring tawagan tulad ng parse_float, parse_int, at parse_constant nagbibigay-daan sa iyong kontrolin kung paano binibigyang-kahulugan ang mga numero at mga espesyal na token. Halimbawa, maaari mong gamitin ang Decimal sa halip ng float para sa mga halaga ng pera, o pagbabago "NaN", "inf", at "-inf" sa mga bagay na pangbantay na iyong napili.

Ipagpapatuloy ang naunang halimbawa, maaari mong basahin ang JSON file na iyong isinulat tulad nito:

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

Ang magiging resulta ay isang regular na listahan at diksyunaryo ng Python, halimbawa , na maaari mong manipulahin gamit ang lahat ng karaniwang operasyon sa Python. Mula sa perspektibo ng iyong code, ito ay "data lamang" muli.

Anong mga Uri ng Python ang Maaaring I-convert sa JSON

Hindi lahat ng bagay sa Python ay maaaring gawing JSON agad-agad, kaya makakatulong na tandaan ang pinapayagang set. Sinusuportahan ng mga praktikal na encoder ang mga karaniwang uri ng container at scalar, kasama ang mga Boolean at None, at imapa ang mga ito sa minimal na hanay ng mga uri ng JSON.

Bilang default, ligtas mong maipapasa ang mga sumusunod na bagay sa Python sa json.dumps():

• dict (naka-encode bilang mga JSON object)
• list at tuple (naka-encode bilang mga JSON array)
• str (naka-encode bilang mga string ng JSON)
• int at float (naka-encode bilang mga numero ng JSON)
• True at False (naka-encode bilang true at false)
• None (naka-encode bilang null)

Kapag in-encode ito ng Python, ang pagmamapa pabalik sa JSON ay diretso, at kabaliktaran kapag nagde-decode. Halimbawa, ang isang Python tuple nagiging isang JSON array, at makakakuha ka ng isang list pabalik sa pagkarga. Mga enum na nagmula sa int or float maaari ding i-encode bilang mga numero.

Ang lahat ng iba pa ay nangangailangan ng isang pasadyang default Handler (upang gawing serializable ang mga bagay) o magiging sanhi TypeErrorIto ay sa pamamagitan ng disenyo: Ang JSON ay para sa datos, hindi para sa mga arbitraryong graph ng object na may gawi at mga pamamaraan tulad ng maaari mong i-serialize gamit ang pickle.

Para sa karamihan ng pang-araw-araw na trabaho, ang subset na ito ng mga uri ay sumasaklaw sa karamihan ng mga use case, kabilang ang mga API payload, mga configuration tree, mga kagustuhan ng user, mga basic log, at maliliit na "database-like" na file para sa mga prototype o mga single-user tool.

Magandang Pag-print, Kompaktong Output, at Nakaayos na mga Susi

Ang raw JSON output ay kadalasang ganap na balido ngunit mahirap basahin, dahil kadalasan itong nabubuo nang walang kinakailangang whitespace. Para sa pag-debug, pag-log, o pagbabahagi sa ibang mga developer, madalas mong gusto ang nababasang JSON na may indent sa halip na isang linya lang.

Ang indent parameter ng json.dumps() ay ang pangunahing pingga para sa magandang pag-print, na nagpapahintulot sa iyo na sabihin sa Python kung ilang espasyo (o kung aling string) ang gagamitin sa bawat antas ng indentation. Ang isang karaniwang pagpipilian ay indent=4, bagama't mas gusto ng ilang codebase ang dalawang espasyo o mga karakter ng tab; ang mga kumbensyon sa istilo ay nag-iiba sa bawat proyekto.

Ang separators Ang argument ay nagbibigay-daan sa iyong mas pahusayin pa ang whitespace, pagbibigay ng tuple tulad ng (", ", ": ") bilang default para sa output na madaling gamitin ng tao. Kung gusto mo ang pinaka-compact na representasyon na posible—halimbawa, ang pagbabawas ng laki ng payload sa network—maaari mong itakda separators=(",", ":") para tanggalin ang mga espasyo pagkatapos ng mga kuwit at tutuldok.

Kapag mahalaga sa iyo ang deterministic output, halimbawa sa mga unit test o snapshot comparison, Ina-activate sort_keys=True Ginagawang nakaayos ang output ng mga dictionary key ng encoder. Sa ganoong paraan, ang dalawang run na lumilikha ng magkaparehong semantikong data ay hindi magkaiba dahil lamang sa ang mga dictionary ay nag-output ng mga key sa magkaibang sequence.

Sama-sama, indent, separators, at sort_keys bigyan ka ng maraming kontrol kung ang iyong JSON ay na-optimize para sa mga makina (compact, walang whitespace) o para sa mga tao (naka-indent, naka-align, na may matatag na hugis sa lahat ng run).

Nested Data, Mga Istratehiya sa Pag-parse, At Mga Pattern ng Pag-access

Sa totoong JSON, ang mga flat structure ang eksepsiyon; kadalasan ay haharap ka sa mga nested object at array. Isipin ang isang tipikal na user record sa isang e-commerce application: personal na impormasyon, nested shipping address, nested billing details, at marahil isang listahan ng mga order, na ang bawat isa ay isang komplikadong istruktura sa sarili nitong karapatan.

Kapag nagde-decode ng JSON sa Python, ang nested data ay nagiging kombinasyon ng mga dictionary at list, at maaari mo itong ma-access gamit ang karaniwang index at key lookups. Para sa mga mababaw na istruktura, ito ay diretso: data, data, At iba pa.

Para sa mga istrukturang may malalim na pagkakapatong o dinamiko, maaaring mas gusto mo ang mas pangkalahatang pamamaraan, tulad ng pagsulat ng isang maliit na recursive function na naghahanap ng mga susi o naglalakad sa isang puno ng mga dict at listahan. Ang mga recursive solution ay kadalasang mas maikli at mas madaling basahin kaysa sa mga iterative solution kapag tumatawid sa arbitraryong naka-patong na datos.

Mas madaling direktang ma-access ang Unnested (flat) JSON gamit ang mga hardcoded key, na maaaring maging perpekto para sa maliliit na utility o kapag ganap mong kinokontrol ang input. Gayunpaman, kapag gumagamit ng mga external API, karaniwan ang pagsulat ng maliliit na helper function na sumasaklaw sa istruktura, para hindi mo i-sprinkle mga kadena sa buong codebase mo.

Anuman ang lalim, pareho lang json.loads() naaangkop na pag-uugali: Tumatanggap ang function ng JSON string at gumagawa ng mga katutubong uri ng Python na maaari mong manipulahin gamit ang mga regular na tool sa Python. Walang kinakailangang espesyal na syntax na lampas sa normal. dict at list pag-index

Paggawa Gamit ang mga JSON File: Pagbasa, Pagsulat, at Pagdaragdag

Ang JSON ay isang nakakagulat na madaling gamiting magaan na format ng imbakan para sa maliliit na proyekto, mga configuration file, o mga script na kailangang magpanatili ng ilang persistent state. Sa halip na direktang maghanap ng isang kumpletong database, kadalasan ay maaari kang gumamit ng isa o dalawang JSON file nang matagal.

Ang pagsulat ng JSON sa isang file ay karaniwang may dalawang hakbang na proseso: i-serialize ang datos ng Python gamit ang json.dumps() o direkta kasama ang json.dump(), at pagkatapos ay tiyaking ang resultang string ay nakasulat sa disk. Kung tatawag ka open('data.json', 'w'), makakakuha ka ng file handle sa write mode na maaaring lumikha ng file o magpuputol nito kung umiiral na ito.

Para sa mga nested structure, ang protocol ay hindi naiiba sa flat data: pareho pa rin ang gamit mo json.dump() tawag, at ang mga nested na kumbinasyon ng mga listahan at dict ay naka-encode nang recursively. Ang tanging desisyon na karaniwang kailangan mong gawin ay kung gaano kalaking indentation ang gusto mo para sa readability kumpara sa laki ng file.

Ang pagbabasa ng JSON mula sa isang file ay kabaligtaran: buksan ang file sa text mode, ipasa ang file object sa json.load(), at makukuha mo ulit ang istruktura ng iyong datos sa Python. Muli, ang kilos ay hindi nakadepende sa kung gaano kalalim ang paglalagay ng pugad—ang decoder ang bahala sa lahat ng iyon para sa iyo.

Kung kailangan mong magdagdag ng JSON data sa mga umiiral na file, mas magiging detalyado ang mga bagay-bagay. Hindi sinusuportahan mismo ng JSON ang "streaming append" sa simpleng paraan dahil ang buong file ay kailangang maging wastong JSON. Ang isang karaniwang pattern ay ang pag-iimbak ng isang array ng mga record at pagbabasa/pagbabago/pagsulat ng buong array, o paggamit ng line-delimited JSON kung saan ang bawat linya ay isang hiwalay na JSON object na maaari mong idagdag nang hindi muling isinusulat ang mga nakaraang linya.

JSON Sa Tunay na Mundo: Mga API, Imbakan, At Pagpapalitan

Kapag nagsimula ka nang bumuo ng mga totoong aplikasyon, ang JSON ay mabilis na nagiging pandikit na nag-uugnay sa mga web client at server, mga microservice, at mga third-party API. Pinahahalagahan ito dahil sa siksik nito at dahil madali pa rin itong mababasa at mae-edit ng mga tao.

Sa pakikipag-ugnayan ng API, ang JSON ang pinakakaraniwang format ng payload, lalo na sa mga serbisyong RESTful. Karaniwang gumagamit ang mga aplikasyon ng Python ng mga library tulad ng requests para magpadala ng mga kahilingan sa HTTP at tumanggap ng mga tugon sa JSON, pagkatapos ay suriin ang mga tugon na iyon gamit ang json.loads() o sa mga pamamaraang pantulong na bumabalot dito.

Ang JSON ay isa ring sikat na format para sa mga configuration file at log, kung saan ang nakabalangkas at key-value na katangian nito ay ginagawa itong mas makahulugan kaysa sa plain text habang nananatiling simple kumpara sa mga kumpletong database. Maaaring magbahagi ng configuration ang mga bahagi ng system sa pamamagitan ng JSON, at maaaring i-parse ng mga log aggregator ang mga JSON log upang mas madaling ma-filter o masuri ang mga ito.

Ang isa pang malaking gamit ay ang serialization at deserialization ng mga istruktura ng datos, na nagko-convert ng mga in-memory collection sa mga JSON string (serialization) at pagkatapos ay muling binubuo ang mga ito sa ibang pagkakataon (deserialization). Ganito mo iniimbak ang mga kagustuhan ng user, nagpapadala ng mga nakabalangkas na mensahe sa pamamagitan ng mga pila, o nagpapadala ng mga nested object sa mga hangganan ng serbisyo, basta't mananatili ka sa mga uri na tugma sa JSON o magbibigay ng mga custom encoder.

Bukod sa JSON lamang, ang Python code ay kadalasang kailangang mag-convert sa pagitan ng JSON at iba pang mga format, tulad ng XML, CSV, o plain text. Halimbawa, maaari mong basahin ang CSV mula sa isang legacy system, i-convert ito sa isang listahan ng mga dict, at pagkatapos ay i-dump ito bilang JSON para sa isang modernong API. O maaari mo ring kunin ang JSON mula sa isang API, i-normalize ito, at isulat ang CSV para i-load ng mga analyst sa mga spreadsheet.

Pag-format, Pagpapatunay, at Karagdagang Operasyon sa JSON

Kapag komportable ka na sa pangunahing pagbasa at pagsusulat, maraming maliliit ngunit kapaki-pakinabang na operasyon ang maaari mong gawin sa JSON data upang mapabuti ang iyong daloy ng trabaho: pag-format para sa pagiging madaling mabasa, pagpapatag ng mga nested structure, pagpapatunay na ang isang string ay talagang JSON, at pag-uuri ng data para sa pare-parehong paghahambing.

Magandang pag-imprenta gamit ang json.dumps(..., indent=...) ay ang unang hakbang, nagbibigay sa iyo ng maayos na pagkakaayos ng mga hierarchy na nagpapadali sa pagtuklas ng mga isyu sa istruktura sa isang sulyap. Ito ay lalong nakakatulong habang nagde-debug o kapag nagbabahagi ng mga halimbawa sa dokumentasyon.

Ang pagpapatag ng nested JSON ay maaaring magpapadali sa downstream processing at analysis, lalo na kung kailangan mong i-convert ang data sa tabular form tulad ng CSV o i-feed ito sa mga tool na umaasa sa mga key-value pair sa halip na mga deeply nested object. Karaniwan mong ipinapatupad ang pagpapatag gamit ang recursion o iterative traversal sa mga dict at list.

Ang pag-validate ng JSON ay kadalasang bumababa sa pagsubok na i-parse ito at pagkuha ng mga exception, lalo na kung bineberipika mo lang na tama ang sintaks ng isang string. Para sa mas mahigpit na pagsusuri, maaari mong gamitin ang JSON Schema at mga panlabas na library, ngunit para sa maraming kaso, isang simpleng try/except sa paligid json.loads() ay sapat na.

Ang pag-uuri ng datos ng JSON ayon sa mga partikular na halaga o susi ay makakatulong kapag naghahambing ng mga tugon, pagbuo ng mga stable snapshot para sa mga pagsubok, o simpleng pagtiyak na ang mga magkakatulad na bagay ay magkakasamang nakagrupo. Maaari mong ayusin ang mga pinagbabatayang listahan at dict ng Python bago itapon o umasa sa sort_keys=True kapag ang pokus ay nasa pagkakasunud-sunod ng mga pangunahing bagay.

Paghawak ng Error Kapag Gumagamit ng JSON

Kahit ang mga sistemang maayos ang pagkakaayos ay maaaring magkaroon ng maling JSON o hindi inaasahang data, kaya mahalaga ang mahusay na paghawak ng error sa pag-parse at pag-encode ng JSON. Ipinapahayag ng Python ang mga problemang ito sa pamamagitan ng mga eksepsiyon, at ang idyomatikong paraan upang harapin ang mga ito ay ang pagbalot ng mga operasyon sa try...except Mga bloke.

Kapag nagde-decode ng JSON, ang pinakakaraniwang isyu ay ang hindi wastong syntax, tulad ng mga nawawalang panipi sa paligid ng mga pangalan ng ari-arian o mga kasunod na kuwit. Ang json ang modyul ay magbubunga ng error sa pag-decode (karaniwan json.JSONDecodeError), na maaari mong makuha at mai-log o i-convert sa mga mensaheng madaling gamitin.

Halimbawa, ang pagsubok na i-parse ang isang sirang string ay maaaring magresulta sa isang error tulad ng: Failed to decode JSON: Expecting property name enclosed in double quotes: line 1 column 29 (char 28)Ang ganitong uri ng mensahe ay nagsasabi sa iyo hindi lamang na nabigo ang pag-parse kundi pati na rin kung saan sa input na nalito ang parser.

Sa panig ng pag-encode, maaaring matamaan mo TypeError kapag sinusubukang i-serialize ang mga hindi sinusuportahang uri, or ValueError kung hindi mo papayagan NaN at mga kawalang-hanggan sa pamamagitan ng allow_nan=False ngunit ang iyong data ay naglalaman ng mga ganitong halaga. Ang mga pabilog na sanggunian sa mga lalagyan ay maaari ring mag-trigger RecursionError kung hindi mo pinagana ang mga pabilog na pagsusuri.

Ang pinakamahusay na kasanayan ay ituring ang mga operasyon ng JSON bilang mga pagkakamaling I/O, lalo na kapag nagbabasa mula sa mga pinagmumulan ng network o mga panlabas na file: palaging ipagpalagay na maaaring may magkamali at hanapin ang mga eksepsiyon nang naaayon, posibleng magdagdag ng mga layer ng pagpapatunay upang ipatupad ang mas tiyak na mga limitasyon sa iyong data. json.loads() o mga pamamaraan ng API helper sa try...except Pinoprotektahan ng mga block ang natitirang bahagi ng iyong code mula sa mga sunud-sunod na pagkabigo at hinahayaan kang bumalik mga error sa JSON na madaling gamitin sa mga kliyente kung naaangkop.

Paggamit ng JSON Gamit ang mga Web API sa Python

Karamihan sa mga web API na kinakausap mo mula sa Python ay magpapadala at tatanggap ng JSON, at pinagsasama ng karaniwang development stack ang requests library (para sa HTTP) gamit ang json modyul (para sa pag-parse at pagbuo ng JSON). Ginagawang natural ng kombinasyong ito ang pagsasama ng API.

Isang karaniwang pattern ang pagtawag sa isang API endpoint, pagsuri kung ang response status code ay nagpapahiwatig ng tagumpay, at pagkatapos ay i-parse ang JSON body . Mula doon, maaari mong ma-access ang mga field, pangasiwaan ang nested data, at imapa ang tugon sa iyong sariling mga domain model o tingnan ang mga object.

Ang paghawak ng error ay nagiging mas mahalaga kapag may mga tawag sa network na kasangkot, dahil maaari kang makaranas hindi lamang ng invalid na JSON kundi pati na rin ng mga timeout, error sa koneksyon, o mga pagkabigo sa server-side na tumutugon gamit ang HTML sa halip na JSON. json.loads() o mga pamamaraan ng API helper sa try...except Pinoprotektahan ng mga block ang natitirang bahagi ng iyong code mula sa mga sunud-sunod na pagkabigo.

Kapag na-parse na, ang API JSON ay kumikilos tulad ng ibang istruktura ng datos sa Python, kaya lahat ng mga pamamaraang tinalakay kanina—tulad ng pag-print, pagpapatag, pagpapatunay, pag-uuri—ay direktang nalalapat. Ang pagiging komportable sa paglipat sa pagitan ng datos sa Python at JSON ay isang malaking tulong sa produktibidad kapag pinagsasama-sama mo ang mga serbisyo. Kung nakatuon ka sa pagbuo ng mga totoong aplikasyon , ang pagbibigay-pansin sa mga pattern ng paghawak ng JSON nang maaga ay makakatipid sa oras ng pag-debug sa ibang pagkakataon.

Ang JSON sa Python ay hindi gaanong tungkol sa isang tawag sa isang function kundi tungkol sa isang toolbox: malinaw na mga type mapping, nababaluktot na mga parameter ng encoding, mga hook para sa mga custom na uri, simple ngunit makapangyarihang file I/O, at matatag na mga pattern para sa pag-parse, pag-format, at pag-validate ng data mula sa labas ng mundo, na lahat ay ginagawang natural na akma ang JSON para sa mga programmer ng Python na humaharap sa mga modernong application na nakabase sa data.