Модуль json в Python: работа с данными и обмен с API-системами

import json

# Python-словарь
user_data = {
"name": "Алексей",
"age": 30,
"skills": ["Python", "SQL", "Docker"],
"is_active": True,
"address": {
"city": "Москва",
"index": 123456
}
}

# Сериализация в строку JSON
json_string = json.dumps(user_data, ensure_ascii=False, indent=4)
print(json_string)

# Десериализация из строки JSON
parsed_data = json.loads(json_string)
print(parsed_data["name"]) # Алексей

# Запись в файл
with open("user.json", "w", encoding="utf-8") as f:
json.dump(user_data, f, ensure_ascii=False, indent=4)

# Чтение из файла
with open("user.json", "r", encoding="utf-8") as f:
loaded_data = json.load(f)
print(loaded_data["skills"]) # ['Python', 'SQL', 'Docker']

import json
from datetime import datetime

# Создаем данные для сериализации
event = {
"id": 12345,
"title": "Конференция Python разработчиков",
"date": datetime.now(), # Объект datetime не сериализуется стандартно
"participants": ["Анна", "Иван", "Мария"],
"details": {
"location": "Технопарк",
"duration": 3, # часа
"topics": ["Flask", "Django", "FastAPI"]
}
}

# Функция для сериализации datetime
def serialize_datetime(obj):
if isinstance(obj, datetime):
return obj.isoformat()
raise TypeError(f"Объект типа {type(obj)} не сериализуется")

# Компактный JSON без отступов
compact_json = json.dumps(event, default=serialize_datetime)
print("Компактный JSON:", compact_json)

# Форматированный JSON с отступами и сортировкой ключей
pretty_json = json.dumps(
event,
default=serialize_datetime,
indent=4,
sort_keys=True,
ensure_ascii=False
)
print("Форматированный JSON:", pretty_json)

# Запись в файл с пользовательскими разделителями для минимизации размера
with open("event_compact.json", "w", encoding="utf-8") as f:
json.dump(event, f, default=serialize_datetime, separators=(',', ':'))

# Запись в файл форматированного JSON
with open("event_pretty.json", "w", encoding="utf-8") as f:
json.dump(
event,
f,
default=serialize_datetime,
indent=4,
sort_keys=True,
ensure_ascii=False
)

class CustomEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime):
return obj.isoformat()
if hasattr(obj, 'to_json'): # Объекты с методом to_json
return obj.to_json()
return super().default(obj) # Делегируем стандартной обработке

# Использование пользовательского кодировщика
json_string = json.dumps(event, cls=CustomEncoder, indent=4)

import json

# JSON-строка
json_string = '''
{
"name": "Александр",
"age": 28,
"languages": ["Python", "JavaScript", "Go"],
"is_developer": true,
"projects": {
"current": "API Gateway",
"previous": ["CRM System", "E-commerce Platform"]
}
}
'''

# Десериализация из строки
user = json.loads(json_string)
print(f"Имя: {user['name']}, Возраст: {user['age']}")
print(f"Языки: {', '.join(user['languages'])}")
print(f"Текущий проект: {user['projects']['current']}")

# Десериализация из файла
with open("user_data.json", "r", encoding="utf-8") as f:
user_from_file = json.load(f)
print(f"Данные из файла: {user_from_file['name']}")

import json
from datetime import datetime

# JSON-строка с данными о событии
event_json = '''
{
"id": "evt-12345",
"name": "Запуск продукта",
"timestamp": "2023-07-15T14:30:00",
"organizer": {
"id": "usr-789",
"name": "Елена Смирнова",
"role": "Product Manager"
},
"attendees": [
{"id": "usr-123", "name": "Иван Петров"},
{"id": "usr-456", "name": "Анна Иванова"}
],
"location": {
"address": "Инновационный центр",
"room": "A-305"
}
}
'''

# Классы для представления данных
class User:
def __init__(self, id, name, role=None):
self.id = id
self.name = name
self.role = role

def __str__(self):
return f"User(id={self.id}, name={self.name})"

class Event:
def __init__(self, id, name, timestamp, organizer, attendees, location):
self.id = id
self.name = name
self.timestamp = datetime.fromisoformat(timestamp)
self.organizer = organizer
self.attendees = attendees
self.location = location

def __str__(self):
return f"Event(id={self.id}, name={self.name}, attendees={len(self.attendees)})"

# Функция преобразования для object_hook
def json_to_objects(d):
if 'id' in d and 'name' in d and 'role' in d:
return User(d['id'], d['name'], d['role'])
elif 'id' in d and 'name' in d:
return User(d['id'], d['name'])
return d

