Уроки курса
1 Введение в Python и философия дзен
30 мин
2 Переменные и динамическая типизация
30 мин
3 Базовые типы данных: числа, строки и булевы значения
30 мин
4 Изменяемые и неизменяемые объекты (Mutable vs Immutable)
30 мин
5 Форматирование строк и f-строки
30 мин
6 Углубленная работа со списками
30 мин
7 Кортежи и их особенности
30 мин
8 Словари под капотом
30 мин
9 Множества и математические операции
30 мин
10 Генераторы списков (List Comprehensions)
30 мин
11 Генераторы словарей и множеств
30 мин
12 Встроенные функции для коллекций
30 мин
13 Условные операторы и логические выражения
30 мин
14 Циклы while и управление потоком
30 мин
15 Итерация с циклом for
30 мин
16 Конструкции for...else и while...else
30 мин
17 Функции enumerate и zip
30 мин
18 Создание собственных функций (def)
30 мин
19 Позиционные и именованные аргументы
30 мин
20 Проблема изменяемых аргументов по умолчанию
30 мин
21 Произвольное число аргументов (*args и **kwargs)
30 мин
22 Область видимости переменных (LEGB)
30 мин
23 Анонимные функции (lambda)
30 мин
24 Функции высшего порядка
30 мин
25 Замыкания (Closures)
30 мин
26 Введение в объектно-ориентированное программирование
30 мин
27 Атрибуты классов и экземпляров
30 мин
28 Магический метод __init__
30 мин
29 Методы экземпляра
30 мин
30 Инкапсуляция и сокрытие данных
30 мин
31 Декоратор @property
30 мин
32 Наследование классов
30 мин
33 Переопределение методов и функция super()
30 мин
34 Полиморфизм в Python
30 мин
35 Магические методы строк (__str__ и __repr__)
30 мин
36 Обработка исключений (try-except)
30 мин
37 Блоки else и finally
30 мин
38 Генерация собственных исключений (raise)
30 мин
39 Открытие и чтение файлов
30 мин
40 Запись данных в файлы
30 мин
41 Контекстные менеджеры (with)
30 мин
42 Работа с форматом JSON
30 мин
43 Модули и импорты
30 мин
44 Полезные модули стандартной библиотеки
30 мин
45 Модуль datetime
30 мин
46 Модуль collections
30 мин
47 Виртуальные окружения (venv)
30 мин
48 Установка сторонних пакетов через pip
30 мин
49 Организация структуры Python-проекта
30 мин
50 Финальный проект: создание приложения
30 мин
К курсу

Работа с форматом JSON

Сериализация структур Python в текстовый формат и десериализация данных для обмена информацией.

Прогресс урока: 0%

Введение в сериализацию и формат JSON

Добро пожаловать в один из важнейших уроков уровня Intermediate! Сегодня мы переходим от изолированных скриптов к программам, которые умеют общаться с внешним миром. В современной разработке приложения редко существуют в вакууме. Они обмениваются данными с веб-серверами, читают конфигурационные файлы, сохраняют пользовательские настройки и взаимодействуют с базами данных. Но как передать сложный объект Python, например, словарь, содержащий списки и другие словари, через сеть? Объекты в памяти компьютера представлены в виде бинарных данных, зависящих от архитектуры процессора и версии интерпретатора. Если мы попытаемся просто 'переслать' область памяти с объектом на другой компьютер, он не сможет ее прочитать. Здесь на сцену выходит концепция сериализации.

Сериализация — это процесс перевода структуры данных или состояния объекта в формат, который можно сохранить (например, в файл или буфер памяти) или передать по сети и затем восстановить в той же или другой компьютерной среде. Противоположный процесс, то есть извлечение структуры данных из серии байтов или строки, называется десериализацией. В мире Python и веб-разработки абсолютным стандартом для сериализации текстовых данных стал формат JSON (JavaScript Object Notation).

JSON был популяризован Дугласом Крокфордом в начале 2000-х годов как легковесная альтернатива XML. XML был слишком тяжеловесным, требовал закрывающих тегов и сложного парсинга. JSON же основан на подмножестве языка JavaScript, но при этом является полностью независимым от языка форматом. Он легко читается людьми и быстро парсится машинами. Важно понимать: несмотря на название, JSON сегодня используется в Java, C++, Go, Ruby и, конечно, в Python. Это универсальный язык общения между программами.

Философия Python (Дзен Python) гласит: 'Явное лучше, чем неявное' и 'Простое лучше, чем сложное'. JSON идеально вписывается в эту философию. В отличие от встроенного в Python модуля pickle, который может сериализовать практически любой объект Python, JSON является текстовым форматом и поддерживает только ограниченный набор базовых типов данных. Это делает его безопасным для обмена данными с недоверенными источниками, в то время как pickle может выполнить вредоносный код при десериализации. В этом уроке мы применим подход Scaffolding: начнем с базовых функций, затем перейдем к обработке файлов, а закончим созданием сложных пользовательских сериализаторов для ООП-архитектуры.

Какое из следующих утверждений о формате JSON является верным?

Сравнение типов данных: JSON против Python

Для успешной работы с JSON необходимо четко понимать, как типы данных JSON соотносятся с типами данных Python. Поскольку JSON — это универсальный формат, он не знает о кортежах (tuples), множествах (sets) или комплексных числах Python. Он оперирует только шестью базовыми типами. При сериализации интерпретатор Python автоматически конвертирует свои внутренние типы в эквиваленты JSON, а при десериализации — наоборот. Давайте детально разберем это соответствие.

1. Объект (Object) в JSON представляет собой неупорядоченный набор пар 'ключ-значение', заключенный в фигурные скобки {}. Ключами всегда должны быть строки в двойных кавычках. В Python этот тип данных идеально ложится на словарь (dict).

2. Массив (Array) в JSON — это упорядоченная коллекция значений, заключенная в квадратные скобки []. Значения могут быть любых поддерживаемых типов. В Python массиву JSON соответствует список (list) и кортеж (tuple). Важно отметить, что при конвертации кортежа в JSON он станет массивом, а при обратной десериализации этого массива вы получите список, а не кортеж. Это классический пример 'потери информации о типе' при сериализации.

3. Строка (String) в JSON должна быть заключена исключительно в двойные кавычки (""). Символы экранируются обратным слешем. В Python это тип str (при этом Python поддерживает как одинарные, так и двойные кавычки, но при генерации JSON модуль строго использует двойные).

4. Число (Number) в JSON не имеет разделения на целые числа и числа с плавающей точкой в спецификации (все числа считаются десятичными). Однако парсер Python достаточно умен, чтобы конвертировать целые числа JSON в int, а числа с десятичной точкой или экспонентой — в float.

