Python и JSON: руководство по эффективной обработке данных

import json

# JSON-строка
json_string = '{"name": "John", "age": 30, "city": "New York"}'

# Преобразование JSON в словарь Python
data = json.loads(json_string)

# Вывод данных
print(data["name"]) # John
print(data["age"]) # 30
print(type(data)) # <class 'dict'>

import json

# Словарь Python
person = {
"name": "Alice",
"age": 25,
"is_student": True,
"courses": ["Python", "Data Science", "Web Development"],
"address": None
}

# Преобразование словаря в JSON-строку
json_string = json.dumps(person)

print(json_string)
# {"name": "Alice", "age": 25, "is_student": true, "courses": ["Python", "Data Science", "Web Development"], "address": null}

# Форматированный JSON с отступами
formatted_json = json.dumps(person, indent=4, sort_keys=True)
print(formatted_json)
"""
{
"address": null,
"age": 25,
"courses": [
"Python",
"Data Science",
"Web Development"
],
"is_student": true,
"name": "Alice"
}
"""

# Запись в файл
with open('person.json', 'w') as file:
json.dump(person, file, indent=4)

# Чтение из файла
with open('person.json', 'r') as file:
loaded_data = json.load(file)
print(loaded_data) # Словарь Python

russian_data = {"имя": "Иван", "город": "Москва"}
json_string = json.dumps(russian_data, ensure_ascii=False)
print(json_string) # {"имя": "Иван", "город": "Москва"}

import json

# Различные типы данных Python
data = {
"string": "Hello, World!",
"integer": 42,
"float": 3.14,
"boolean": True,
"none_value": None,
"list": [1, 2, 3],
"nested_dict": {"key": "value"}
}

# Сериализация в JSON
json_string = json.dumps(data)
print(json_string)

# Десериализация обратно в Python
python_data = json.loads(json_string)
print(type(python_data)) # <class 'dict'>

import json
from datetime import datetime

data = {
"date": datetime.now(),
"set": {1, 2, 3},
"bytes": b"binary data"
}

# Вызовет ошибку
try:
json_string = json.dumps(data)
except TypeError as e:
print(f"Ошибка: {e}")

import json
from datetime import datetime

# Функция для преобразования нестандартных типов
def custom_serializer(obj):
if isinstance(obj, datetime):
return obj.isoformat()
elif isinstance(obj, set):
return list(obj)
elif isinstance(obj, bytes):
return obj.decode('utf-8')
# Для неизвестных типов вызываем исключение
raise TypeError(f"Object of type {type(obj)} is not JSON serializable")

data = {
"date": datetime.now(),
"set": {1, 2, 3},
"bytes": b"binary data"
}

# Используем пользовательский сериализатор
json_string = json.dumps(data, default=custom_serializer)
print(json_string)

import json
from datetime import datetime

# Функция для преобразования из JSON в сложные объекты Python
def custom_deserializer(obj):
if "date" in obj and isinstance(obj["date"], str):
try:
obj["date"] = datetime.fromisoformat(obj["date"])
except ValueError:
pass
return obj

# JSON с ISO-форматом даты
json_string = '{"date": "2023-10-15T14:30:00"}'

# Десериализация с пользовательским преобразованием
data = json.loads(json_string, object_hook=custom_deserializer)
print(type(data["date"])) # <class 'datetime.datetime'>
print(data["date"]) # 2023-10-15 14:30:00

import json

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

# Метод для преобразования объекта в словарь
def to_dict(self):
return {
"name": self.name,
"age": self.age
}

# Создание объекта
person = Person("John", 30)

# Сериализация с использованием метода to_dict
json_string = json.dumps(person.to_dict())
print(json_string) # {"name": "John", "age": 30}

# Более сложный вариант с функцией default
def serialize_person(obj):
if isinstance(obj, Person):
return obj.to_dict()
raise TypeError(f"Object {obj} is not serializable")

json_string = json.dumps(person, default=serialize_person)
print(json_string) # {"name": "John", "age": 30}

# Десериализация и создание объекта Person
def decode_person(obj):
if "name" in obj and "age" in obj:
return Person(obj["name"], obj["age"])
return obj

json_string = '{"name": "John", "age": 30}'
person_obj = json.loads(json_string, object_hook=decode_person)
print(type(person_obj)) # <class '__main__.Person'>
print(person_obj.name) # John

import json

# Сложный JSON с вложенными структурами
complex_json = '''
{
"company": {
"name": "Tech Innovations Ltd",
"founded": 2010,
"location": {
"city": "San Francisco",
"country": "USA",
"address": {
"street": "123 Tech Avenue",
"zipcode": "94107"
}
},
"employees": [
{
"id": 1,
"name": "John Smith",
"position": "CEO",
"skills": ["leadership", "strategy", "programming"],
"contact": {
"email": "john@techinnovations.com",
"phone": "+1-555-123-4567"
}
},
{
"id": 2,
"name": "Alice Johnson",
"position": "CTO",
"skills": ["architecture", "python", "cloud"],
"contact": {
"email": "alice@techinnovations.com",
"phone": "+1-555-987-6543"
}
}
],
"active": true
}
}
'''

