Panduan Pengaturcara untuk Data Python dan JSON

Laman Utama » Python » Panduan Pengaturcara untuk Data Python dan JSON

JSON secara senyap-senyap telah menjadi bahasa lalai untuk data di web, dan jika anda menulis Python, anda akan menemuinya di mana-mana: API, fail konfigurasi, "pangkalan data" kecil untuk projek sampingan, log dan juga lekapan ujian. Memahami bagaimana jenis data Python dipetakan kepada JSON dan bagaimana json Modul yang benar-benar berkesan merupakan salah satu kemahiran yang tiba-tiba memudahkan banyak tugasan harian.

Panduan ini menerangkan JSON dari sudut pandangan pengaturcara Python, menerangkan apa itu JSON, bagaimana ia berkaitan dengan JavaScript, jenis Python yang boleh diwakilinya dan cara menghuraikan, menjana, mencetak cantik, mengesahkan dan menyesuaikan JSON menggunakan jsonKita juga akan melihat kes penggunaan dunia sebenar seperti bekerja dengan fail dan API, serta helah untuk mengendalikan data bersarang dan kes pinggir seperti ralat atau nilai khas seperti NaN dan ketakterhinggaan.

Apakah JSON dan Bagaimana Ia Berkaitan dengan Data Python

JSON, singkatan untuk JavaScript Object Notation, ialah format teks untuk data berstruktur yang pada asalnya meminjam sintaksnya daripada objek dan tatasusunan JavaScript. Walaupun berakar umbi JavaScript, JSON adalah agnostik bahasa dan disokong oleh hampir setiap bahasa moden, termasuk Python, menjadikannya sesuai untuk bertukar data antara perkhidmatan, klien dan pelayan.

Secara konseptual, JSON hanya menggunakan dua blok binaan komposit: objek JavaScript dan tatasusunan JavaScript . Objek berkelakuan seperti kamus Python, dan tatasusunan berkelakuan seperti senarai Python. Dengan kedua-duanya, ditambah dengan set kecil jenis primitif, JSON boleh menerangkan struktur data bersarang yang kompleks.

Objek dalam JavaScript (dan JSON) kelihatan seperti ini: {"key1": value1, "key2": value2}Ia merupakan koleksi pasangan kunci-nilai, yang mana kunci ialah rentetan dan nilai boleh menjadi sebarang nilai JSON yang sah (termasuk objek atau tatasusunan lain). Ini sepadan rapat dengan Python dict.

Array dalam JavaScript (dan JSON) adalah serupa dengan senarai Python: Ia merupakan koleksi nilai yang tersusun, sekali lagi menggunakan sebarang jenis JSON yang sah. Secara keseluruhannya, objek dan tatasusunan boleh disusun secara sewenang-wenangnya untuk memodelkan data kaya seperti profil pengguna, pokok konfigurasi atau respons API.

Pemetaan antara jenis JSON dan jenis Python adalah sangat mudah, itulah sebabnya anda kadangkala mendengar orang secara bergurau memanggilnya "PYON" (Notasi Objek Python). Apabila Python mengekod atau menyahkod JSON, kesepadanan berikut terpakai:

• Objek JSON → Python dict
• Tatasusunan JSON → Python list
• Rentetan JSON → Python str
• Nombor JSON (integer) → Python int
• Nombor JSON (nyata) → Python float
• JSON true → Python True
• JSON false → Python False
• JSON null → Python None

Satu batasan penting ialah kekunci objek JSON sentiasa rentetan, jadi jika anda mengekod Python dict dengan kekunci bukan rentetan (cth., integer atau tupel), kekunci tersebut akan dipaksa kepada rentetan atau menimbulkan ralat bergantung pada tetapan anda. JSON sangat bagus untuk mengekalkan data berstruktur seperti konfigurasi atau rekod, tetapi ia tidak mekanisme penjerukan umum untuk objek Python sewenang-wenangnya.

Modul json Terbina Dalam Python

