Ръководство на програмиста за данни в Python и JSON

Начало » Питон » Ръководство на програмиста за данни в Python и JSON

JSON тихомълком се превърна в езика по подразбиране за данни в мрежата, и ако пишете на Python, ще се натъкнете на него навсякъде: API, конфигурационни файлове, малки „бази данни“ за странични проекти, лог файлове и дори тестови конфигурации. Разбиране как типовете данни на Python се съпоставят с JSON и как json Модулът, който наистина работи, е едно от онези умения, които изведнъж опростяват много ежедневни задачи.

Това ръководство разглежда JSON от гледна точка на Python програмист. обяснение какво е JSON, как се свързва с JavaScript, кои типове в Python може да представлява и как да се анализира, генерира, прецизира, валидира и персонализира JSON с помощта на jsonЩе разгледаме и реални случаи на употреба, като работа с файлове и API, както и трикове за обработка на вложени данни и гранични случаи, като грешки или специални стойности, например... NaN и безкрайности.

Какво е JSON и как се свързва с данните в Python

JSON, съкращение от JavaScript Object Notation, е текстов формат за структурирани данни. който първоначално е заимствал синтаксиса си от JavaScript обекти и масиви. Въпреки корените си в JavaScript, JSON е езиково независим и се поддържа от почти всеки съвременен език, включително Python, което го прави идеален за обмен на данни между услуги, клиенти и сървъри.

Концептуално, JSON използва само два съставни градивни елемента: JavaScript обект и JavaScript масивОбектът се държи много подобно на речник на Python, а масивът се държи като списък на Python. С тези два елемента, плюс малък набор от примитивни типове, JSON може да описва сложни вложени структури от данни.

Един обект в JavaScript (и JSON) изглежда така: {"key1": value1, "key2": value2}Това е колекция от двойки ключ-стойност, където ключовете са низове, а стойностите могат да бъдат всяка валидна JSON стойност (включително други обекти или масиви). Това съответства много на Python dict.

Масивът в JavaScript (и JSON) е подобен на списък в Python: Това е подредена колекция от стойности, отново използваща всеки валиден JSON тип. Заедно, обектите и масивите могат да бъдат вложени произволно, за да моделират богати данни, като потребителски профили, конфигурационни дървета или API отговори.

Съпоставянето между JSON типовете и Python типовете е много лесно, Ето защо понякога чувате хората да го наричат ​​шеговито „PYON“ (Python Object Notation). Когато Python кодира или декодира JSON, се прилагат следните съответствия:

• JSON обект → Питон dict
• JSON масив → Питон list
• JSON низ → Питон str
• JSON номер (цяло число) → Питон int
• JSON номер (реален) → Питон float
• JSON true → Питон True
• JSON false → Питон False
• JSON null → Питон None

Едно важно ограничение е, че ключовете на JSON обекти винаги са низове, така че, ако кодирате Python dict с ключове, които не са низове (напр. цели числа или кортежи), тези ключове ще бъдат преобразувани в низове или ще генерират грешки в зависимост от вашите настройки. JSON е чудесен за съхранение на структурирани данни като конфигурации или записи, но е... не общ механизъм за мариноване за произволни Python обекти.

Вграденият JSON модул на Python

Python се доставя със стандартен библиотечен модул, наречен json, което ви дава всичко необходимо за работа с JSON: парсиране на низове, зареждане от файлове, сериализиране на Python обекти и персонализиране на начина, по който данните се кодират и декодират. Не е необходима външна зависимост за типичните JSON задачи.

Четирите основни функции, които ще използвате през повечето време, са: json.dumps() намлява json.dump() за конвертиране на Python обекти в JSON и json.loads() намлява json.load() за връщане от JSON към Python типове. Версиите с „s“ работят с низове, докато версиите без „s“ работят с файлоподобни обекти.

- json енкодерът поддържа специфичен набор от Python типове по подразбиране, а именно dict, list, tuple (като масиви), str, числа (int, float, и изброявания, производни на цели/числа с плаваща запетая), и трите специални единични елемента True, False, и NoneТе се конвертират в техните JSON еквиваленти съгласно описаното по-рано съпоставяне.

Ако трябва да сериализирате персонализирани обекти или типове данни, Дизайнът на модула е разширяем: можете да създадете подклас на JSON енкодера и да го имплементирате default() метод или да предадете персонализиран default функция в json.dump() / json.dumps()Този персонализиран hook трябва да върне нещо JSON-сериализиращо се (като dict or list) или повишат TypeError ако не знае как да обработи дадения обект.

