JSON — это язык коммуникации современной веб-разработки, и владеть им в Python — всё равно что иметь универсальный переводчик в мире данных. Когда я начал работать с API, мой код напоминал запутанный лабиринт из строковых манипуляций и регулярных выражений. Встроенный модуль json в Python перевернул моё представление об обработке данных. Независимо от того, разрабатываете ли вы серверные приложения или анализируете данные, этот модуль — ваш надёжный союзник в преобразовании данных. Давайте раскроем всю его мощь, от базовых операций до продвинутых приёмов, которые сделают ваш код не просто рабочим, а элегантным. 🚀

## Основы работы с JSON в Python: модуль json

JSON (JavaScript Object Notation) — лёгкий формат обмена данными, который стал стандартом для веб-сервисов, API и конфигурационных файлов. Python включает модуль `json` в стандартную библиотеку, что избавляет от необходимости устанавливать дополнительные пакеты.

Импортировать модуль просто:

При работе с JSON важно понимать соответствие между типами данных Python и JSON:

| **Тип в Python** | **Тип в JSON** | **Пример в Python** | **Пример в JSON** |
|------------------|----------------|----------------------------|----------------------------|
| dict | object | {"name": "John"} | {"name": "John"} |
| list, tuple | array | [1, 2, 3], (1, 2, 3) | [1, 2, 3] |
| str | string | "Python" | "Python" |
| int, float | number | 42, 3.14 | 42, 3.14 |
| True / False | true / false | True, False | true, false |
| None | null | None | null |

Зная эти соответствия, вы избежите множества проблем при сериализации и десериализации данных. Например, тип `tuple` в Python преобразуется в массив в JSON, а при обратном преобразовании вы получите `list`, а не исходный `tuple`.

Основные методы модуля `json`, которые вы будете использовать чаще всего:

- `json.dumps()` — сериализация объекта Python в строку JSON
- `json.loads()` — десериализация строки JSON в объект Python
- `json.dump()` — сериализация объекта Python и запись в файл
- `json.load()` — чтение и десериализация JSON из файла

Давайте разберём каждый из этих методов более подробно в следующих разделах. 💡

[AsideBanner]
## Сериализация данных Python в JSON: метод dumps()

Метод `json.dumps()` — это ваш основной инструмент для преобразования объектов Python в строки JSON. Название метода можно запомнить как "dump string" — сброс в строку.

> **Сергей Петров, тимлид Python-разработки**
>
> Однажды наша команда столкнулась с проблемой при интеграции с платформой аналитики. Мы отправляли сложные объекты, и API постоянно возвращал ошибки. Тщательное изучение показало, что наши данные содержали кириллические символы и даты, которые некорректно сериализовались.
>
> После нескольких часов отладки мы выработали стандарт для сериализации: всегда используем UTF-8 и предварительно конвертируем даты в строки по ISO. Эта практика избавила нас от 90% проблем с API:
>
> 

import json

python_dict = {
"name": "John",
"age": 30,
"city": "New York"
}

json_string = json.dumps(python_dict)
print(json_string) # Выведет: {"name": "John", "age": 30, "city": "New York"}

pretty_json = json.dumps(python_dict, indent=4, sort_keys=True)
print(pretty_json)
# Выведет:
# {
# "age": 30,
# "city": "New York",
# "name": "John"
# }

data_with_unicode = {
"имя": "Иван",
"город": "Москва"
}

# По умолчанию символы будут преобразованы в \uXXXX
default_json = json.dumps(data_with_unicode)
print(default_json) # {"\\u0438\\u043c\\u044f": "\\u0418\\u0432\\u0430\\u043d", ...}

# Сохраняем оригинальные символы
readable_json = json.dumps(data_with_unicode, ensure_ascii=False)
print(readable_json) # {"имя": "Иван", "город": "Москва"}