Python dihantar dengan modul perpustakaan standard yang dipanggil json, yang memberikan anda semua yang anda perlukan untuk bekerja dengan JSON: menghuraikan rentetan, memuatkan daripada fail, menyusun semula objek Python secara bersiri dan menyesuaikan cara data dikodkan dan dinyahkod. Anda tidak memerlukan sebarang kebergantungan luaran untuk tugasan JSON biasa.

Empat fungsi teras yang akan anda gunakan kebanyakan masa ialah: json.dumps() dan json.dump() untuk menukar objek Python kepada JSON, dan json.loads() dan json.load() untuk beralih daripada JSON kembali kepada jenis Python. Versi “s” berfungsi dengan rentetan, manakala versi tanpa “s” berfungsi dengan objek seperti fail.

. json pengekod menyokong set jenis Python tertentu secara lalai, iaitu dict, list, tuple (sebagai tatasusunan), str, nombor (int, float, dan enum terbitan integer/float), dan tiga singleton khas True, False, dan None. Ini ditukar kepada padanan JSON mengikut pemetaan yang diterangkan sebelum ini.

Jika anda perlu membuat siri objek atau jenis data tersuai, Reka bentuk modul ini boleh dikembangkan: anda boleh subkelas pengekod JSON dan melaksanakannya default() kaedah, atau lulus adat default berfungsi ke dalam json.dump() / json.dumps(). Cangkuk tersuai itu sepatutnya mengembalikan sesuatu yang boleh disirikan JSON (seperti dict or list), atau menaikkan TypeError jika ia tidak tahu bagaimana untuk mengendalikan objek yang diberikan.

Di sebalik semua itu, modul ini juga menawarkan kaedah seperti encode() dan iterencode(), yang menukar data Python kepada rentetan JSON, dengan iterencode() menghasilkan kepingan yang dikodkan secara berperingkat. Ini kurang biasa digunakan secara langsung tetapi perlu diketahui jika anda perlu menstrim respons JSON yang sangat besar.

Menukar Objek Python Kepada JSON

Apabila anda ingin menukar data Python kepada teks JSON, anda gunakan json.dump() or json.dumps(), bergantung pada sama ada anda ingin menulis terus ke fail atau mendapatkan rentetan JSON dalam memori. Kedua-dua fungsi berkongsi parameter teras yang sama yang membolehkan anda mengawal cara penukaran berfungsi.

Majlis tersebut json.dump(obj, fp, ...) mengambil objek Python dan objek seperti fail, dan menulis perwakilan JSON bagi obj ke fail itu. Rakan sejawatnya dalam memori, json.dumps(obj, ...), mengembalikan rentetan JSON dan bukannya menulis ke fail. Kedua-duanya menerima beberapa argumen kata kunci seperti skipkeys, ensure_ascii, check_circular, allow_nan, indent, separators, default, dan sort_keys.

Setiap pilihan ini mengubah suai tingkah laku pengekodan dengan cara yang sangat penting dalam projek sebenar: anda boleh memilih sama ada untuk melangkau kekunci tidak sah, memaksa output ASCII, mencetak hasilnya dengan cantik, mengawal ruang kosong, menentukan bersiri tersuai untuk objek bukan standard atau menstabilkan susunan kekunci untuk pengujian dan perbezaan.

Inilah maksud parameter utama secara praktikal:

