Модуль pprint в Python: форматирование сложных структур данных

from pprint import pprint

data = {"users": [{"name": "Иван", "roles": ["admin", "developer"]},
{"name": "Мария", "roles": ["manager"]}],
"settings": {"debug": True, "environment": "production"}}

# Стандартный вывод
print("Стандартный вывод:")
print(data)

# Форматированный вывод
print("\nФорматированный вывод с pprint:")
pprint(data)

from pprint import PrettyPrinter

# Создание объекта PrettyPrinter с шириной 40 символов
pp = PrettyPrinter(width=40)
pp.pprint(data)

from pprint import pformat

# Получение отформатированной строки
formatted_data = pformat(data)
print("Длина отформатированного представления:", len(formatted_data))
print(formatted_data)

from pprint import isreadable

complex_data = {1: 1, 2: 2, 3: {4: 4}}
print(isreadable(complex_data)) # True

# Объект с функцией не может быть безопасно восстановлен
complex_data_with_function = {1: lambda x: x}
print(isreadable(complex_data_with_function)) # False

from pprint import isrecursive

# Создание рекурсивной структуры
recursive_dict = {1: 'a', 2: 'b'}
recursive_dict[3] = recursive_dict
print(isrecursive(recursive_dict)) # True

# Обычная структура
print(isrecursive({1: 'a', 2: 'b'})) # False

from pprint import pprint, PrettyPrinter

nested_data = {"results": [{"id": 1, "values": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]},
{"id": 2, "values": [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]}]}

# Стандартная ширина (80 символов)
print("Стандартная ширина:")
pprint(nested_data)

# Уменьшенная ширина (30 символов)
print("\nУменьшенная ширина:")
pp = PrettyPrinter(width=30)
pp.pprint(nested_data)

# Глубокая структура данных
deep_data = {"level1": {"level2": {"level3": {"level4": {"level5": "значение"}}}}}

# Вывод с ограниченной глубиной (2 уровня)
print("Ограниченная глубина:")
pprint(deep_data, depth=2)

# Полный вывод
print("\nПолный вывод:")
pprint(deep_data)

# Словарь с неупорядоченными ключами
unordered_dict = {"z": 1, "b": 2, "a": 3, "m": 4}

# Вывод с сортировкой ключей (по умолчанию True в Python 3.8+)
print("Сортировка ключей включена:")
pprint(unordered_dict, sort_dicts=True)

# Вывод без сортировки
print("\nСортировка ключей отключена:")
pprint(unordered_dict, sort_dicts=False)

# Список с несколькими элементами
data_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Стандартный вывод
print("Стандартный вывод:")
pprint(data_list)

# Компактный вывод
print("\nКомпактный вывод:")
pprint(data_list, compact=True)

# Вложенная структура
nested_structure = {"outer": {"inner1": 1, "inner2": 2}}

# Стандартный отступ (1 пробел)
print("Стандартный отступ:")
pprint(nested_structure)

# Увеличенный отступ (4 пробела)
print("\nУвеличенный отступ:")
pp = PrettyPrinter(indent=4)
pp.pprint(nested_structure)

# Только для Python 3.10+
# Словарь с длинными числами
large_numbers = {"large_int": 1000000000, "large_float": 1234567890.1234567}

# Вывод с подчеркиванием чисел
print("Вывод с подчеркиванием (Python 3.10+):")
# pprint(large_numbers, underscore_numbers=True)
print("1_000_000_000 (вид с подчеркиванием)")

# Создание рекурсивной структуры
recursive_list = [1, 2, 3]
recursive_list.append(recursive_list)

# Вывод с обработкой рекурсии
print("Обработка рекурсии:")
pprint(recursive_list)

import json
from pprint import pformat

# Преобразование JSON в Python-объект
json_string = '{"name": "Анна", "scores": [98, 95, 92], "active": true}'
data = json.loads(json_string)

# Форматирование с pprint и сохранение в переменную
formatted_data = pformat(data, width=40, sort_dicts=True)

# Использование в строках с форматированием
print(f"Данные пользователя:\n{formatted_data}\n")

# Создание документации с отформатированными данными
documentation = f"""
## Пример структуры данных

Поле `name` содержит имя пользователя.
Поле `scores` содержит список оценок.
"""

print(documentation)

from pprint import PrettyPrinter

class EnhancedPrinter(PrettyPrinter):
"""Расширенный класс для форматирования с дополнительными возможностями."""

def __init__(self, highlight_keys=None, **kwargs):
super().__init__(**kwargs)
self.highlight_keys = highlight_keys or []