5. Логическое значение (Boolean) в JSON представлено литералами true и false (с маленькой буквы). В Python им соответствуют True и False (с большой буквы).

6. Пустое значение (Null) в JSON записывается как null. В Python ему полностью соответствует объект None.

Понимание этой таблицы конвертации критически важно. Многие начинающие разработчики сталкиваются с ошибками, когда пытаются скормить парсеру JSON строку, где ключи обернуты в одинарные кавычки, или где используется значение True вместо true. Помните: JSON строг в своем синтаксисе. Любое отклонение приведет к ошибке JSONDecodeError.

Тип данных в JSON Тип данных в Python
Object {} dict
Array [] list (иногда tuple при сериализации)
String "..." str
Number (12, 3.14) int, float
true / false True / False
null None

Если у вас есть кортеж Python `my_tuple = (1, 2, 3)`, во что он превратится после сериализации в JSON и последующей обратной десериализации?

Модуль json в Python: Первое знакомство

Для работы с JSON в стандартной библиотеке Python существует встроенный модуль, который так и называется — json. Вам не нужно устанавливать его через pip, он доступен сразу 'из коробки'. Под капотом этот модуль частично написан на языке Си (C), что делает его чрезвычайно быстрым и эффективным при обработке больших объемов данных. Модуль предоставляет простой и интуитивно понятный API, состоящий из четырех основных функций. Их легко запомнить, если разделить по типу источника данных: работа со строками в памяти и работа с файлами на диске.

Для работы со строками используются функции с суффиксом 's' (от слова string):

  • json.dumps(obj) — сериализует объект Python в JSON-строку. (dump string)
  • json.loads(s) — десериализует JSON-строку s в объект Python. (load string)

Для работы с файловыми объектами используются функции без суффикса:

  • json.dump(obj, fp) — сериализует объект и записывает его напрямую в открытый файловый объект (file pointer).
  • json.load(fp) — читает JSON-данные из файлового объекта и десериализует их в объект Python.

Почему разработчики разделили эти функции? Дело в управлении памятью. Если у вас есть JSON-файл размером в несколько гигабайт, использование связки file.read() + json.loads() приведет к тому, что весь файл сначала будет загружен в оперативную память как одна гигантская строка, а затем парсер создаст еще один гигантский словарь. Это может вызвать MemoryError. Функция json.load() работает с потоками (streams) и парсит данные по мере их чтения из файла, что является более оптимизированным подходом.

Давайте начнем нашу практику с функции json.loads() — десериализации строк. Представьте, что мы получили данные от внешнего API (например, информацию о пользователе). Эти данные приходят в виде обычной строки. Наша задача — превратить эту строку в удобный словарь Python, чтобы обращаться к данным по ключам.

Какая функция из модуля json используется для преобразования JSON-СТРОКИ в словарь Python? (введите имя функции без скобок)

python 
import json

# Имитация ответа от API (это строка! Обратите внимание на одинарные кавычки снаружи и двойные внутри)
api_response = '{"user_id": 42, "username": "neo", "is_active": true, "roles": ["admin", "user"], "profile": null}'

print("Тип данных api_response:", type(api_response))

# Десериализация JSON-строки в Python словарь
user_data = json.loads(api_response)

print("\nТип данных user_data:", type(user_data))
print("Данные пользователя:", user_data)

# Теперь мы можем обращаться к данным как к обычному словарю Python
print("\nID пользователя:", user_data['user_id'])
print("Активен ли пользователь?", user_data['is_active']) # Вернет Python True

Разбор кода: Десериализация с json.loads()

В приведенном выше примере мы сначала импортировали модуль json. Далее мы создали переменную api_response. Обратите внимание: это обычная строка. Мы специально обернули ее в одинарные кавычки '...', чтобы внутри строки можно было свободно использовать двойные кавычки " для ключей JSON, не прибегая к экранированию с помощью слэша (\"). Если бы мы попытались использовать одинарные кавычки внутри JSON, функция парсинга мгновенно выбросила бы исключение, потому что стандарт JSON строго требует двойных кавычек.