# Десериализация с преобразованием словарей в объекты
data = json.loads(event_json, object_hook=json_to_objects)

# Создаем объект Event из данных
event = Event(
data['id'], 
data['name'], 
data['timestamp'], 
data['organizer'],
data['attendees'], 
data['location']
)

print(event)
print(f"Организатор: {event.organizer}")
print(f"Дата события: {event.timestamp.strftime('%d.%m.%Y %H:%M')}")
print("Участники:")
for attendee in event.attendees:
print(f"- {attendee}")

import json
import requests

# Получаем данные о погоде по API
response = requests.get(
"https://api.openweathermap.org/data/2.5/weather",
params={
"q": "Moscow,ru",
"appid": "ваш_api_ключ",
"units": "metric"
}
)

# Проверяем успешность запроса
if response.status_code == 200:
# Парсим JSON ответ
weather_data = json.loads(response.text)

# Извлекаем нужные данные
city = weather_data["name"]
temp = weather_data["main"]["temp"]
humidity = weather_data["main"]["humidity"]
weather_desc = weather_data["weather"][0]["description"]

print(f"Погода в городе {city}:")
print(f"Температура: {temp}°C")
print(f"Влажность: {humidity}%")
print(f"Описание: {weather_desc}")
else:
print(f"Ошибка запроса: {response.status_code}")
print(response.text)

import json
import os

# Путь к файлу конфигурации
config_path = "app_config.json"

# Конфигурация по умолчанию
default_config = {
"app_name": "MyAwesomeApp",
"version": "1.0.0",
"database": {
"host": "localhost",
"port": 5432,
"user": "postgres",
"password": "default_password"
},
"logging": {
"level": "INFO",
"file": "app.log"
},
"debug_mode": False
}

# Загрузка конфигурации
def load_config():
# Если файл конфигурации существует, загружаем его
if os.path.exists(config_path):
with open(config_path, "r") as f:
return json.load(f)
else:
# Иначе создаем файл с конфигурацией по умолчанию
with open(config_path, "w") as f:
json.dump(default_config, f, indent=4)
return default_config

# Обновление конфигурации
def update_config(new_settings):
config = load_config()

# Рекурсивное обновление настроек
def update_dict(d, u):
for k, v in u.items():
if isinstance(v, dict) and k in d and isinstance(d[k], dict):
d[k] = update_dict(d[k], v)
else:
d[k] = v
return d

updated_config = update_dict(config, new_settings)

with open(config_path, "w") as f:
json.dump(updated_config, f, indent=4)

return updated_config

# Пример использования
config = load_config()
print(f"Загружена конфигурация для {config['app_name']} v{config['version']}")

# Обновляем настройки
update_config({
"database": {
"password": "new_secure_password"
},
"debug_mode": True
})

import json
import time
from pathlib import Path

class GameState:
def __init__(self, player_name="Unknown", level=1, score=0, inventory=None):
self.player_name = player_name
self.level = level
self.score = score
self.inventory = inventory or []
self.last_saved = None

def add_item(self, item):
self.inventory.append(item)
print(f"Получен предмет: {item}")

def level_up(self):
self.level += 1
self.score += 100
print(f"Уровень повышен! Текущий уровень: {self.level}")

def save(self, filename="savegame.json"):
self.last_saved = time.time()

# Создаем словарь для сериализации
save_data = {
"player_name": self.player_name,
"level": self.level,
"score": self.score,
"inventory": self.inventory,
"timestamp": self.last_saved
}

# Сохраняем в файл
with open(filename, "w") as f:
json.dump(save_data, f, indent=4)

print(f"Игра сохранена в {filename}")

@classmethod
def load(cls, filename="savegame.json"):
try:
with open(filename, "r") as f:
save_data = json.load(f)

# Создаем экземпляр класса из загруженных данных
game = cls(
player_name=save_data["player_name"],
level=save_data["level"],
score=save_data["score"],
inventory=save_data["inventory"]
)
game.last_saved = save_data["timestamp"]

print(f"Игра загружена: {game.player_name}, уровень {game.level}")
return game
except FileNotFoundError:
print(f"Файл сохранения {filename} не найден")
return None
except json.JSONDecodeError:
print(f"Ошибка чтения файла сохранения {filename}")
return None

# Пример использования
def play_game():
# Пытаемся загрузить сохраненную игру
game = GameState.load()

# Если сохранения нет, создаем новую игру
if game is None:
player_name = input("Введите имя игрока: ")
game = GameState(player_name=player_name)
print(f"Новая игра создана для игрока {player_name}")

# Имитация игрового процесса
game.add_item("Меч")
game.level_up()
game.add_item("Щит")

# Сохраняем игру
game.save()

# Запуск игры
play_game()