# Парсинг JSON
data = json.loads(complex_json)

# Получение значений из вложенных структур
company_name = data["company"]["name"]
print(company_name) # Tech Innovations Ltd

address = data["company"]["location"]["address"]["street"]
print(address) # 123 Tech Avenue

# Доступ к элементу массива
first_employee_name = data["company"]["employees"][0]["name"]
print(first_employee_name) # John Smith

# Перебор всех сотрудников
for employee in data["company"]["employees"]:
print(f"{employee['name']} – {employee['position']}")
# Вывод: John Smith – CEO
# Alice Johnson – CTO

# Безопасный доступ к вложенным ключам
def get_nested(obj, path, default=None):
keys = path.split('.')
result = obj

try:
for key in keys:
if key.isdigit() and isinstance(result, list):
result = result[int(key)]
else:
result = result[key]
return result
except (KeyError, IndexError, TypeError):
return default

# Использование функции безопасного доступа
zipcode = get_nested(data, 'company.location.address.zipcode', 'N/A')
print(zipcode) # 94107

# Получение несуществующего ключа
fax = get_nested(data, 'company.contact.fax', 'Not available')
print(fax) # Not available

def find_key(obj, key):
"""Находит все значения для заданного ключа в JSON-структуре"""
results = []

def _search(current_obj, current_key):
if isinstance(current_obj, dict):
for k, v in current_obj.items():
if k == current_key:
results.append(v)
if isinstance(v, (dict, list)):
_search(v, current_key)
elif isinstance(current_obj, list):
for item in current_obj:
if isinstance(item, (dict, list)):
_search(item, current_key)

_search(obj, key)
return results

# Поиск всех email в структуре
emails = find_key(data, 'email')
print(emails) # ['john@techinnovations.com', 'alice@techinnovations.com']

# Поиск всех навыков
skills = find_key(data, 'skills')
print(skills) # [['leadership', 'strategy', 'programming'], ['architecture', 'python', 'cloud']]

import copy

# Глубокое копирование для безопасного изменения
data_copy = copy.deepcopy(data)

# Изменение вложенных данных
data_copy["company"]["location"]["country"] = "Canada"
data_copy["company"]["employees"][0]["position"] = "President"

# Добавление нового сотрудника
new_employee = {
"id": 3,
"name": "Bob Anderson",
"position": "CIO",
"skills": ["infrastructure", "security"],
"contact": {
"email": "bob@techinnovations.com"
}
}
data_copy["company"]["employees"].append(new_employee)

# Преобразование обратно в JSON
modified_json = json.dumps(data_copy, indent=2)
print(modified_json)

import json
import requests
from datetime import datetime

# Получение данных из API (пример)
def get_weather_data(city):
# В реальном проекте здесь будет реальный URL API с ключом
# Это демонстрационный пример
response = {
"location": {
"name": city,
"country": "Some Country"
},
"current": {
"temp_c": 22.5,
"condition": {
"text": "Sunny",
"code": 1000
},
"wind_kph": 15.1,
"humidity": 65
},
"forecast": {
"forecastday": [
{
"date": "2023-10-15",
"day": {
"maxtemp_c": 25.3,
"mintemp_c": 18.1,
"condition": {
"text": "Partly cloudy",
"code": 1003
}
}
},
{
"date": "2023-10-16",
"day": {
"maxtemp_c": 26.8,
"mintemp_c": 19.2,
"condition": {
"text": "Sunny",
"code": 1000
}
}
}
]
}
}
return response

# Анализ данных о погоде
def analyze_weather(data):
location = f"{data['location']['name']}, {data['location']['country']}"
current_temp = data['current']['temp_c']
condition = data['current']['condition']['text']

# Расчёт средних температур прогноза
forecast_temps = []
forecast_days = []

for day in data['forecast']['forecastday']:
date = datetime.strptime(day['date'], '%Y-%m-%d').strftime('%d %b')
max_temp = day['day']['maxtemp_c']
min_temp = day['day']['mintemp_c']
avg_temp = (max_temp + min_temp) / 2
forecast_temps.append(avg_temp)
forecast_days.append(date)

avg_forecast_temp = sum(forecast_temps) / len(forecast_temps)

return {
"location": location,
"current_temp": current_temp,
"condition": condition,
"forecast_days": forecast_days,
"forecast_temps": forecast_temps,
"avg_forecast_temp": avg_forecast_temp
}

# Получение и анализ данных
weather_data = get_weather_data("Berlin")
analysis = analyze_weather(weather_data)

print(f"Погода в {analysis['location']}: {analysis['current_temp']}°C, {analysis['condition']}")
print(f"Средняя прогнозируемая температура: {analysis['avg_forecast_temp']:.1f}°C")
for i, day in enumerate(analysis['forecast_days']):
print(f"{day}: {analysis['forecast_temps'][i]:.1f}°C")

import json
import os

class ConfigManager:
def __init__(self, config_path):
self.config_path = config_path
self.config = {}
self.load_config()