Затем вызывается магия: json.loads(api_response). Эта функция сканирует строку символ за символом. Она видит открывающую фигурную скобку { и понимает: 'Ага, я должна создать словарь'. Она видит ключ "user_id", создает строку в Python. Видит число 42 — создает тип int. Когда она доходит до true, она преобразует его в питоновский True, а null превращается в None. Наконец, массив ["admin", "user"] конвертируется в полноценный список list.

В результате мы получаем объект user_data с типом <class 'dict'>. Теперь это не просто текст, это структурированные данные. Мы можем использовать мощь Python для работы с ними: обращаться по ключам user_data['user_id'], итерироваться в цикле for key, val in user_data.items() или использовать методы словаря .get() для безопасного извлечения значений.

Симуляция Code Review:
Junior разработчик: Зачем нам этот модуль json? Я читал на StackOverflow, что можно просто использовать встроенную функцию eval(). Она же тоже превращает строку словаря в словарь, и код работает!
Senior разработчик: Это классическая и очень опасная ошибка. Функция eval() вычисляет произвольный Python-код. Если в api_response злоумышленник подставит строку '__import__("os").system("rm -rf /")', твой код выполнит эту команду, и мы потеряем все данные на сервере. Модуль json абсолютно безопасен: он занимается только парсингом данных и никогда не выполняет код. Кроме того, eval() не поймет JSON-специфичные значения вроде true (со строчной буквы) или null.

Этот диалог подчеркивает важнейшее правило безопасности (Security Best Practice): Никогда не доверяйте внешним данным. Всегда используйте специализированные парсеры. Модуль json гарантирует, что из строки будут извлечены только данные, и ничего кроме данных.

Какая строка вызовет ошибку `json.decoder.JSONDecodeError` при попытке использовать на ней `json.loads()`?

Исключения при десериализации: JSONDecodeError

Что происходит, когда внешнее API ломается и отправляет нам 'битый' текст вместо правильного JSON? Или если пользователь опечатался в конфигурационном файле? Разработка устойчивого программного обеспечения (Robust Software Engineering) требует от нас готовности к таким ситуациям. Модуль json предоставляет специальное исключение для обработки ошибок парсинга — json.JSONDecodeError.

Эта ошибка генерируется всякий раз, когда функция loads или load сталкивается с синтаксисом, не соответствующим стандарту JSON. Давайте рассмотрим самые частые причины возникновения JSONDecodeError:

  1. Использование одинарных кавычек: Как мы уже выяснили, ключи и строковые значения должны быть в двойных кавычках. Если строка выглядит как {'key': 'value'}, это валидный синтаксис Python, но невалидный JSON.
  2. Отсутствующие или лишние кавычки: Например, {"name: "John"} (забыли закрыть кавычку после name).
  3. Висячая запятая (Trailing comma): В Python можно оставить запятую после последнего элемента словаря или списка: [1, 2, 3,]. В JSON это строго запрещено. Строка {"a": 1,} вызовет ошибку парсинга (Expecting property name enclosed in double quotes).
  4. Неэкранированные спецсимволы: Если в строковой переменной JSON присутствует табуляция, перенос строки или сама двойная кавычка без экранирующего слеша (\), парсер сломается.
  5. Получение HTML вместо JSON: Частая ситуация при работе с веб-API. Если сервер упал (ошибка 500), он может вернуть HTML-страницу с ошибкой вместо ожидаемого JSON. Попытка распарсить HTML тег <html> приведет к немедленной ошибке.

Объект исключения JSONDecodeError содержит полезные атрибуты для отладки. Он не просто говорит 'ошибка', он сообщает, где именно произошла ошибка! У него есть атрибуты msg (описание ошибки), doc (исходный невалидный документ), pos (индекс символа с ошибкой), lineno (номер строки) и colno (номер колонки). Это делает процесс отладки невероятно удобным, особенно при разборе больших многострочных JSON-файлов.

python 
import json

bad_json_string = '{
    "name": "Alice",
    "age": 25,
    "city": "London",
}'  # ОШИБКА: Запятая после последнего элемента (London)

try:
    # Пытаемся распарсить невалидный JSON
    data = json.loads(bad_json_string)
except json.JSONDecodeError as err:
    print(f"❌ Критическая ошибка парсинга JSON!")
    print(f"Сообщение: {err.msg}")
    print(f"Строка: {err.lineno}, Колонка: {err.colno}")
    print(f"Позиция символа: {err.pos}")
    # Мы можем безопасно продолжить работу программы, 
    # присвоив data значение по умолчанию
    data = {}

print("Итоговые данные:", data)

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

Код, который мы только что рассмотрели, демонстрирует профессиональный подход к написанию парсеров. Мы не позволяем программе аварийно завершиться (crash), если входные данные оказались скомпрометированными. Вместо этого мы оборачиваем вызов json.loads() в блок try...except, ловим конкретное исключение json.JSONDecodeError (что гораздо лучше, чем ловить абстрактный Exception, который может скрыть другие баги) и извлекаем метаданные ошибки.

В выводе консоли этот скрипт напечатает сообщение: 'Expecting property name enclosed in double quotes'. Почему? Потому что после запятой парсер ожидал увидеть следующий ключ в двойных кавычках, а встретил закрывающую фигурную скобку }. В атрибутах lineno и colno мы увидим точную координату этой скобки. В реальных проектах эти координаты записываются в систему логирования (log files), чтобы разработчики могли быстро найти проблему, а пользователю отправляется дружелюбное сообщение: 'Не удалось обработать ответ от сервера. Пожалуйста, попробуйте позже'.

Важный нюанс: исключение JSONDecodeError наследуется от встроенного ValueError. Поэтому, если в старом легаси-коде вы встретите конструкцию except ValueError: при разборе JSON, не пугайтесь — это будет работать, так как JSONDecodeError является 'ребенком' ValueError. Однако в современном Python 3.x настоятельно рекомендуется использовать явный json.JSONDecodeError для повышения читаемости (Дзен Python: 'Явное лучше, чем неявное').

Теперь, когда мы научились безопасно извлекать данные из JSON в объекты Python, настало время изучить обратный процесс. Как наши питоновские словари, списки и булевы значения превратить в красивую текстовую JSON-строку для отправки на сервер? Для этого мы будем использовать функцию json.dumps().

От какого базового исключения (built-in exception) наследуется json.JSONDecodeError?

Что вызовет ошибку `JSONDecodeError` в следующем фрагменте: `'{"settings": [1, 2, 3, ]}'`?

Сериализация Python объектов: json.dumps()

Функция json.dumps() (от слов 'dump string') берет объект Python и переводит его в текстовый формат JSON, возвращая строку. Это один из самых часто используемых инструментов при написании бэкенда на Python (например, на фреймворках Django, Flask или FastAPI). Когда клиент (браузер или мобильное приложение) запрашивает данные, бэкенд формирует словарь с результатами, сериализует его в JSON и отправляет по протоколу HTTP.

Давайте посмотрим на простой пример: у нас есть словарь, описывающий конфигурацию игры. В нем есть числа, булевы значения, None и вложенные списки. Мы передаем этот словарь в json.dumps(). Интерпретатор проходит по каждому элементу. Он видит ключ словаря и, если это не строка (например, число), он автоматически преобразует его в строку (потому что ключи JSON могут быть только строками!). Затем он смотрит на значение. True конвертируется в текстовое true, None — в null. Если интерпретатор встречает объект, который он не знает, как сериализовать (например, объект пользовательского класса, функцию или байтовую строку), он выбрасывает исключение TypeError: Object of type X is not JSON serializable.

По умолчанию json.dumps() создает максимально компактную строку. В ней нет переносов строк, пробелов после двоеточий или запятых. Это сделано для экономии трафика: чем меньше байт, тем быстрее данные передадутся по сети. Этот процесс называется минификацией. Однако для человека такая 'сплошная' строка совершенно нечитаема, особенно если словарь большой. Для отладки и создания читаемых конфигурационных файлов json.dumps() предоставляет мощный арсенал аргументов форматирования, таких как indent, separators и sort_keys.

Важный аспект, который часто упускают: кодировка. JSON стандарт предписывает использовать Unicode (по умолчанию UTF-8). В Python 3 все строки по умолчанию являются юникодными. Однако модуль json имеет параметр ensure_ascii, который по умолчанию установлен в True. Что это значит? Это значит, что все не-ASCII символы (например, русские буквы, иероглифы, эмодзи) будут экранированы в формат \uXXXX. Строка 'Привет' превратится в "\u041f\u0440\u0438\u0432\u0435\u0442". С точки зрения спецификации JSON, это абсолютно корректно, и любой парсер обратно соберет слово 'Привет'. Но читать это глазами невозможно, и размер строки увеличивается. Мы разберем, как отключить это поведение.

python 
import json

# Подготовка сложного словаря Python
game_state = {
    "player": "Иван",
    "score": 15400,
    "is_alive": True,
    "inventory": ["Меч", "Щит", "Зелье лечения"],
    "current_quest": None,
    "coordinates": (15.5, 42.1)  # Кортеж
}

# 1. Базовая сериализация (все слитно, кириллица экранирована)
compact_json = json.dumps(game_state)
print("Базовый dump:")
print(compact_json)
print("-" * 40)

# 2. Сериализация с отключенным экранированием ASCII (читаемая кириллица)
unicode_json = json.dumps(game_state, ensure_ascii=False)
print("С ensure_ascii=False:")
print(unicode_json)