Под капака, модулът предлага и методи като encode() намлява iterencode(), които конвертират Python данни в JSON низове, с iterencode() като поетапно се получават кодираните части. Те се използват по-рядко директно, но си струва да се знаят, ако трябва да предавате поточно много големи JSON отговори.

Конвертиране на Python обекти в JSON

Когато искате да превърнете Python данни в JSON текст, използвате json.dump() or json.dumps(), в зависимост от това дали искате да пишете директно във файл или да получите JSON низ в паметта. И двете функции споделят едни и същи основни параметри, които ви позволяват да контролирате как се държи преобразуването.

Функцията json.dump(obj, fp, ...) приема Python обект и файлоподобен обект, и записва JSON представяне на obj към този файл. Неговият еквивалент в паметта, json.dumps(obj, ...), връща JSON низ, вместо да записва във файл. И двата приемат поредица от ключови аргументи, като например skipkeys, ensure_ascii, check_circular, allow_nan, indent, separators, default, и sort_keys.

Всяка от тези опции променя поведението на кодирането по начини, които са от голямо значение в реалните проекти: Можете да изберете дали да пропуснете невалидни ключове, да наложите ASCII изход, да отпечатате резултата, да контролирате празните пространства, да дефинирате персонализирана сериализация за нестандартни обекти или да стабилизирате подредбата на ключовете за тестване и разлики.

Ето какво означават основните параметри на практика:

• skipkeys: ако е зададено на True, ключове от речника, които не са от тип str, int, float, bool or None се пропускат тихо, вместо да се повдигат TypeErrorАко предпочитате бързодействащо поведение, когато ключовете са странни, оставете го както е указано. False.
• ensure_ascii: когато True (по подразбиране), не-ASCII и непечатаемите символи се екранират (напр. като \uXXXX), така че изходът остава чист ASCII. Когато FalseUnicode символите се пишат такива, каквито са, което обикновено е по-добре за четими от човек конфигурации или лог файлове.
• check_circular: if True, енкодерът проверява за циклични препратки в списъци, речници и персонализирани кодирани обекти, за да предотврати безкрайна рекурсия. Задавайки го на False деактивира тази предпазна мрежа и може да доведе до RecursionError ако вашите структури са самореферентни.
• allow_nan: if True, специални стойности с плаваща запетая като NaN, Infinity, и -Infinity са разрешени и кодирани по JavaScript-съвместим начин, въпреки че не са строго валиден JSON според спецификацията. Ако False, опитът за кодиране на такива стойности ще повиши ValueError.
• indent: неотрицателно цяло число (или низ), което контролира красивия печат. Положително число означава, че има толкова интервали на вложено ниво. Низ (като "\t") се използва директно за вдлъбване. None (по подразбиране) избира най-компактното представяне, без допълнителни нови редове освен необходимото.
• separators: кортеж (item_separator, key_separator) контролиране на пунктуацията и интервалите между елементите и между ключовете и стойностите. За най-стегнатия JSON обикновено използвате (",", ":") за да премахнете всички незадължителни интервали.
• default: функция, която получава обект, който енкодерът не знае как да обработи. Тя трябва да върне JSON-сериализиращ се заместител (като dict or list) или повишат TypeErrorТова е основният начин да направите вашите собствени класове сериализируеми.
• sort_keys: if True, речниците са кодирани със сортирани ключове. Това е изключително удобно за регресионни тестове и възпроизводими резултати, където искате JSON дъмповете да са стабилни между изпълненията.

Като конкретна илюстрация, представете си, че имате смесен списък в Python съдържащ цели числа и речник с име, идентификатор и резултат с плаваща запетая. Можете да създадете и съхраните JSON по следния начин:

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 ще бъде добре форматиран благодарение на indent=4, показване на всеки елемент от списъка и ключ от речника на отделен ред. Това прави отстраняването на грешки и ръчното редактиране много по-лесни в сравнение с един единствен, плътен ред текст.

Парсиране на JSON обратно в Python

За да се върнете от JSON текст обратно към Python обекти, използвате съответстващата двойка функции: json.load() (за файлоподобни обекти) и json.loads() (за JSON низове). Тези функции анализират входните данни и пресъздават Python типовете според същата таблица за съпоставяне, както преди.

Подписите изглеждат горе-долу така: json.load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw) намлява json.loads(s, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, kw)На основно ниво можете да ги извикате само с JSON входа, но допълнителните аргументи отварят вратата към по-напреднало поведение при парсиране.

Куки като object_hook намлява object_pairs_hook позволява ви да персонализирате как JSON обектите се превръщат в Python структури, като ви подадем или декодирания dict или списък с (key, value) съответно двойки. Това е полезно, ако искате да изградите персонализирани класове директно от JSON или да запазите подредбата по определен начин.