• skipkeys: jika ditetapkan kepada True, kunci kamus yang bukan jenis str, int, float, bool or None dilangkau secara senyap dan bukannya dibangkitkan TypeErrorJika anda lebih suka tingkah laku fail-fast apabila kekunci pelik, biarkan ia sebagai False.
• ensure_ascii: apabila True (lalai), aksara bukan ASCII dan tidak boleh dicetak akan dilucutkan (cth. sebagai \uXXXX) jadi output kekal ASCII tulen. Apabila False, aksara Unicode ditulis sebagaimana adanya, yang biasanya lebih baik untuk konfigurasi atau log yang boleh dibaca oleh manusia.
• check_circular: if True, pengekod menyemak rujukan bulat dalam senarai, dict dan objek yang dikodkan tersuai untuk mengelakkan rekursi tak terhingga. Menetapkannya kepada False melumpuhkan jaringan keselamatan itu dan boleh menyebabkan RecursionError jika struktur anda merujuk kepada diri sendiri.
• allow_nan: if True, nilai titik apungan khas seperti NaN, Infinity, dan -Infinity dibenarkan dan dikodkan dengan cara yang serasi dengan JavaScript, walaupun ia bukan JSON yang sah sepenuhnya mengikut spesifikasi. Jika False, cuba mengekod nilai sedemikian akan meningkatkan ValueError.
• indent: integer bukan negatif (atau rentetan) yang mengawal pencetakan cantik. Nombor positif bermaksud banyak ruang bagi setiap aras bersarang. Rentetan (seperti "\t") digunakan secara langsung untuk lekukan. None (lalai) memilih perwakilan yang paling padat, tanpa baris baharu tambahan melebihi apa yang diperlukan.
• separators: satu tuple (item_separator, key_separator) mengawal tanda baca dan ruang kosong antara item dan antara kekunci dan nilai. Untuk JSON yang paling ketat, anda biasanya menggunakan (",", ":") untuk mengosongkan semua ruang pilihan.
• default: fungsi yang menerima sebarang objek yang pengekod tidak tahu cara mengendalikannya. Ia mesti mengembalikan penggantian boleh bersiri JSON (seperti dict or list), atau menaikkan TypeErrorIni ialah cangkuk utama untuk menjadikan kelas anda sendiri boleh disirikan.
• sort_keys: if True, kamus dikodkan dengan kekunci yang disusun. Ini sangat berguna untuk ujian regresi dan output yang boleh dihasilkan semula, yang mana anda mahu lambakan JSON stabil merentasi larian.

Sebagai ilustrasi konkrit, bayangkan anda mempunyai senarai Python campuran yang mengandungi integer dan kamus dengan nama, id dan skor titik apungan. Anda boleh mencipta dan menyimpan JSON seperti ini:

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

JSON yang dicetak akan diformat dengan baik terima kasih kepada indent=4, memaparkan setiap item senarai dan kunci kamus pada barisnya sendiri. Ini menjadikan penyahpepijatan dan penyuntingan manual lebih mudah berbanding dengan satu baris teks yang padat.

Menghuraikan JSON Kembali Ke Python

Untuk beralih daripada teks JSON kembali kepada objek Python, anda menggunakan pasangan fungsi yang sepadan: json.load() (untuk objek seperti fail) dan json.loads() (untuk rentetan JSON). Fungsi ini menghuraikan input dan mencipta semula jenis Python mengikut jadual pemetaan yang sama seperti sebelumnya.

Tandatangan tersebut secara kasarnya seperti berikut: json.load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw) dan json.loads(s, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw)Pada peringkat asas, anda boleh memanggilnya hanya dengan input JSON, tetapi argumen tambahan membuka pintu kepada tingkah laku penghuraian yang lebih maju.

Cangkuk seperti object_hook dan object_pairs_hook membolehkan anda menyesuaikan cara objek JSON diubah menjadi struktur Python, dengan memberi anda sama ada yang didekodkan dict atau senarai (key, value) pasangan masing-masing. Ini berguna jika anda ingin membina kelas tersuai terus daripada JSON atau mengekalkan susunan dengan cara tertentu.

Boleh dipanggil lain seperti parse_float, parse_int, dan parse_constant membolehkan anda mengawal bagaimana nombor dan token khas ditafsirkan. Contohnya, anda mungkin mahu menggunakan Decimal bukan float untuk nilai wang, atau mengubah "NaN", "inf", dan "-inf" ke dalam objek sentinel pilihan anda.

Meneruskan contoh terdahulu, anda boleh membaca fail JSON yang anda tulis seperti ini:

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

Output yang terhasil akan menjadi senarai dan kamus Python biasa, contohnya , yang boleh anda manipulasi dengan semua operasi Python biasa. Dari perspektif kod anda, ia hanyalah "data" sekali lagi.

Jenis-jenis Python Yang Boleh Ditukar Kepada JSON