Разбор форматирования: ensure_ascii и кортежи

Если вы запустите код выше, в первом выводе ('Базовый dump') вы увидите нечто невразумительное: {"player": "\u0418\u0432\u0430\u043d", ... }. Это работает защита ensure_ascii=True. Функция гарантирует, что результирующая строка содержит исключительно символы из таблицы ASCII (латинский алфавит, цифры, базовая пунктуация). Эта защита осталась со времен Python 2 и старых систем, которые не умели нормально работать с UTF-8. В современном мире, где UTF-8 поддерживается везде, от баз данных до браузеров, мы практически всегда хотим видеть реальные символы.

Установив аргумент ensure_ascii=False, мы приказываем парсеру: 'Не экранируй Unicode-символы, оставляй их как есть'. Во втором выводе мы ясно увидим имя 'Иван' и предметы инвентаря на русском языке. Это не только улучшает читаемость, но и значительно уменьшает размер итоговой строки, так как один кириллический символ в UTF-8 занимает 2 байта, а экранированная последовательность \u0418 — целых 6 байт (символы \, u, 0, 4, 1, 8).

Вторая важная деталь, которую демонстрирует код — это обработка кортежа (Tuple). В словаре game_state у нас есть ключ "coordinates": (15.5, 42.1). Как мы помним из таблицы соответствий типов, в JSON нет концепции кортежей (неизменяемых массивов). Поэтому модуль json неявно конвертирует этот кортеж в стандартный массив JSON. В итоговой строке мы увидим квадратные скобки: "coordinates": [15.5, 42.1]. Этот процесс является односторонним! Если мы сразу же вызовем json.loads() на этой строке, координаты вернутся к нам в виде питоновского списка list, а не кортежа. Разработчик должен учитывать эту 'потерю иммутабельности' при проектировании систем, использующих сериализацию.

Помимо кодировки, базовая функция dumps выдает результат в одну длинную строку. Если словарь содержит сотни ключей, ориентироваться в таком JSON человеку будет крайне сложно. Для решения этой проблемы существует аргумент indent, который позволяет настроить Pretty Printing (красивый вывод).

Какой тип данных из Python вызовет ошибку TypeError при попытке использовать json.dumps()?

Продвинутое форматирование: indent, separators и sort_keys

Добавление параметра indent (отступ) преобразует 'кашу' из символов в структурированный, удобочитаемый документ. Значением indent является целое число (количество пробелов для каждого уровня вложенности) или строка (например, "\t" для отступов табуляцией). Обычно в индустрии используют indent=2 или indent=4. Как только вы включаете этот параметр, модуль json автоматически добавляет переносы строк и выравнивает ключи и значения. Это незаменимо для логирования, генерации конфигурационных файлов, которые будут редактировать люди, и при отладке (дебаггинге).

Параметр sort_keys — это булево значение. Если установить его в True, все ключи в итоговом JSON-объекте будут отсортированы по алфавиту перед сериализацией. Зачем это нужно? До версии Python 3.7 словари не сохраняли порядок добавления элементов. Сегодня они его сохраняют, но при получении данных из разных источников (база данных, кэш, другие API) порядок ключей может отличаться, даже если само содержимое словарей идентично. Если вы хотите сравнить два JSON-документа посимвольно (например, при вычислении хеша для проверки целостности данных или для кэширования), они должны быть строго идентичны. Сортировка ключей гарантирует детерминированный (предсказуемый) результат: одинаковые словари всегда дадут идентичную JSON-строку.

Наконец, параметр separators предоставляет низкоуровневый контроль над минификацией. Он принимает кортеж из двух строк: (item_separator, key_separator). По умолчанию, если indent не задан, используются значения (', ', ': '). Обратите внимание на пробелы после запятой и двоеточия. Они делают строку чуть более читаемой, но тратят лишние байты. Если мы разрабатываем высоконагруженную систему (HighLoad) и хотим выжать максимум производительности, мы можем передать separators=(',', ':') (без пробелов!). Это самая агрессивная форма минификации в Python, удаляющая абсолютно все лишние байты из итоговой строки.

Симуляция Code Review:
Junior разработчик: Я написал скрипт для сохранения настроек пользователя в файл. Использовал json.dumps(config, indent=4). Работает отлично!
Senior разработчик: Для файла конфигурации, который будет открывать человек в блокноте, это идеальный подход. Но я вижу, что ты использовал этот же код для отправки данных в Redis (кэш в оперативной памяти). Там не нужен indent. Каждый пробел и перенос строки — это потраченная оперативная память. В кэш мы должны писать максимально плотно. Замени там на dumps(config, separators=(',', ':')). Всегда выбирай формат в зависимости от конечного потребителя (человек или машина).

python 
import json

user_profile = {
    "username": "admin",
    "role": "superuser",
    "active": True,
    "permissions": ["read", "write", "delete"]
}

# 1. Читаемый формат (Pretty Print) для людей
pretty_json = json.dumps(user_profile, indent=4, sort_keys=True)
print("Читаемый формат (indent=4, sort_keys=True):")
print(pretty_json)
print("-" * 40)

# 2. Ультра-компактный формат для машинной передачи (убираем пробелы)
compact_json = json.dumps(user_profile, separators=(',', ':'))
print("Ультра-компактный (separators=(',', ':')):")
print(compact_json)

# Сравним размер в байтах
print(f"\nРазмер читаемого: {len(pretty_json)} байт")
print(f"Размер компактного: {len(compact_json)} байт")

Какой параметр `json.dumps` отвечает за сортировку ключей словаря по алфавиту? (введите имя параметра)

Вы разрабатываете API с высокой нагрузкой и хотите минимизировать объем передаваемых данных. Какая комбинация параметров json.dumps() наиболее эффективна для этой задачи?

Работа с файлами: json.load() и json.dump()

До сих пор мы работали со строками в оперативной памяти (методы loads и dumps). Но что, если конфигурация нашего приложения хранится на жестком диске в файле config.json? Или мы хотим сохранить результаты парсинга веб-сайта в файл data.json? Для этого используются функции без суффикса 's': json.load() и json.dump(). Они принимают так называемый файлоподобный объект (file-like object). В подавляющем большинстве случаев это объект, возвращаемый встроенной функцией open().

Главное правило при работе с файлами в Python — всегда использовать контекстный менеджер with. Он гарантирует, что файл будет безопасно закрыт после завершения работы (или в случае возникновения ошибки). Это освобождает системные ресурсы и сбрасывает (flush) буферы записи на диск. Если вы забудете закрыть файл, открытый на запись, часть данных может остаться в памяти, и файл на диске окажется поврежденным или неполным.