Други извикаеми функции, като например parse_float, parse_int, и parse_constant позволяват ви да контролирате как се интерпретират числата и специалните токени. Например, може да искате да използвате Decimal вместо float за парични стойности или трансформиране "NaN", "inf", и "-inf" в стражеви обекти по ваш избор.

Продължавайки предишния пример, можете да прочетете JSON файла, който написахте, така:

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

Полученият резултат ще бъде обикновен списък и речник на Python, например , които можете да манипулирате с всички обичайни операции на Python. От гледна точка на вашия код, това отново са „просто данни“.

Какви типове Python може да конвертира в JSON

Не всеки Python обект може да бъде преобразуван в JSON веднага щом е готов за употреба. така че е полезно да запомните разрешения набор. Практическите енкодери поддържат общите типове контейнери и скалари, плюс булеви стойности и Noneи ги съпоставете с минималния набор от JSON типове.

По подразбиране можете безопасно да предадете следните Python обекти в json.dumps():

• dict (кодирано като JSON обекти)
• list намлява tuple (кодирано като JSON масиви)
• str (кодирано като JSON низове)
• int намлява float (кодирано като JSON числа)
• True намлява False (кодирано като true намлява false)
• None (кодирано като null)

Когато Python кодира тези данни, преобразуването обратно в JSON е лесно, и обратно при декодиране. Например, Python tuple става JSON масив и получавате list обратно при зареждане. Преброявания, получени от int or float могат да бъдат кодирани и като числа.

Всичко останало се нуждае от персонализация default секундант (за да превърне обектите в сериализируемо представяне) или ще причини TypeErrorТова е по замисъл: JSON е предназначен за данни, а не за произволни графове на обекти с поведение и методи, каквито бихте могли да сериализирате, използвайки pickle.

За по-голямата част от ежедневната работа, това подмножество от типове обхваща по-голямата част от случаите на употреба, включително полезни товари на API, дървета на конфигурацията, потребителски предпочитания, основни лог файлове и малки „подобни на бази данни“ файлове за прототипи или инструменти за един потребител.

Красив печат, компактен изход и подредени клавиши

Суровият JSON изход е напълно валиден, но е труден за четене. тъй като често се генерира без ненужни интервали. За дебъгване, регистриране или споделяне с други разработчици, често е необходим четлив JSON с отстъпи, вместо едноредов.

- indent параметър на json.dumps() е основният лост за красив печат, което ви позволява да кажете на Python колко интервала (или кой низ) да използва за всяко ниво на отстъп. Типичен избор е indent=4, въпреки че някои кодови бази предпочитат два интервала или табулации; стилистичните конвенции варират между проектите.

- separators аргументът ви позволява да настройвате още повече празните пространства, даване на кортеж като (", ", ": ") по подразбиране за лесен за използване изход. Ако искате възможно най-компактното представяне – например, за да намалите размера на полезния товар в мрежата – можете да зададете separators=(",", ":") за премахване на интервали след запетаи и двоеточия.

Когато ви интересува детерминистичен изход, например при единични тестове или сравнения на моментни снимки, активиращо sort_keys=True кара енкодера да извежда ключовете от речника в сортиран ред. По този начин две изпълнения, които произвеждат семантично идентични данни, не се различават само защото речниците са извели ключове в различна последователност.

Заедно indent, separators, и sort_keys давам ви много контрол дали вашият JSON е оптимизиран за машини (компактен, без празно пространство) или за хора (с отстъп, подравнен, със стабилна форма в различните изпълнения).

Вложени данни, стратегии за парсиране и модели за достъп

В реалния JSON, плоските структури са изключение; Обикновено ще имате работа с вложени обекти и масиви. Представете си типичен потребителски запис в приложение за електронна търговия: лична информация, вложени адреси за доставка, вложени данни за фактуриране и може би списък с поръчки, всяка от които е сложна структура сама по себе си.

При декодиране на JSON в Python, вложените данни се превръщат в комбинации от речници и списъци, и можете да получите достъп до него, използвайки стандартни индексни и ключови търсения. За плитки структури това е лесно: data, data, и така нататък.

За дълбоко вложени или динамични структури може да предпочетете по-общ подход, като например писане на малка рекурсивна функция, която търси ключове или обхожда дърво от речници и списъци. Рекурсивните решения често са по-кратки и по-лесни за четене от итеративните, когато се обхождат произволно вложени данни.