def _format_dict_items(self, items, stream, indent, allowance, context, level):
# Переопределение метода форматирования элементов словаря
write = stream.write
indent += self._indent_per_level

for key, ent in items:
if key in self.highlight_keys:
write(' ' * indent)
write(f"!!! ") # Добавление выделения
self._format(key, stream, indent, allowance + 4, context, level)
write(': ')
self._format(ent, stream, indent + self._indent_per_level,
allowance + 1, context, level + 1)
write(',\n')
else:
write(' ' * indent)
self._format(key, stream, indent, allowance + 1, context, level)
write(': ')
self._format(ent, stream, indent + self._indent_per_level,
allowance + 1, context, level + 1)
write(',\n')

# Использование кастомного принтера
user_data = {
"name": "Иван Петров",
"email": "ivan@example.com",
"role": "administrator",
"permissions": ["read", "write", "execute"],
"settings": {
"theme": "dark",
"notifications": True
}
}

# Выделение важных полей
custom_printer = EnhancedPrinter(highlight_keys=["email", "role"], width=60, indent=2)
custom_printer.pprint(user_data)

import logging
from pprint import pformat

# Настройка логирования
logging.basicConfig(level=logging.DEBUG, 
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s')
logger = logging.getLogger('app')

# Функция для логирования сложных структур
def log_complex_data(data, message="Получены данные"):
logger.debug(f"{message}:\n{pformat(data, width=100, indent=2)}")

# Пример использования
complex_data = {
"users": [
{"id": 1, "name": "Алексей", "active": True},
{"id": 2, "name": "Елена", "active": False}
],
"stats": {
"active_count": 1,
"total_count": 2,
"last_login": "2023-05-15T14:32:20"
}
}

log_complex_data(complex_data, "Статистика пользователей")

from pprint import PrettyPrinter
from datetime import datetime, timedelta
import uuid

class CustomTypePrinter(PrettyPrinter):
def _repr(self, object, context, level):
# Специальное форматирование для datetime
if isinstance(object, datetime):
return f"DateTime({object.strftime('%Y-%m-%d %H:%M:%S')})"
# Специальное форматирование для UUID
elif isinstance(object, uuid.UUID):
return f"ID({str(object)[:8]}...)"
# Специальное форматирование для timedelta
elif isinstance(object, timedelta):
days = object.days
hours, remainder = divmod(object.seconds, 3600)
minutes, seconds = divmod(remainder, 60)
return f"Duration({days}d {hours}h {minutes}m {seconds}s)"
else:
return super()._repr(object, context, level)

# Пример данных с разными типами
mixed_data = {
"event_id": uuid.uuid4(),
"created_at": datetime.now(),
"updated_at": datetime.now() – timedelta(hours=2, minutes=30),
"duration": timedelta(days=1, hours=12, minutes=45),
"name": "Важное событие",
"participants": ["Пользователь1", "Пользователь2"],
"settings": {"public": True, "notify": False}
}

# Использование кастомного принтера
custom_printer = CustomTypePrinter(width=70, indent=2, depth=3)
custom_printer.pprint(mixed_data)

from pprint import pformat
import textwrap

def generate_report(data, title="Отчет", width=80):
"""Создает структурированный отчет из данных."""
border = "=" * width
header = f" {title} ".center(width, '=')

# Форматирование данных с помощью pprint
formatted_data = pformat(data, width=width-10, indent=2)

# Добавление отступов к каждой строке данных
indented_data = textwrap.indent(formatted_data, ' ')

# Создание отчета
report = f"\n{header}\n\n{indented_data}\n\n{border}\n"
return report

# Пример использования
performance_data = {
"application": "ServiceApp",
"period": "2023-Q2",
"metrics": {
"uptime": 99.98,
"response_time": {
"avg": 120.5, # ms
"p95": 230.7, # ms
"p99": 350.2 # ms
},
"errors": {
"5xx": 23,
"4xx": 145
}
},
"improvements": [
"Оптимизирована обработка запросов",
"Обновлены зависимости",
"Добавлен кэш для часто запрашиваемых данных"
]
}

# Генерация и печать отчета
print(generate_report(performance_data, "Отчет о производительности системы"))

import requests
from pprint import pprint

def fetch_and_debug_api(url):
"""Получает данные API и выводит их в структурированном виде."""
try:
response = requests.get(url)
response.raise_for_status() # Проверка на HTTP ошибки

# Используем pprint для отображения ответа
print(f"Статус ответа: {response.status_code}")
print("Заголовки:")
pprint(dict(response.headers), indent=2)

print("\nТело ответа:")
try:
# Попытка распарсить JSON
data = response.json()
pprint(data, width=100, indent=2)
except ValueError:
# Если не JSON, выводим как текст
print(response.text[:500] + "..." if len(response.text) > 500 else response.text)

except requests.exceptions.RequestException as e:
print(f"Ошибка при запросе: {e}")

# Пример использования
fetch_and_debug_api("https://jsonplaceholder.typicode.com/users/1")

import logging
from pprint import pformat
from functools import wraps

# Настройка логгера
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s'
)
logger = logging.getLogger('app')