Tidak semua objek Python boleh diubah menjadi JSON secara automatik, jadi adalah berguna untuk mengingati set yang dibenarkan. Pengekod praktikal menyokong jenis kontena dan skalar biasa, serta Boolean dan None, dan memetakannya kepada set minimum jenis JSON.

Secara lalai, anda boleh memasukkan objek Python berikut dengan selamat ke dalam json.dumps():

• dict (dikodkan sebagai objek JSON)
• list dan tuple (dikodkan sebagai tatasusunan JSON)
• str (dikodkan sebagai rentetan JSON)
• int dan float (dikodkan sebagai nombor JSON)
• True dan False (dikodkan sebagai true dan false)
• None (dikodkan sebagai null)

Apabila Python mengekod ini, pemetaan kembali ke JSON adalah mudah, dan sebaliknya semasa penyahkodan. Contohnya, Python tuple menjadi tatasusunan JSON, dan anda mendapat list kembali dimuatkan. Enum yang diperoleh daripada int or float juga boleh dikodkan sebagai nombor.

Semua yang lain memerlukan adat default pengendali (untuk menukar objek kepada perwakilan yang boleh bersiri) atau akan menyebabkan TypeErrorIni adalah reka bentuk: JSON bertujuan untuk data, bukan untuk graf objek sewenang-wenangnya dengan tingkah laku dan kaedah seperti yang anda mungkin siarkan secara bersiri menggunakan pickle.

Bagi kebanyakan kerja harian, subset jenis ini merangkumi kebanyakan kes penggunaan, termasuk muatan API, pokok konfigurasi, pilihan pengguna, log asas dan fail kecil "seperti pangkalan data" untuk prototaip atau alat pengguna tunggal.

Percetakan Cantik, Output Padat, Dan Kekunci Tersusun

Output JSON mentah cenderung sah sepenuhnya tetapi sukar dibaca, kerana ia sering dijana tanpa ruang kosong yang tidak perlu. Untuk penyahpepijatan, pengelogan atau perkongsian dengan pembangun lain, anda sering mahukan JSON yang boleh dibaca dan berinden dan bukannya satu baris sahaja.

. indent parameter bagi json.dumps() ialah tuas utama untuk pencetakan yang cantik, membolehkan anda memberitahu Python berapa banyak ruang (atau rentetan yang mana) untuk digunakan bagi setiap tahap lekukan. Pilihan biasa ialah indent=4, walaupun sesetengah pangkalan kod lebih suka dua ruang atau aksara tab; konvensyen gaya berbeza antara projek.

. separators argumen membolehkan anda memperhalusi ruang kosong dengan lebih lanjut, memberikan tuple seperti (", ", ": ") secara lalai untuk output mesra manusia. Jika anda mahukan perwakilan yang paling padat—contohnya untuk mengurangkan saiz muatan melalui rangkaian—anda boleh menetapkan separators=(",", ":") untuk mengalih keluar ruang selepas koma dan titik bertindih.

Apabila anda mengambil berat tentang output deterministik, contohnya dalam ujian unit atau perbandingan snapshot, mengaktifkan sort_keys=True menjadikan pengekod mengeluarkan kunci kamus dalam susunan yang disusun. Dengan cara itu, dua larian yang menghasilkan data yang serupa secara semantik tidak berbeza hanya kerana kamus berlaku untuk mengeluarkan kunci dalam urutan yang berbeza.

Bersama-sama, indent, separators, dan sort_keys memberi anda banyak kawalan sama ada JSON anda dioptimumkan untuk mesin (padat, tiada ruang kosong) atau untuk manusia (inden, sejajar, dengan bentuk yang stabil merentasi larian).

Data Bersarang, Strategi Penghuraian dan Corak Akses

Dalam JSON dunia sebenar, struktur rata adalah pengecualian; anda biasanya akan berurusan dengan objek dan tatasusunan bersarang. Fikirkan rekod pengguna biasa dalam aplikasi e-dagang: maklumat peribadi, alamat penghantaran bersarang, butiran pengebilan bersarang dan mungkin senarai pesanan, yang setiap satunya merupakan struktur kompleks tersendiri.