Синтаксис чтения из файла: json.load(file_pointer). Функция читает поток данных из открытого файла и налету конвертирует их в объекты Python. Это работает немного эффективнее, чем чтение всего файла в строку через file.read() с последующим вызовом json.loads(), так как интерпретатор может оптимизировать процесс обработки потока.

Синтаксис записи в файл: json.dump(obj, file_pointer). Первый аргумент — сериализуемый объект Python, второй — файловый объект, открытый на запись (с модом 'w'). Здесь действуют абсолютно все те же параметры форматирования, что и в dumps: вы можете передавать indent, ensure_ascii и другие.

Критический нюанс — Кодировка файла! При вызове функции open() в Python на разных операционных системах используется разная кодировка по умолчанию. В Linux и macOS это UTF-8. А вот в операционной системе Windows функция open() по умолчанию часто использует системную кодировку cp1251. Поскольку стандарт JSON требует использования UTF-8, вы всегда, абсолютно всегда должны явно указывать параметр encoding='utf-8' в функции open(). Если вы этого не сделаете, скрипт, отлично работавший на Mac, вызовет фатальную ошибку UnicodeDecodeError у пользователя Windows при попытке сохранить русскоязычные данные.

python 
import json
import os

# Данные, которые мы хотим сохранить на диск
app_settings = {
    "theme": "dark",
    "volume": 85,
    "notifications": True,
    "language": "Русский"
}

file_name = "settings.json"

# ЗАПИСЬ В ФАЙЛ (dump)
# Обязательно указываем encoding="utf-8" и используем with!
with open(file_name, mode="w", encoding="utf-8") as file:
    # Передаем объект и файловый указатель
    json.dump(app_settings, file, indent=4, ensure_ascii=False)

print(f"Данные успешно сохранены в файл {file_name}")

# ЧТЕНИЕ ИЗ ФАЙЛА (load)
with open(file_name, mode="r", encoding="utf-8") as file:
    loaded_settings = json.load(file)

print("Данные успешно прочитаны:")
print(loaded_settings['language'])  # Выведет 'Русский'

# Уборка за собой (для чистоты урока удаляем файл)
os.remove(file_name)

Какой код правильно и безопасно записывает словарь `data` в файл `output.json`?

Задание

Практическая задача: Обновление конфигурации. Представьте, что у вас есть скрипт, который должен загрузить настройки из файла config.json, увеличить значение параметра 'run_count' на 1, и перезаписать этот же файл.

  • Откройте файл config.json на чтение ('r') с использованием with и utf-8.
  • Десериализуйте содержимое файла в переменную config с помощью json.load().
  • Увеличьте config['run_count'] на 1.
  • Откройте файл config.json на запись ('w') с использованием with.
  • Сохраните обновленный словарь config в файл с помощью json.dump(), используя indent=4.
10 баллов

Проблема пользовательских классов: TypeError

До этого момента мы работали с идеальными сценариями: словари, списки, базовые числа и строки. Но реальное промышленное программирование строится на парадигме ООП (Объектно-Ориентированное Программирование). Мы создаем классы для моделирования бизнес-логики: User, Product, Order. Что произойдет, если мы попытаемся передать экземпляр нашего собственного класса в функцию json.dumps()?

Интерпретатор Python попытается это сделать, посмотрит на свой внутренний список поддерживаемых типов (string, integer, float, boolean, None, list, dict) и, не найдя там вашего класса, мгновенно сгенерирует исключение TypeError: Object of type X is not JSON serializable. Модуль json 'глупый' — он не знает, какие именно атрибуты вашего объекта нужно сохранить, а какие (например, внутренние кэши или временные состояния) следует проигнорировать.

Давайте рассмотрим пример: у нас есть класс Employee. У него есть имя, должность и зарплата. Чтобы сериализовать этот объект, мы должны взять этот процесс под свой контроль и объяснить парсеру, как превратить этот класс в базовый тип данных Python (как правило, в словарь), который модуль json уже умеет переводить в текстовый формат. В Python существует два основных способа решения этой проблемы: использование аргумента default в функции dumps() и создание собственного класса-наследника json.JSONEncoder.

Метод через параметр default — это самый простой и быстрый путь для небольших проектов. Параметр default принимает функцию-колбэк (callback function). Когда json.dumps() наталкивается на объект неизвестного ему типа, он вызывает эту функцию и передает ей непонятный объект. Функция должна изучить объект и вернуть его сериализуемое представление. Если функция тоже не знает, что делать с объектом, она должна сама выбросить TypeError. Это изящный способ внедрить свою логику прямо в процесс парсинга.

python 
import json

class Employee:
    def __init__(self, name, position):
        self.name = name
        self.position = position

# Функция-обработчик неизвестных объектов
def custom_encoder(obj):
    # Проверяем, является ли объект экземпляром нашего класса
    if isinstance(obj, Employee):
        # Возвращаем словарь с нужными атрибутами (его json уже умеет парсить!)
        return {
            "__class__": "Employee", # Метаданные для десериализации (опционально)
            "name": obj.name,
            "position": obj.position
        }
    # Если мы не знаем этот тип, выбрасываем стандартную ошибку
    raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")

# Создаем экземпляр класса
worker = Employee("Алиса", "Инженер")

# Передаем нашу функцию в параметр default
result = json.dumps(worker, default=custom_encoder, ensure_ascii=False, indent=2)
print("Сериализованный объект класса Employee:")
print(result)

Разбор: Сериализация через функцию default

Обратите внимание на то, как элегантно работает функция custom_encoder. Когда json.dumps() доходит до переменной worker, он понимает, что не умеет работать с объектами <class '__main__.Employee'>. Вместо падения с ошибкой, он передает этот объект в нашу функцию custom_encoder.

Внутри функции мы используем встроенную функцию isinstance(obj, Employee). Если проверка пройдена, мы вручную собираем словарь dict. В этом словаре мы извлекаем атрибуты obj.name и obj.position. Этот словарь возвращается обратно в json.dumps(). Так как словарь — это поддерживаемый тип, сериализация успешно завершается! Мы также добавили специальный ключ "__class__": "Employee". С точки зрения формата JSON, это просто строка. Но в будущем, при обратной десериализации, этот ключ послужит нам 'маячком' (маркером), указывающим на то, что этот словарь нужно превратить не просто в словарь, а обратно в класс Employee.

Хотя использование параметра default отлично подходит для простых скриптов, в крупных проектах с множеством файлов и классов (Enterprise level), передавать эту функцию в каждый вызов dumps становится утомительно. Кроме того, логика сериализации размазывается по всему проекту. Для таких случаев в Python предусмотрен более архитектурно правильный способ — наследование от класса json.JSONEncoder.