def load_config(self):
"""Загружает конфигурацию из файла"""
if os.path.exists(self.config_path):
try:
with open(self.config_path, 'r') as file:
self.config = json.load(file)
except json.JSONDecodeError:
print("Ошибка в формате JSON. Создаётся новый файл конфигурации.")
self.config = {}
else:
print("Файл конфигурации не найден. Создаётся новый файл.")
self.config = {}

def save_config(self):
"""Сохраняет конфигурацию в файл"""
with open(self.config_path, 'w') as file:
json.dump(self.config, file, indent=4)
print(f"Конфигурация сохранена в {self.config_path}")

def get(self, key, default=None):
"""Получает значение по ключу с поддержкой вложенных ключей через точку"""
keys = key.split('.')
result = self.config

try:
for k in keys:
result = result[k]
return result
except (KeyError, TypeError):
return default

def set(self, key, value):
"""Устанавливает значение по ключу с поддержкой вложенных ключей через точку"""
keys = key.split('.')
current = self.config

# Проходим по всем ключам кроме последнего
for k in keys[:-1]:
if k not in current or not isinstance(current[k], dict):
current[k] = {}
current = current[k]

# Устанавливаем значение для последнего ключа
current[keys[-1]] = value
self.save_config()

def delete(self, key):
"""Удаляет ключ из конфигурации"""
keys = key.split('.')
current = self.config

try:
# Проходим по всем ключам кроме последнего
for k in keys[:-1]:
current = current[k]

# Удаляем последний ключ
if keys[-1] in current:
del current[keys[-1]]
self.save_config()
return True
return False
except (KeyError, TypeError):
return False

# Пример использования
config = ConfigManager('app_config.json')

# Установка значений
config.set('app.name', 'My Awesome App')
config.set('app.version', '1.0.0')
config.set('database.host', 'localhost')
config.set('database.port', 5432)
config.set('database.credentials.username', 'admin')
config.set('database.credentials.password', 'secret123')

# Получение значений
app_name = config.get('app.name')
db_port = config.get('database.port')
db_user = config.get('database.credentials.username')

print(f"App: {app_name}, DB Port: {db_port}, DB User: {db_user}")

# Удаление значения
config.delete('database.credentials.password')

import json

# Пример данных пользователя из API 1
api1_user = {
"user_id": 12345,
"personal_info": {
"first_name": "John",
"last_name": "Doe",
"birth_date": "1990-05-15"
},
"contact": {
"email": "john.doe@example.com",
"phone": {
"home": "555-1234",
"mobile": "555-5678"
},
"address": {
"street": "123 Main St",
"city": "New York",
"state": "NY",
"zip": "10001"
}
},
"preferences": {
"newsletter": True,
"notifications": ["email", "sms"],
"theme": "dark"
}
}

# Функция для преобразования в формат API 2
def convert_user_to_api2_format(api1_data):
# Создаем структуру для API 2
api2_user = {
"id": api1_data["user_id"],
"name": {
"first": api1_data["personal_info"]["first_name"],
"last": api1_data["personal_info"]["last_name"],
"full": f"{api1_data['personal_info']['first_name']} {api1_data['personal_info']['last_name']}"
},
"birthDate": api1_data["personal_info"]["birth_date"],
"contactInfo": {
"emailAddress": api1_data["contact"]["email"],
"phoneNumbers": {
"primary": api1_data["contact"]["phone"]["mobile"],
"secondary": api1_data["contact"].get("phone", {}).get("home")
}
},
"location": {
"address": api1_data["contact"]["address"]["street"],
"city": api1_data["contact"]["address"]["city"],
"state": api1_data["contact"]["address"]["state"],
"postalCode": api1_data["contact"]["address"]["zip"]
},
"settings": {
"receiveNewsletter": api1_data["preferences"]["newsletter"],
"notificationChannels": api1_data["preferences"]["notifications"],
"userTheme": api1_data["preferences"]["theme"]
}
}
return api2_user

# Преобразование данных
api2_user = convert_user_to_api2_format(api1_user)

# Вывод преобразованных данных
print(json.dumps(api2_user, indent=2))

import asyncio
import aiohttp
import json

async def fetch_data(session, url):
async with session.get(url) as response:
return await response.json()

async def fetch_multiple_apis():
# Список URL для API запросов
urls = [
"https://jsonplaceholder.typicode.com/posts/1",
"https://jsonplaceholder.typicode.com/users/1",
"https://jsonplaceholder.typicode.com/comments?postId=1"
]

async with aiohttp.ClientSession() as session:
tasks = [fetch_data(session, url) for url in urls]
results = await asyncio.gather(*tasks)

# Обработка результатов
post_data = results[0]
user_data = results[1]
comments_data = results[2]

# Комбинирование данных
combined_data = {
"post": post_data,
"author": {
"id": user_data["id"],
"name": user_data["name"],
"email": user_data["email"]
},
"comments": comments_data
}

return combined_data

# Запуск асинхронного кода
# В реальном приложении используйте:
# combined_data = asyncio.run(fetch_multiple_apis())
# print(json.dumps(combined_data, indent=2))