Apabila menyahkod JSON ke dalam Python, data bersarang menjadi gabungan kamus dan senarai, dan anda boleh mengaksesnya menggunakan carian indeks dan kekunci standard. Untuk struktur cetek, ini mudah: data, data, Dan sebagainya.

Untuk struktur bersarang mendalam atau dinamik, anda mungkin lebih suka pendekatan yang lebih generik, seperti menulis fungsi rekursif kecil yang mencari kunci atau yang berjalan di atas pokok dict dan senarai. Penyelesaian rekursif selalunya lebih pendek dan lebih mudah dibaca daripada penyelesaian lelaran apabila merentasi data bersarang secara sewenang-wenangnya.

JSON tidak bersarang (rata) lebih mudah diakses secara langsung dengan kekunci berkod keras, yang boleh menjadi sangat baik untuk utiliti kecil atau apabila anda mengawal input sepenuhnya. Walau bagaimanapun, apabila menggunakan API luaran, adalah perkara biasa untuk menulis fungsi pembantu kecil yang merangkumi struktur, jadi anda tidak menaburkan rantai di seluruh pangkalan kod anda.

Tidak kira kedalamannya, sama sahaja json.loads() tingkah laku terpakai: Fungsi ini menerima rentetan JSON dan menghasilkan jenis Python asli yang kemudiannya anda manipulasikan dengan alatan Python biasa. Tiada sintaks khas diperlukan melebihi biasa dict dan list pengindeksan.

Bekerja Dengan Fail JSON: Membaca, Menulis dan Menambah

JSON menghasilkan format storan ringan yang sangat berguna untuk projek kecil, fail konfigurasi atau skrip yang perlu mengekalkan keadaan berterusan. Daripada terus mendapatkan pangkalan data penuh, anda selalunya boleh menggunakan satu atau dua fail JSON untuk tempoh yang agak lama.

Menulis JSON ke fail biasanya merupakan proses dua langkah: bersirikan data Python dengan json.dumps() atau secara langsung dengan json.dump(), dan kemudian pastikan rentetan yang terhasil ditulis ke cakera. Jika anda memanggil open('data.json', 'w'), anda akan mendapat pemegang fail dalam mod tulis yang sama ada mencipta fail atau memendekkannya jika ia sudah wujud.

Untuk struktur bersarang, protokol ini tidak berbeza daripada data rata: awak masih guna yang sama json.dump() panggilan, dan kombinasi senarai dan dict yang bersarang dikodkan secara rekursif. Satu-satunya keputusan yang biasanya perlu anda buat ialah berapa banyak indentasi yang anda inginkan untuk kebolehbacaan berbanding saiz fail.

Membaca JSON daripada fail adalah sebaliknya: buka fail dalam mod teks, serahkan objek fail kepada json.load(), dan anda akan mendapat kembali struktur data Python anda. Sekali lagi, tingkah laku tersebut adalah bebas daripada sejauh mana penyarangan berlaku—penyahkod mengendalikan semua itu untuk anda.

Jika anda perlu menambahkan data JSON pada fail sedia ada, perkara akan menjadi lebih terperinci. JSON itu sendiri tidak menyokong "penambahan penstriman" dengan cara yang mudah kerana keseluruhan fail mestilah JSON yang sah. Corak biasa adalah menyimpan tatasusunan rekod dan membaca/mengubah suai/menulis keseluruhan tatasusunan atau menggunakan JSON yang dipisahkan baris di mana setiap baris ialah objek JSON berasingan yang boleh anda tambahkan tanpa menulis semula baris sebelumnya.

JSON Di Dunia Nyata: API, Storan dan Pertukaran

Sebaik sahaja anda mula membina aplikasi sebenar, JSON dengan cepat menjadi gam yang menghubungkan klien dan pelayan web, perkhidmatan mikro dan API pihak ketiga. Ia dihargai kerana ia padat dan kerana manusia masih boleh membaca dan mengeditnya dengan agak mudah.