Класс JSONEncoder — это движок, который осуществляет сериализацию под капотом модуля. Создав свой класс, унаследованный от него, мы можем переопределить метод default(self, o). Преимущество этого подхода заключается в том, что мы инкапсулируем логику преобразования сложных объектов (Datetimes, UUID, Custom Classes) в одном месте. Затем мы можем передать наш класс-кодировщик в параметр cls функции dumps. Это эталонный пример применения принципов объектно-ориентированного дизайна (Solid, паттерн Strategy) в стандартной библиотеке Python.

Как называется параметр функции json.dumps(), который принимает функцию-обработчик для конвертации неизвестных типов объектов в поддерживаемые?

Какую ошибку выбрасывает json.dumps() по умолчанию, если попытаться сериализовать пользовательский объект без указания параметра default или cls?

Продвинутая сериализация: Subclassing JSONEncoder

Давайте реализуем подход с использованием собственного класса кодировщика (Custom Encoder). Мы создадим сложный объект — Order, внутри которого будут храниться объекты класса Product. Это типичный сценарий интернет-магазина. Нам нужен мощный класс, который сможет 'распаковать' всю эту иерархию.

Наш кодировщик должен унаследовать json.JSONEncoder. В нем мы переопределяем метод default(self, obj). Внутри этого метода мы можем использовать цепочку if-elif для проверки типа объекта (isinstance). Если объект соответствует классу Order, мы возвращаем его атрибуты в виде словаря. Если это Product, мы делаем то же самое. И самое важное правило при переопределении методов родительских классов: если объект не подходит ни под одно из наших условий, мы обязаны вызвать реализацию метода базового класса с помощью super().default(obj). Базовый класс сам сгенерирует правильное исключение TypeError или обработает объект, если он оказался базовым типом.

Этот паттерн проектирования называется Chain of Responsibility (Цепочка обязанностей). Мы пытаемся обработать объект сами; если не можем — передаем ответственность 'наверх', родительскому классу. Это обеспечивает расширяемость кода и предотвращает подавление ошибок (swallowing exceptions).

Еще один частый хак, который используют разработчики для быстрой сериализации объектов: использование встроенного атрибута __dict__. Почти каждый объект в Python хранит свои атрибуты в словаре __dict__. Вместо того чтобы вручную перечислять {"name": obj.name, "price": obj.price}, можно просто вернуть obj.__dict__. Однако с этим нужно быть осторожным: если объект содержит внутренние атрибуты (например, ссылки на открытые соединения с базой данных), они тоже попадут в JSON, что приведет к новым ошибкам TypeError.

python 
import json

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

class Order:
    def __init__(self, order_id, items):
        self.order_id = order_id
        self.items = items # Список объектов Product

# Создаем свой мощный кодировщик
class ShopEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, Product):
            return {"type": "Product", "name": obj.name, "price": obj.price}
        elif isinstance(obj, Order):
            return {"type": "Order", "id": obj.order_id, "items": obj.items}
        # Если тип неизвестен, передаем работу базовому классу
        return super().default(obj)

# Собираем данные
p1 = Product("Ноутбук", 120000)
p2 = Product("Мышь", 1500)
my_order = Order(991, [p1, p2])

# Сериализация с использованием аргумента cls
json_string = json.dumps(my_order, cls=ShopEncoder, indent=2, ensure_ascii=False)
print("Результат работы ShopEncoder:")
print(json_string)

Десериализация пользовательских классов: object_hook

Мы научились превращать объекты Python в JSON. Теперь давайте решим обратную задачу. Мы получили по сети JSON-строку с данными заказа: {"type": "Order", "id": 991, "items": [...]}. Если мы просто вызовем json.loads(), мы получим обычный Python-словарь (dict). Мы не сможем вызвать методы этого объекта или насладиться автодополнением кода (autocomplete) в IDE, так как IDE не знает, что это словарь заказа. Нам нужно превратить этот словарь обратно в инстанс класса Order.

Для этого в функциях loads() и load() предусмотрен потрясающе мощный параметр — object_hook (дословно 'хук на объект'). Это тоже функция-колбэк. Принцип ее работы таков: модуль json парсит строку в обычном режиме снизу вверх. Каждый раз, когда он успешно собирает из строки новый словарь, он немедленно передает этот словарь в нашу функцию object_hook. Наша функция может посмотреть на содержимое словаря, понять, что это за сущность, создать соответствующий объект Python и вернуть его вместо исходного словаря.

Как функция поймет, какой класс нужно создать? Здесь вступают в игру те самые 'маячки' (маркеры), которые мы заботливо добавляли при сериализации. В нашем предыдущем примере мы добавили ключи "type": "Product" и "type": "Order". Внутри object_hook мы просто проверяем наличие этого ключа. Если dict['type'] == 'Product', мы вызываем конструктор класса Product. Если нет — возвращаем словарь как есть (это может быть просто обычный словарь, не относящийся к нашим классам).

Важно отметить порядок обхода (Bottom-Up Parsing). Парсер сначала собирает самые глубокие вложенные объекты. В нашем примере Order содержит массив Product. Это значит, что object_hook сначала сработает для каждого товара (Product), превратит словари товаров в объекты Product, и только затем он доберется до словаря Order. И в словаре Order по ключу items уже будет лежать список настоящих питоновских объектов Product, готовый к передаче в конструктор Order(id, items). Это избавляет нас от необходимости писать рекурсивные алгоритмы вручную — парсер делает всю сложную работу за нас.

python 
import json

# Наши классы
class User:
    def __init__(self, username, role):
        self.username = username
        self.role = role
        
    def __repr__(self):
        return f"<Объект User: {self.username} (Роль: {self.role})>"

# Входящий JSON с маркером __class__
incoming_json = '{"__class__": "User", "username": "neo", "role": "admin"}'

# Функция для параметра object_hook
def custom_decoder(dct):
    # Проверяем наличие нашего секретного маркера
    if "__class__" in dct:
        if dct["__class__"] == "User":
            # Создаем и возвращаем объект!
            return User(username=dct["username"], role=dct["role"])
    # Если маркера нет, возвращаем обычный словарь
    return dct

# Десериализация с хуком
parsed_obj = json.loads(incoming_json, object_hook=custom_decoder)

print("Тип результата:", type(parsed_obj))
print("Объект:", parsed_obj)
print("Обращение к атрибуту:", parsed_obj.username)

В каком порядке функция, переданная в параметр object_hook, обрабатывает вложенные JSON-объекты (словари)?

Какой параметр в функциях json.loads() и json.load() позволяет перехватывать разобранные словари и конвертировать их в пользовательские объекты Python?

Боль системы: Объекты datetime в JSON