# Стандартная сериализация
normal_json = json.dumps(python_dict) # {"name": "John", "age": 30, "city": "New York"}

# Компактная сериализация без пробелов
compact_json = json.dumps(python_dict, separators=(',', ':')) # {"name":"John","age":30,"city":"New York"}

print(f"Обычный: {len(normal_json)} байт")
print(f"Компактный: {len(compact_json)} байт")

class User:
def __init__(self, name, age):
self.name = name
self.age = age

user = User("Alice", 25)

# Это вызовет ошибку TypeError
# json.dumps(user)

# Создаём функцию-конвертер
def user_to_json(obj):
if isinstance(obj, User):
return {"name": obj.name, "age": obj.age}
# Для других типов вызываем стандартное исключение
raise TypeError(f"Объект типа {type(obj)} не сериализуется в JSON")

# Теперь сериализация работает
user_json = json.dumps(user, default=user_to_json)
print(user_json) # {"name": "Alice", "age": 25}

import json

json_string = '{"name": "John", "age": 30, "is_admin": false, "courses": ["Python", "Django"]}'

python_obj = json.loads(json_string)

print(type(python_obj)) # <class 'dict'>
print(python_obj["name"]) # John
print(python_obj["courses"][0]) # Python

nested_json = '''
{
"user": {
"name": "Alice",
"contacts": {
"email": "alice@example.com",
"phone": "123-456-7890"
}
},
"permissions": ["read", "write"],
"active": true
}
'''

data = json.loads(nested_json)

# Доступ к вложенным элементам
email = data["user"]["contacts"]["email"]
print(email) # alice@example.com

# Проверка типов
print(type(data["permissions"])) # <class 'list'>
print(type(data["active"])) # <class 'bool'>

# Параметр parse_float позволяет переопределить обработку чисел с плавающей точкой
from decimal import Decimal

json_with_decimals = '{"price": 19.99, "tax": 1.78}'

# Используем Decimal для точной обработки десятичных дробей
data = json.loads(json_with_decimals, parse_float=Decimal)

# Теперь можно выполнять точные арифметические операции
total = data["price"] + data["tax"]
print(total) # 21.77 (а не 21.77000000000001)
print(type(total)) # <class 'decimal.Decimal'>

# Пример использования object_hook для создания пользовательских объектов
def decode_user(obj):
if "name" in obj and "age" in obj:
return {"type": "user", "data": obj}
return obj

user_json = '{"name": "Bob", "age": 42}'
result = json.loads(user_json, object_hook=decode_user)
print(result) # {'type': 'user', 'data': {'name': 'Bob', 'age': 42}}

import json

data = {
"users": [
{"id": 1, "name": "Alice", "active": True},
{"id": 2, "name": "Bob", "active": False}
],
"total": 2,
"next_id": 3
}

# Запись в файл с форматированием
with open('users.json', 'w', encoding='utf-8') as f:
json.dump(data, f, indent=4, ensure_ascii=False)

# Файл users.json будет содержать отформатированный JSON

# Чтение из файла
with open('users.json', 'r', encoding='utf-8') as f:
loaded_data = json.load(f)

print(loaded_data["users"][0]["name"]) # Alice
print(loaded_data["total"]) # 2

# Пример обработки большого файла построчно
def process_large_json_file(filename):
with open(filename, 'r', encoding='utf-8') as f:
# Считываем файл построчно
for line in f:
# Пропускаем пустые строки и структурные символы
line = line.strip()
if not line or line in '[]{},':
continue

try:
# Пробуем разобрать строку как JSON
if line.endswith(','):
line = line[:-1] # Удаляем запятую в конце
item = json.loads(line)
# Обрабатываем элемент
print(f"Обработан элемент: {item}")
except json.JSONDecodeError:
print(f"Ошибка декодирования строки: {line}")

# Пример с jsonlines
import jsonlines