Невложен (плосък) JSON е по-лесен за директен достъп с твърдо кодирани ключове, което може да е напълно приемливо за малки програми или когато контролирате изцяло входните данни. Когато обаче се използват външни API, е обичайно да се пишат малки помощни функции, които капсулират структурата, така че да не се разпръсква... вериги в цялата ви кодова база.

Независимо от дълбочината, едно и също json.loads() поведението се прилага: Функцията приема JSON низ и генерира нативни Python типове, които след това се манипулират с обикновени Python инструменти. Не се изисква специален синтаксис освен нормалния. dict намлява list индексиране.

Работа с JSON файлове: четене, писане и добавяне

JSON е изненадващо удобен и лек формат за съхранение за малки проекти, конфигурационни файлове или скриптове, които трябва да поддържат някакво постоянно състояние. Вместо да посегнете директно към пълна база данни, често можете да се разминете с един или два JSON файла за доста дълго време.

Записването на JSON във файл обикновено е двуетапен процес: сериализирайте Python данни с json.dumps() или директно с json.dump()и след това се уверете, че полученият низ е записан на диска. Ако извикате open('data.json', 'w'), получавате файлов дескриптор в режим на запис, който или създава файла, или го отрязва, ако вече съществува.

За вложените структури протоколът не се различава от плоските данни: все още използваш същото json.dump() извикване, а вложените комбинации от списъци и речници се кодират рекурсивно. Единственото решение, което обикновено трябва да вземете, е колко отстъп искате за по-лесна четливост спрямо размера на файла.

Четенето на JSON от файл е обратното: отваряне на файла в текстов режим, предайте файловия обект на json.load()и получавате обратно структурата си от данни на Python. Отново, поведението е независимо от това колко дълбоко е влагането – декодерът обработва всичко това вместо вас.

Ако трябва да добавите JSON данни към съществуващи файлове, Нещата стават по-нюансирани. Самият JSON не поддържа „стрийминг на добавяне“ по тривиален начин, защото целият файл трябва да е валиден JSON. Често срещан модел е да се съхранява масив от записи и да се чете/модифицира/записва целият масив или да се използва JSON с разделители на редове, където всеки ред е отделен JSON обект, към който можете да добавяте, без да презаписвате предишните редове.

JSON в реалния свят: API, съхранение и обмен

След като започнете да изграждате реални приложения, JSON бързо се превръща в спойката. който свързва уеб клиенти и сървъри, микросървиси и API на трети страни. Цени се както защото е компактен, така и защото хората все още могат да го четат и редактират сравнително лесно.

При взаимодействието с API, JSON е най-разпространеният формат за полезен товар, особено в RESTful услугите. Python приложенията обикновено използват библиотеки като requests да изпраща HTTP заявки и получаване на JSON отговори, след което анализирайте тези отговори с json.loads() или с помощни методи, които го обгръщат.

JSON е също популярен формат за конфигурационни файлове и лог файлове, където структурираният му, ключ-стойностен характер го прави много по-изразителен от обикновения текст, като същевременно остава опростен в сравнение с пълните бази данни. Системните компоненти могат да споделят конфигурация чрез JSON, а агрегаторите на лог файлове могат да анализират JSON лог файлове, за да ги филтрират или анализират по-лесно.

Друг голям случай на употреба е сериализацията и десериализацията на структури от данни, конвертиране на колекции в паметта в JSON низове (сериализация) и последващото им възстановяване (десериализация). Това е начинът, по който съхранявате потребителските предпочитания, предаване на структурирани съобщения чрез опашки или изпращане на вложени обекти през границите на услугите, стига да се придържате към JSON-съвместими типове или да предоставите персонализирани енкодери.

Освен JSON, Python кодът често трябва да конвертира между JSON и други формати, като XML, CSV или обикновен текст. Например, можете да прочетете CSV от стара система, да го трансформирате в списък със словари и след това да го извлечете като JSON за модерен API. Или можете да извлечете JSON от API, да го нормализирате и да напишете CSV, който анализаторите да заредят в електронни таблици.

Форматиране, валидиране и допълнителни операции върху JSON

След като се усвоите с основни умения за четене и писане, Има редица малки, но полезни операции, които можете да извършите с JSON данни, за да подобрите работния си процес: форматиране за по-лесна четливост, изравняване на вложени структури, валидиране дали даден низ наистина е JSON и сортиране на данни за последователни сравнения.

Красив печат с json.dumps(..., indent=...) е първата стъпка, което ви дава добре разположени йерархии, които улесняват забелязването на структурни проблеми с един поглед. Това е особено полезно по време на дебъгване или при споделяне на примери в документация.