Существует одна проблема, с которой сталкивается 100% разработчиков на Python рано или поздно: сериализация объектов даты и времени (модуль datetime). Практически в любой базе данных, в любом логе, в любом профиле пользователя есть временные метки: 'дата регистрации', 'время последнего входа', 'срок действия токена'. В Python мы используем объекты datetime.datetime для работы с этим. Но знаете ли вы, что стандарт JSON не имеет типа данных 'Дата'?

Действительно, в JSON есть только числа, строки, булевы значения, списки и словари. Даты там не предусмотрено. Поэтому вызов json.dumps({"created_at": datetime.now()}) приведет к фатальной ошибке TypeError: Object of type datetime is not JSON serializable. Модуль json просто отказывается работать с датами, потому что не существует единого стандарта форматирования: кто-то хочет видеть DD.MM.YYYY, кто-то MM/DD/YY, а кто-то Unix Timestamp (количество секунд с 1970 года). Разработчики Python решили не навязывать формат, оставив решение программисту (Дзен Python: 'В случае сомнений, не поддавайся искушению угадывать').

В индустрии сложился стандарт де-факто: формат ISO 8601. Он выглядит так: 2023-10-25T14:30:00.000Z. Он сортируется лексикографически, не имеет проблем с перестановкой дня и месяца и поддерживается всеми языками программирования (например, в JavaScript функция JSON.stringify() автоматически конвертирует объекты Date именно в этот формат). В Python получить такую строку у объекта datetime можно с помощью метода .isoformat().

Чтобы заставить json.dumps() автоматически переводить все объекты datetime в формат ISO 8601, мы можем использовать уже знакомый нам параметр default. Создаем простую функцию, которая проверяет тип объекта, и если это datetime или date — вызывает его метод isoformat().

python 
import json
from datetime import datetime, date

# Словарь с датой и временем
event = {
    "name": "Конференция Python",
    "start_date": date(2024, 5, 15),
    "created_at": datetime.now()
}

# Универсальный обработчик дат
def json_serial(obj):
    # Проверяем, относится ли объект к типу datetime или date
    if isinstance(obj, (datetime, date)):
        return obj.isoformat() # Возвращаем ISO строку
    raise TypeError(f"Тип {type(obj)} не поддерживается")

# Сериализуем данные
result = json.dumps(event, default=json_serial, indent=2, ensure_ascii=False)
print("Успешная сериализация с датами:")
print(result)

Задание

Практическое задание: Вы - разработчик API. Напишите класс CustomEncoder, который наследуется от json.JSONEncoder и переопределяет метод default для поддержки сериализации объектов datetime в формат ISO 8601.

  • Создайте класс CustomEncoder(json.JSONEncoder).
  • Переопределите метод default(self, obj).
  • Внутри метода проверьте: if isinstance(obj, datetime):
  • Если проверка пройдена, верните obj.isoformat().
  • В конце метода обязательно верните super().default(obj) для обработки базовых типов.
10 баллов

Тонкая настройка парсера: parse_float и parse_int

Допустим, мы пишем приложение для финансовых вычислений или обработки криптовалютных транзакций. В таких приложениях точность имеет критическое значение. Вы, вероятно, знаете, что стандартный тип float в Python (и в большинстве других языков) имеет ограниченную точность и может страдать от проблем округления. Например, 0.1 + 0.2 дает 0.30000000000000004. Если мы получаем из JSON данные о балансе банковского счета и они парсятся как float, мы можем потерять деньги на погрешности округления.

Для таких задач в Python существует специальный модуль decimal и класс Decimal, который обеспечивает точную арифметику десятичных чисел. Но как заставить функцию json.loads() создавать объекты Decimal вместо стандартных float при чтении JSON-документа? Использовать object_hook здесь не получится, потому что он перехватывает словари (объекты JSON), а число — это примитивный тип, не словарь.

Для решения этой продвинутой задачи в функциях десериализации (loads, load) предусмотрены специальные хуки: parse_float и parse_int. Параметр parse_float принимает любую вызываемую функцию (callable). Каждый раз, когда парсер JSON встречает число с плавающей точкой в строке, он не конвертирует его в float сам, а передает эту строку в вашу функцию. Функция должна вернуть то представление числа, которое вам нужно.

Чтобы конвертировать все дробные числа из JSON в высокоточные объекты Decimal, достаточно импортировать класс Decimal и передать его в этот параметр. Это работает, потому что Decimal — это класс, конструктор которого принимает строку! Парсер передаст строку '3.14', и будет вызван код Decimal('3.14'), что создаст абсолютно точный объект. Аналогичным образом работает parse_int: вы можете использовать его для конвертации гигантских чисел, если ваш проект имеет специфические требования к хранению целых чисел (хотя в Python тип int и так имеет неограниченную длину).

python 
import json
from decimal import Decimal

# Представим, что это ответ от криптовалютной биржи
finance_json = '{"bitcoin_balance": 1.123456789, "price": 45000.5}'

# 1. Обычный парсинг (потеря точности из-за float)
normal_data = json.loads(finance_json)
print("Обычный float:", normal_data["bitcoin_balance"])
print("Тип:", type(normal_data["bitcoin_balance"]))

print("-" * 30)

# 2. Парсинг с использованием parse_float и Decimal (абсолютная точность)
# Передаем сам класс Decimal (без скобок!) как функцию-обработчик
accurate_data = json.loads(finance_json, parse_float=Decimal)
print("Точный Decimal:", accurate_data["bitcoin_balance"])
print("Тип:", type(accurate_data["bitcoin_balance"]))

# Теперь математика будет точной:
# normal_data['price'] * Decimal('1.1') вызовет ошибку TypeError, так как float и Decimal не смешиваются
# accurate_data['price'] * Decimal('1.1') сработает идеально!

Какой параметр `json.loads()` позволяет перехватить процесс парсинга дробных чисел и использовать класс `Decimal` вместо стандартного `float`?

Опасности: Security, Limits и NaN

Хотя парсер JSON в Python невероятно стабилен и защищен (в отличие от модуля pickle или функции eval()), есть несколько 'подводных камней', о которых должен знать Senior-разработчик. Первый подводный камень касается спецификации самих чисел.

В стандарте JSON (RFC 8259) строго сказано: числовые значения NaN (Not a Number - не число) и Infinity (Бесконечность) не поддерживаются. Однако, по умолчанию парсер Python json отступает от строгого стандарта ради удобства программистов. Если вы напишете json.dumps(float('inf')), вы получите строку Infinity. При обратном чтении json.loads('Infinity') вы получите объект float('inf'). Проблема в том, что если вы отправите такой нестандартный JSON в браузер (JavaScript) или в приложение на Java/C#, их парсеры упадут с синтаксической ошибкой!