def log_function_call(func):
"""Декоратор для логирования входных и выходных данных функции."""
@wraps(func)
def wrapper(*args, **kwargs):
# Логирование входных параметров
args_repr = pformat(args, indent=2)
kwargs_repr = pformat(kwargs, indent=2)
logger.debug(f"Вызов {func.__name__} с аргументами:\nargs: {args_repr}\nkwargs: {kwargs_repr}")

# Выполнение функции
result = func(*args, **kwargs)

# Логирование результата
result_repr = pformat(result, indent=2)
logger.debug(f"Результат {func.__name__}:\n{result_repr}")

return result
return wrapper

# Пример использования декоратора
@log_function_call
def process_user_data(user_id, **user_details):
# Имитация обработки данных пользователя
processed_data = {
"id": user_id,
"name": user_details.get("name", "Unknown"),
"processed": True,
"timestamp": "2023-06-15T12:34:56"
}
return processed_data

# Вызов функции
process_user_data(12345, name="Алексей", email="alexey@example.com")

from pprint import pformat

def generate_config_template(config_dict, output_file=None):
"""Генерирует шаблон конфигурационного файла на основе словаря."""
# Форматируем конфигурацию
formatted_config = pformat(config_dict, indent=4, width=90)

# Добавляем Python-код для создания файла конфигурации
template = f"""#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Автоматически сгенерированный файл конфигурации
# Отредактируйте значения в соответствии с вашими требованиями

CONFIG = {formatted_config}

if __name__ == "__main__":
print("Конфигурация загружена успешно!")
print(f"Найдено {{len(CONFIG)}} секций.")
"""

# Записываем в файл или возвращаем строку
if output_file:
with open(output_file, 'w', encoding='utf-8') as f:
f.write(template)
print(f"Файл конфигурации создан: {output_file}")

return template

# Пример конфигурации
default_config = {
"database": {
"host": "localhost",
"port": 5432,
"username": "admin",
"password": "change_me",
"pool_size": 5,
"timeout": 30
},
"logging": {
"level": "INFO",
"format": "%(asctime)s – %(name)s – %(levelname)s – %(message)s",
"file": "/var/log/app.log",
"rotate": True
},
"api": {
"base_url": "https://api.example.com",
"version": "v1",
"timeout": 10,
"retry_attempts": 3
}
}

# Генерируем шаблон
config_template = generate_config_template(default_config, "config_example.py")
print("Пример сгенерированного шаблона:")
print("-" * 80)
print(config_template[:500] + "..." if len(config_template) > 500 else config_template)

import difflib
from pprint import pformat

def compare_data_structures(old_data, new_data):
"""Сравнивает две структуры данных и показывает различия."""
# Форматируем обе структуры
old_formatted = pformat(old_data, width=70).splitlines()
new_formatted = pformat(new_data, width=70).splitlines()

# Создаем объект для сравнения
differ = difflib.Differ()
diff = list(differ.compare(old_formatted, new_formatted))

# Выводим результат
print("Сравнение структур данных:")
print("-" * 80)
for line in diff:
if line.startswith('+ '): # Добавленные строки
print(f"\033[92m{line}\033[0m") # Зеленый цвет
elif line.startswith('- '): # Удаленные строки
print(f"\033[91m{line}\033[0m") # Красный цвет
elif line.startswith('? '): # Метки изменений
continue # Пропускаем для краткости
else: # Неизмененные строки
print(line)

# Пример данных для сравнения
old_version = {
"name": "Product X",
"version": "1.0.3",
"features": ["search", "filter", "export"],
"settings": {
"theme": "light",
"notifications": True
}
}

new_version = {
"name": "Product X Pro",
"version": "1.1.0",
"features": ["search", "filter", "export", "analytics"],
"settings": {
"theme": "dark",
"notifications": True,
"advanced_mode": True
}
}

# Сравниваем версии
compare_data_structures(old_version, new_version)