Dalam interaksi API, JSON setakat ini merupakan format muatan yang paling biasa, terutamanya dalam perkhidmatan RESTful. Aplikasi Python biasanya menggunakan pustaka seperti requests untuk menghantar permintaan HTTP dan terima respons JSON, kemudian hurai respons tersebut dengan json.loads() atau dengan kaedah pembantu yang membungkusnya.

JSON juga merupakan format yang popular untuk fail konfigurasi dan log, di mana sifat berstruktur dan nilai kuncinya menjadikannya lebih ekspresif daripada teks biasa sambil kekal ringkas berbanding pangkalan data penuh. Komponen sistem boleh berkongsi konfigurasi melalui JSON dan agregator log boleh menghuraikan log JSON untuk menapis atau menganalisisnya dengan lebih mudah.

Satu lagi kes penggunaan besar ialah pensirialisasian dan penyahsirialisasian struktur data, menukar koleksi dalam memori kepada rentetan JSON (pensirialisasian) dan kemudian membinanya semula kemudian (penyahsirialisasian). Ini adalah cara anda menyimpan pilihan pengguna, menghantar mesej berstruktur melalui baris gilir atau menghantar objek bersarang merentasi sempadan perkhidmatan, dengan syarat anda berpegang pada jenis yang serasi dengan JSON atau menyediakan pengekod tersuai.

Selain JSON sahaja, kod Python selalunya perlu menukar antara JSON dan format lain, seperti XML, CSV atau teks biasa. Contohnya, anda mungkin membaca CSV daripada sistem legasi, mengubahnya menjadi senarai dict dan kemudian membuangnya sebagai JSON untuk API moden. Atau anda boleh menarik JSON daripada API, menormalkannya dan menulis CSV untuk penganalisis memuatkan ke dalam hamparan.

Pemformatan, Pengesahan dan Operasi Tambahan pada JSON

Sebaik sahaja anda selesa dengan asas membaca dan menulis, terdapat banyak operasi kecil tetapi berguna yang boleh anda lakukan pada data JSON untuk meningkatkan aliran kerja anda: pemformatan untuk kebolehbacaan, meratakan struktur bersarang, mengesahkan bahawa rentetan benar-benar JSON dan menyusun data untuk perbandingan yang konsisten.

Percetakan cantik dengan json.dumps(..., indent=...) adalah langkah pertama, memberikan anda hierarki jarak yang kemas yang memudahkan anda mengenal pasti isu struktur dengan pantas. Ini amat membantu semasa penyahpepijatan atau apabila berkongsi contoh dalam dokumentasi.

Perataan JSON bersarang boleh memudahkan pemprosesan dan analisis hiliran, terutamanya jika anda perlu menukar data kepada bentuk jadual seperti CSV atau memasukkannya ke dalam alat yang menjangkakan pasangan nilai kunci dan bukannya objek bersarang dalam. Anda biasanya melaksanakan perataan sendiri menggunakan rekursi atau traversal iteratif ke atas dict dan senarai.

Mengesahkan JSON selalunya bermuara kepada cuba menghuraikannya dan menangkap pengecualian, terutamanya jika anda hanya mengesahkan bahawa rentetan adalah betul secara sintaksis. Untuk semakan yang lebih teliti, anda boleh menggunakan Skema JSON dan pustaka luaran, tetapi untuk kebanyakan kes, cara yang mudah try/except sekitar json.loads() sudah cukup.

Mengisih data JSON mengikut nilai atau kekunci tertentu boleh membantu apabila membandingkan respons, menjana snapshot yang stabil untuk ujian, atau hanya memastikan objek yang serupa dikumpulkan bersama. Anda boleh menyusun senarai dan dict Python yang mendasari sebelum membuang atau bergantung pada sort_keys=True apabila tumpuan diberikan pada susunan kunci dalam objek.

Pengendalian Ralat Semasa Bekerja Dengan JSON

Sistem yang berstruktur dengan baik pun boleh mengalami JSON yang salah bentuk atau data yang tidak dijangka, jadi pengendalian ralat yang mantap di sekitar penghuraian dan pengekodan JSON adalah penting. Python menyatakan masalah ini melalui pengecualian, dan cara idiomatik untuk menanganinya adalah dengan membungkus operasi dalam try...except Blok.