Чтобы защитить себя от генерации невалидного (с точки зрения других языков) JSON, вы можете использовать параметр allow_nan=False в функции dumps. В этом случае, если попытаться сериализовать float('inf') или float('nan'), модуль выбросит исключение ValueError: Out of range float values are not JSON compliant. Это классический пример 'Strict Mode' (строгого режима), который заставляет нас придерживаться мировых стандартов.

Вторая потенциальная проблема связана с лимитами (Resource Exhaustion). Злоумышленник может послать на ваш сервер JSON-строку с гигантским уровнем вложенности: [[[[[[[[ ... ]]]]]]]] (тысячи скобок). В некоторых старых версиях Python или в специфичных парсерах это приводило к исчерпанию лимита рекурсии стека (RecursionError) и падению сервера. Современный модуль json на базе C-расширения устойчив к базовым атакам, но потребление памяти всё равно пропорционально размеру файла. Если на вход API без ограничения размера тела запроса (body size limit в Nginx/FastAPI) подать 5-гигабайтный JSON, парсер попытается загрузить его в оперативную память, что гарантированно убьет процесс (OOM Killer). Защита здесь происходит не на уровне парсера, а на уровне архитектуры: всегда ограничивайте максимальный размер принимаемого payload'а от пользователей (например, не больше 2 MB).

Задание

Проект 'Менеджер Конфигурации'. Разработайте архитектуру модуля настроек.

  • Создайте файл 'default_config.json' с базовыми настройками (отступы, цвета).
  • Напишите функцию load_config(filename). Внутри используйте блок try-except.
  • Если файл существует, используйте with open() и json.load() для получения словаря.
  • Если файла нет (FileNotFoundError) или он поврежден (json.JSONDecodeError), функция должна перехватить ошибку и вернуть словарь по умолчанию.
  • Напишите функцию save_config(config_dict, filename), использующую json.dump(indent=4) для красивого сохранения настроек обратно на диск.
10 баллов

Интеграция знаний: Парсинг реального API

Давайте сведем все полученные знания в единый проект. Представьте, что вы пишете скрипт для парсинга погоды. Вы делаете HTTP-запрос к внешнему серверу (используя библиотеку requests) и получаете длинную текстовую строку в формате JSON. Этот JSON содержит вложенные структуры (массивы словарей), данные в разных форматах и некоторые лишние поля, которые нам не нужны.

Процесс работы с таким ответом обычно включает несколько шагов (Pipeline). Шаг 1: Валидация. Мы не доверяем внешнему API, поэтому оборачиваем парсинг в try...except JSONDecodeError. Если API вернул ошибку 502 Bad Gateway в виде HTML, наш скрипт не упадет, а корректно залогирует проблему. Шаг 2: Извлечение нужных данных. JSON возвращает гигантское дерево, но нам нужна только температура и описание погоды на сегодняшний день. Мы обращаемся к данным через цепочку ключей: data['forecast'][0]['temperature']. Шаг 3: Преобразование типов (опционально). Если API возвращает температуру как строку '22.5', мы конвертируем ее во float. Шаг 4: Сериализация. Извлеченные и очищенные данные мы упаковываем в новый, небольшой словарь и сохраняем его в локальный файл кэша weather_cache.json с помощью json.dump().

Этот паттерн (Получение -> Парсинг -> Трансформация -> Сериализация) является классическим паттерном ETL (Extract, Transform, Load) в миниатюре. Овладение этим навыком делает вас ценным специалистом, способным писать коннекторы (Connectors) к любым современным веб-сервисам: Telegram-ботам, платежным системам (Stripe, PayPal), CRM-системам и базам данных. В следующем блоке кода мы симулируем весь этот процесс.

python 
import json

# Симуляция ответа от Weather API (строка)
raw_api_response = '''
{
    "status": "success",
    "metadata": {"server_id": "eu-west-1", "time": "2023-11-01T12:00:00Z"},
    "data": {
        "city": "Москва",
        "forecast": [
            {"day": "today", "temp": 4.5, "condition": "Дождь"},
            {"day": "tomorrow", "temp": 6.0, "condition": "Облачно"}
        ]
    }
}
'''

def process_weather_data(json_string):
    try:
        # 1. Безопасная десериализация
        parsed_data = json.loads(json_string)
    except json.JSONDecodeError as e:
        print(f"Ошибка формата API ответа: {e}")
        return

    # 2. Проверка статуса (Бизнес-логика)
    if parsed_data.get("status") != "success":
        print("API вернуло статус ошибки.")
        return

    # 3. Извлечение вложенных данных (Навигация по словарям и спискам)
    city = parsed_data["data"]["city"]
    today_forecast = parsed_data["data"]["forecast"][0]
    temp = today_forecast["temp"]
    condition = today_forecast["condition"]

    print(f"Погода в городе {city}:")
    print(f"Температура: {temp}°C, {condition}")

    # 4. Сохранение очищенных данных для дальнейшего использования (Сериализация)
    clean_data = {"city": city, "temperature": temp, "desc": condition}
    
    with open("weather_cache.json", "w", encoding="utf-8") as file:
        json.dump(clean_data, file, ensure_ascii=False, indent=2)
    print("Данные сохранены в weather_cache.json")

# Запуск проекта
process_weather_data(raw_api_response)

В примере кода переменная raw_api_response содержит JSON строку. Как получить доступ к значению температуры (4.5) после десериализации этой строки в переменную parsed_data?

Заключение модуля

Поздравляем! Вы прошли глубокий и интенсивный курс по работе с форматом JSON в Python. Мы вышли далеко за пределы простого заучивания 'dumps/loads' и разобрали архитектурные аспекты сериализации. Вы узнали, почему важно контролировать кодировку через ensure_ascii=False, как сделать вывод красивым с помощью indent, и как оптимизировать трафик с помощью separators. Мы изучили работу с файловой системой и важность контекстного менеджера with open() с явным указанием кодировки utf-8.

Более того, мы погрузились в ООП и научились 'обучать' парсер работать с вашими собственными классами (User, Product, Datetime) с помощью параметров default, cls (subclassing JSONEncoder) и object_hook для десериализации. Вы узнали о ловушках с кортежами (которые превращаются в списки), об опасностях функции eval() и о том, как извлекать абсолютную точность для финансовых систем с помощью parse_float=Decimal.

Овладение JSON — это ваш билет в мир веб-технологий. Теперь вы готовы создавать микросервисы (Microservices), писать конфигурации для докера, сохранять состояния ботов и общаться с любыми REST API в мире. Всегда помните о безопасности: обрабатывайте JSONDecodeError и не доверяйте входящим данным. Практикуйтесь на реальных открытых API (например, PokeAPI или OpenWeatherMap), парсите их ответы и сохраняйте в файлы. Успехов в написании надежного и чистого кода (Pythonic way)!

Предыдущий урок Следующий урок