Сплескването на вложени JSON може да улесни обработката и анализа надолу по веригата, особено ако трябва да конвертирате данните в таблична форма като CSV или да ги подадете в инструменти, които очакват двойки ключ-стойност, а не дълбоко вложени обекти. Обикновено сами реализирате изравняването, използвайки рекурсия или итеративно обхождане на речници и списъци.

Валидирането на JSON често се свежда до опит за неговото анализиране и улавяне на изключения, особено ако просто проверявате дали даден низ е синтактично правилен. За по-строги проверки можете да използвате JSON Schema и външни библиотеки, но в много случаи е достатъчно просто try/except около json.loads() е достатъчно.

Сортирането на JSON данни по определени стойности или ключове може да помогне при сравняване на отговори, генериране на стабилни снимки за тестове или просто гарантиране, че подобни обекти са групирани заедно. Можете или да сортирате основните списъци и диктанти на Python преди да ги извлечете, или да разчитате на sort_keys=True когато фокусът е върху подреждането на ключовете в обектите.

Обработка на грешки при работа с JSON

Дори добре структурираните системи могат да се сблъскат с деформиран JSON или неочаквани данни, така че стабилната обработка на грешки при парсирането и кодирането на JSON е от решаващо значение. Python изразява тези проблеми чрез изключения, а идиоматичният начин за справяне с тях е да се обвият операциите в try...except блокове.

При декодиране на JSON, най-често срещаният проблем е невалиден синтаксис, като например липсващи кавички около имената на свойствата или запетаи в края. json модулът ще генерира грешка при декодиране (обикновено json.JSONDecodeError), които можете да уловите и регистрирате или да конвертирате в удобни за потребителя съобщения.

Например, опитът за анализиране на счупен низ може да доведе до грешка като: Failed to decode JSON: Expecting property name enclosed in double quotes: line 1 column 29 (char 28)Този вид съобщение ви казва не само, че парсингът е неуспешен, но и къде във входа е допусната грешка от страна на парсера.

От страна на кодирането може да се натъкнете на TypeError при опит за сериализиране на неподдържани типове, or ValueError ако забраните NaN и безкрайности чрез allow_nan=False но вашите данни съдържат такива стойности. Цикличните препратки в контейнерите също могат да задействат RecursionError ако деактивирате кръговите проверки.

Най-добрата практика е да се третират JSON операциите като допускащ грешки входно/изходен сигнал. особено при четене от мрежови източници или външни файлове: винаги приемайте, че нещо може да се обърка и съответно улавяйте изключения, като евентуално добавяте слоеве за валидиране, за да наложите по-специфични ограничения върху данните си. json.loads() или помощни методи на API в try...except блоковете защитават останалата част от кода ви от каскадни грешки и ви позволяват да върнете лесни за ползване JSON грешки на клиентите, когато е уместно.

Използване на JSON с уеб API в Python

Повечето уеб API, с които общувате от Python, ще изпращат и получават JSON, и типичният стек за разработка комбинира requests библиотека (за HTTP) с json модул (за парсиране и генериране на JSON). Тази комбинация прави API интеграцията да изглежда много естествена.

Често срещан модел е да се извика крайна точка на API, проверете дали кодът за състояние на отговора показва успех и след това анализирайте тялото на JSON файлаОттам можете да осъществявате достъп до полета, да обработвате вложени данни и да картографирате отговора в собствените си модели на домейни или да преглеждате обекти.

Обработката на грешки става особено важна, когато са включени мрежови повиквания, защото можете да се сблъскате не само с невалиден JSON, но и с изтичане на времето, грешки при свързване или грешки от страна на сървъра, които отговарят с HTML вместо с JSON. json.loads() или помощни методи на API в try...except блоковете защитават останалата част от кода ви от каскадни грешки.

След като бъде анализиран, API JSON се държи точно както всяка друга структура от данни на Python, така че всички техники, обсъдени по-рано – красив печат, изравняване, валидиране, сортиране – се прилагат директно. Удобството при превключване между данни на Python и JSON е огромно повишаване на производителността, когато свързвате услуги. Ако сте фокусирани върху изграждане на реални приложенияОбръщането на внимание на моделите за обработка на JSON в ранен етап ще спести време за отстраняване на грешки по-късно.

JSON в Python е по-малко за извикване на една функция и повече за набор от инструменти: ясни съпоставяния на типове, гъвкави параметри за кодиране, hooks за персонализирани типове, прост, но мощен файлов вход/изход и стабилни модели за парсиране, форматиране и валидиране на данни от външния свят, всичко това прави JSON естествено решение за Python програмисти, работещи със съвременни приложения, управлявани от данни.