# Запись в формате jsonlines (каждый объект на отдельной строке)
with jsonlines.open('data.jsonl', mode='w') as writer:
writer.write({"id": 1, "name": "Alice"})
writer.write({"id": 2, "name": "Bob"})

# Чтение из формата jsonlines
with jsonlines.open('data.jsonl') as reader:
for obj in reader:
print(obj["name"])

import json

# 1. Синтаксическая ошибка в JSON
try:
invalid_json = '{"name": "John", "age": 30,}' # Лишняя запятая
data = json.loads(invalid_json)
except json.JSONDecodeError as e:
print(f"Ошибка декодирования: {e.msg} на позиции {e.pos} в строке {e.lineno}")

# 2. Несериализуемые типы данных
try:
from datetime import datetime
data = {"timestamp": datetime.now()} # datetime не сериализуется по умолчанию
json_str = json.dumps(data)
except TypeError as e:
print(f"Ошибка типа: {e}")

def safe_json_loads(json_str, default=None):
"""Безопасная десериализация JSON с возвратом значения по умолчанию при ошибке."""
try:
return json.loads(json_str)
except json.JSONDecodeError as e:
print(f"Ошибка декодирования JSON: {e}")
return default

# Использование
result = safe_json_loads('{"valid": "json"}') # Вернёт словарь
result = safe_json_loads('invalid json', {}) # Вернёт пустой словарь

import json
from datetime import datetime, date
import decimal

# Кастомный энкодер для сложных типов
class ComplexEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, (datetime, date)):
return obj.isoformat()
if isinstance(obj, decimal.Decimal):
return float(obj)
if hasattr(obj, '__dict__'): # Для пользовательских классов
return obj.__dict__
return super().default(obj)

# Данные со сложными типами
data = {
"name": "Product",
"price": decimal.Decimal("19.99"),
"created": datetime.now(),
"tags": ["electronics", "gadgets"]
}

# Сериализация с использованием кастомного энкодера
json_str = json.dumps(data, cls=ComplexEncoder, indent=2)
print(json_str)

# Функция для преобразования словарей в объекты
def object_hook(d):
if 'created' in d:
# Преобразование строки ISO в datetime
try:
d['created'] = datetime.fromisoformat(d['created'])
except ValueError:
pass # Оставляем как строку, если формат не распознан
return d

# Десериализация с обработчиком объектов
parsed_data = json.loads(json_str, object_hook=object_hook)
print(type(parsed_data['created'])) # <class 'datetime.datetime'>

import ijson # pip install ijson

# Для обработки очень больших JSON-файлов
def process_large_json_with_ijson(filename):
with open(filename, 'rb') as f:
# Извлекаем только необходимые поля
for item in ijson.items(f, 'items.item'):
if 'name' in item and item.get('active', False):
print(f"Обработка: {item['name']}")

import jsonschema # pip install jsonschema

# Схема для валидации
schema = {
"type": "object",
"properties": {
"name": {"type": "string"},
"age": {"type": "number", "minimum": 0},
"email": {"type": "string", "format": "email"}
},
"required": ["name", "age"]
}

# Данные для проверки
valid_data = {"name": "John", "age": 30, "email": "john@example.com"}
invalid_data = {"name": "John", "age": -5} # Отрицательный возраст

# Валидация
try:
jsonschema.validate(instance=valid_data, schema=schema)
print("Данные valid_data прошли валидацию")
except jsonschema.exceptions.ValidationError as e:
print(f"Ошибка валидации valid_data: {e}")

try:
jsonschema.validate(instance=invalid_data, schema=schema)
print("Данные invalid_data прошли валидацию")
except jsonschema.exceptions.ValidationError as e:
print(f"Ошибка валидации invalid_data: {e}")

# Вместо стандартного json можно использовать ujson или orjson
# pip install ujson
import ujson

# Сериализация с ujson обычно быстрее
json_str = ujson.dumps(data)
parsed = ujson.loads(json_str)