Semasa menyahkod JSON, isu yang paling biasa ialah sintaks yang tidak sah, seperti tanda petikan yang hilang di sekitar nama hartanah atau koma di belakang. json modul akan menimbulkan ralat penyahkodan (biasanya json.JSONDecodeError), yang boleh anda tangkap dan rekodkan atau tukarkan kepada mesej mesra pengguna.

Contohnya, cuba menghuraikan rentetan yang rosak mungkin mengakibatkan ralat seperti: Failed to decode JSON: Expecting property name enclosed in double quotes: line 1 column 29 (char 28)Mesej seperti ini bukan sahaja memberitahu anda bahawa penghuraian gagal tetapi juga di mana dalam input penghurai itu keliru.

Pada bahagian pengekodan, anda mungkin tekan TypeError apabila cuba membuat siri jenis yang tidak disokong, or ValueError jika anda tidak membenarkan NaN dan infiniti melalui allow_nan=False tetapi data anda mengandungi nilai sedemikian. Rujukan bulat dalam bekas juga boleh mencetuskan RecursionError jika anda melumpuhkan semakan pekeliling.

Amalan terbaik adalah untuk melayan operasi JSON sebagai I/O yang boleh salah, terutamanya apabila membaca daripada sumber rangkaian atau fail luaran: sentiasa anggap sesuatu mungkin tidak kena dan tangkap pengecualian dengan sewajarnya, mungkin menambah lapisan pengesahan untuk menguatkuasakan kekangan yang lebih khusus pada data anda. json.loads() atau kaedah pembantu API dalam try...except blok melindungi seluruh kod anda daripada kegagalan bertingkat dan membolehkan anda kembali ralat JSON mesra pengguna kepada pelanggan apabila sesuai.

Menggunakan JSON Dengan API Web Dalam Python

Kebanyakan API web yang anda gunakan daripada Python akan menghantar dan menerima JSON, dan susunan pembangunan biasa menggabungkan requests perpustakaan (untuk HTTP) dengan json modul (untuk menghuraikan dan menjana JSON). Gabungan ini menjadikan penyepaduan API terasa sangat semula jadi.

Corak biasa adalah dengan memanggil titik akhir API, semak sama ada kod status respons menunjukkan kejayaan, kemudian menghuraikan isi JSON . Dari situ anda boleh mengakses medan, mengendalikan data bersarang dan memetakan respons ke dalam model domain anda sendiri atau melihat objek.

Pengendalian ralat menjadi sangat penting apabila panggilan rangkaian terlibat, kerana anda bukan sahaja boleh menghadapi JSON yang tidak sah tetapi juga tamat masa, ralat sambungan atau kegagalan bahagian pelayan yang bertindak balas dengan HTML dan bukannya JSON. json.loads() atau kaedah pembantu API dalam try...except blok melindungi seluruh kod anda daripada kegagalan bertingkat.

Setelah dihuraikan, API JSON bertindak seperti struktur data Python yang lain, jadi semua teknik yang dibincangkan sebelum ini—cetakan, perataan, pengesahan, pengisihan—digunakan secara langsung. Keselesaan bergerak antara data Python dan JSON merupakan peningkatan produktiviti yang besar apabila anda menghubungkan perkhidmatan bersama-sama. Jika anda fokus untuk membina aplikasi sebenar , memberi perhatian kepada corak pengendalian JSON lebih awal akan menjimatkan masa penyahpepijatan kemudian.

JSON dalam Python kurang mengenai panggilan fungsi tunggal dan lebih kepada kotak alat: pemetaan jenis yang jelas, parameter pengekodan fleksibel, cangkuk untuk jenis tersuai, I/O fail yang ringkas tetapi berkuasa dan corak yang mantap untuk menghuraikan, memformat dan mengesahkan data dari dunia luar, semuanya menjadikan JSON sesuai untuk pengaturcara Python yang berurusan dengan aplikasi berasaskan data moden.