argparse: зачем нужен и при чем здесь sys.argv[]?

При создании скриптов, которые запускаются из командной строки, часто возникает необходимость принимать аргументы. Чтобы эффективно разбирать и обрабатывать эти параметры, в стандартной библиотеке Python есть модуль argparse. В этом лонгриде мы покажем на примере, как его использовать, покажем взаимосвязь с sys.argv.


➡️ Какую роль играет sys.argv?

sys.argv — это список, содержащий аргументы командной строки, с которыми был запущен скрипт. Первый элемент списка sys.argv[0] — это имя самого скрипта.

Например, если вы вызовете скрипт так:

python script.py filename.txt -v

то выведется такой перечень:

import sys

print(sys.argv) # ['script.py', 'filename.txt', '-v']

Однако sys.argv — это просто список строк, и если работать с ним вручную, то придётся самостоятельно обрабатывать порядок, типы данных, проверять правильность и т.п., что может стать сложной задачей. Здесь на помощь приходит argparse. Он автоматизирует парсинг аргументов и предоставляет удобные способы проверки параметров CLI.


➡️ argparse: как с ним обращаться

argparse позволяет описать, какие параметры принимает ваш скрипт, какие из них обязательны, какие опциональны, какие могут быть флагами (включить / выключить). Он также автоматически генерирует справку и обрабатывает ошибки в вводе.

Часто бывает так, что скрипт требует передать обязательный параметр — имя файла. Это называется позиционным аргументом, так как его положение в командной строке имеет значение.

import argparse

# Создаём парсер
parser = argparse.ArgumentParser(description='Обработка файла.') # Создаем объект ArgumentParser;

# Добавляем позиционный аргумент 'filename'
parser.add_argument('filename', help='имя файла для обработки') # Добавляем описание каждого аргумента или опции

# Разбираем аргументы командной строки
args = parser.parse_args() # Разберём аргументы sys.argv

# Fргументы доступны как атрибуты: args.filename
print(f'Обрабатываем файл: {args.filename}')

Теперь, если запустить скрипт так:

python script.py example.txt

Программа выведет:

Обрабатываем файл: example.txt

Если попытаться запустить без аргумента:

python script.py

то argparse автоматически покажет сообщение об ошибке и краткую справку:

usage: script.py [-h] filename
script.py: error: the following arguments are required: filename

Документация
#основы
@zen_of_python
🙏 — Если спасибо за такой контент

Паттерн Mediator | Что это и зачем нужен

Mediator — паттерн проектирования, который вводит объект-посредник для координации взаимодействий между другими объектами. Вместо того, чтобы объекты напрямую вызывали методы друг друга и пытались «договариваться», они отправляют сообщения посреднику, а он решает, кто и как должен на них отреагировать. Классическая аналогия — диспетчерская в аэропорту: пилоты не связываются друг с другом напрямую, а говорят с диспетчером.

При прямой связи «каждый с каждым» количество зависимостей растёт как квадрат числа компонентов: изменения в одном классе часто заставляют править десятки других. Посредник помещает логику взаимодействия в одну точку:

class Mediator:
    """Интерфейс медиатора."""
    def notify(self, sender, event):
        raise NotImplementedError

class CourseMediator(Mediator):
    """Конкретный медиатор — координатор курсов и пользователей."""
    def __init__(self):
        self.users = []

    def register(self, user):
        self.users.append(user)
        user.mediator = self

    def notify(self, sender, course_name):
        # В простом варианте медиатор просто логирует сообщение
        print(f"[{sender}] выбрал курс: {course_name}")
        # Можно добавить дополнительную логику: фильтрация, отправка уведомлений и т.п.

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

    def send_course(self, course_name):
        if not self.mediator:
            raise RuntimeError("User не зарегистрирован у медиатора")
        self.mediator.notify(self, course_name)

    def __str__(self):
        return self.name


m = CourseMediator()
u1 = User("Майкл"); u2 = User("Оля")
m.register(u1); m.register(u2)
u1.send_course("DSA")
u2.send_course("Software Development")

User не знает про других пользователей. Вся координация — в CourseMediator. Такой подход облегчает изменение логики (например, добавить рассылку уведомлений другим пользователям) без модификации User. Медиатор снижает связанность (Coupling) между компонентами и упрощает поддержку.


Плюсы

1️⃣ Централизация логики взаимодействия (проще править и тестировать).
2️⃣ Снижение связности между компонентами.
3️⃣ Легче добавлять новые стратегии взаимодействия, не меняя классы коллег.

Минусы

1️⃣ Риск «божественного объекта» (God Object): медиатор может накопить слишком много логики и стать сложным.
2️⃣ Централизация порождает узкое место — медиатор становится более сложным и менее прозрачным.

#основы
@zen_of_python

Паттерн Flyweight | как экономить память и избегать дублирования кода

Flyweight («вес мухи») — один из структурных паттернов, предназначенный для оптимизации расходования памяти. Суть — разделять состояния объектов на:

➡️ Внутреннее (intrinsic): общие, неизменяемые компоненты, которые можно разделять между объектами;
➡️ Внешнее (extrinsic) — уникальные, изменяемые данные, передаваемые в объект лишь в контексте его использования.

Это позволяет хранить меньше объектов при одинаковом поведении. Стоит задуматься об этом паттерне, если требуется создать множество объектов с частично общими данными.

Пример
Представь, что у нас лес в игре из 100К деревьев. У каждого дерева есть:

— Внутреннее состояние: текстура, цвет листвы, форма кроны, высота модели. Это разделяемые каждым деревом в лесу свойства;
— Внешнее состояние: координаты на карте, текущее состояние (здорово/повалено). Такое уникально для каждого дерева.

Если бы мы для каждого дерева хранили копию текстуры и модели, мы бы потратили гигабайты памяти. Flyweight избавляет от проблемы:


Наивный вариант (без Flyweight)

class Tree:
    def __init__(self, texture, color, shape, x, y):
        self.texture = texture
        self.color = color
        self.shape = shape
        self.x = x
        self.y = y

    def draw(self):
        print(f"Drawing {self.color} {self.shape} at ({self.x}, {self.y})")
        

# создаём 100.000 деревьев, каждое хранит одинаковую текстуру и форму
forest = [
    Tree("oak_texture.png", "green", "oak", x, y)
    for x, y in zip(range(1000), range(1000))
]

Каждый объект Tree хранит одинаковые данные (oak_texture.png, "oak", "green"), хотя это лишнее.


С Flyweight

# Общие характеристики
class TreeType:
    def __init__(self, texture, color, shape):
        self.texture = texture
        self.color = color
        self.shape = shape

    def draw(self, x, y):
        # внешние данные передаются параметром
        print(f"Drawing {self.color} {self.shape} at ({x}, {y})")


# Фабрика для переиспользования типов деревьев
class TreeFactory:
    _tree_types = {}

    @classmethod
    def get_tree_type(cls, texture, color, shape):
        key = (texture, color, shape)
        if key not in cls._tree_types:
            cls._tree_types[key] = TreeType(texture, color, shape)
        return cls._tree_types[key]


# Контекст: хранит только уникальные данные (extrinsic)
class Tree:
    def __init__(self, x, y, tree_type):
        self.x = x
        self.y = y
        self.tree_type = tree_type

    def draw(self):
        self.tree_type.draw(self.x, self.y)


# создаём 100ю000 деревьев, но реально разных TreeType всего 2-3
forest = []
for i in range(100000):
    if i % 2 == 0:
        tree_type = TreeFactory.get_tree_type("oak_texture.png", "green", "oak")
    else:
        tree_type = TreeFactory.get_tree_type("pine_texture.png", "darkgreen", "pine")
    forest.append(Tree(i, i * 2, tree_type))

# Нарисуем первые пять
for tree in forest[:5]:
    tree.draw()

⚡️ У нас 100 000 объектов Tree, но всего 2 объекта `TreeType` (oak и pine). Экономия памяти огромная: вместо хранения 100.000 текстур хранится только 2.


Недостатки паттерна

— Усложнение структуры кода;
— Возможны сложности с сопровождением, особенно при неправильном управлении extrinsic;
— Повышен риск связности — общие объекты могут влиять на многие части системы .

#основы
@zen_of_python

Mixins | Что это и как использовать

В ООП миксины — это инструмент, который позволяет переиспользовать общую функциональность между несколькими, часто несвязанными типами данных. Это шаг в сторону гибкого модульного кода с минимальной связностью похожих объектов.

В отличие от других ЯП (Ruby, Dart и проч.), которые поддерживают этот паттерн явно через специализированный синтаксис, Python полагается на множественное наследование как на механизм для реализации этой концепции.

Представьте, что вы создаете классы Animal и Vehicle с различными форматами данных. Реализация одной и той же функции serialize() приводит к дублированию кода:

# Плохо: Дублирование кода
class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species
    
    def serialize(self) -> dict:
        return vars(self)

class Vehicle:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
    
    def serialize(self) -> dict:  # Дублирование!
        return vars(self)

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def serialize(self) -> dict:  # Дублирование!
        return vars(self)

Решение через примеси:

# Миксин обычно предоставляет одну конкретную функцию
class SerializableMixin:
    def serialize(self) -> dict:
        if hasattr(self, "__slots__"):
            return {
                name: getattr(self, name)
                for name in self.__slots__
            }
        else:
            return vars(self)

# Классы используют mixin без странной иерархии
class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species

class Vehicle:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

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

# Применяем mixin к нужным классам
class SerializableAnimal(Animal, SerializableMixin):
    pass

class SerializableVehicle(Vehicle, SerializableMixin):
    pass

class SerializablePerson(Person, SerializableMixin):
    pass

Когда использовать Mixins

1️⃣ Когда нужно переиспользовать функциональность между несвязанными классами
2️⃣ Когда нужно создать модульный и композируемый код
3️⃣ Когда нужно расширить функциональность сторонних библиотек


Когда НЕ стоит использовать Mixins

1️⃣ Когда функциональность специфична для одного класса
2️⃣ Когда создается слишком сложная иерархия наследования

#основы
@zen_of_python
🤓 — Если изучил досконально

Requests для начинающих + пара фишек для адептов

requests является де-факто стандартом для HTTP-запросов в Python. Она упрощает взаимодействие с веб-сервисами, предоставляя интуитивно понятный интерфейс для отправки запросов и обработки ответов.

Инструмент не входит в стандартную библиотеку ЯП, поэтому его необходимо установить отдельно:

python -m pip install requests

Рекомендуется устанавливать внешние пакеты в виртуальное окружение, чтобы избежать конфликтов зависимостей.


Основные методы

Для получения данных с сервера используется метод GET:

import requests

response = requests.get('https://example.com')
print(response.text)

Для отправки данных на сервер используется метод POST:

import requests

data = {'key': 'value'}
response = requests.post('https://example.com', data=data)
print(response.text)

Ответы сервера

Статус-код запроса можно получить так:

print(response.status_code) # 200 — успешный запрос

Если ответ содержит JSON-данные, их можно преобразовать в Python-объект с помощью метода json():

data = response.json()

Параметры запроса (params)

Параметры запроса можно передавать в виде словаря в params:

params = {'q': 'python'}
response = requests.get('https://example.com/search', params=params)

Requests автоматически кодирует параметры и добавляет их к URL.



Заголовки (Headers)
Заголовки запроса можно передавать в виде словаря в параметре headers:

headers = {'User-Agent': 'my-app'}
response = requests.get('https://example.com', headers=headers)

Это полезно для указания типа контента, авторизации и других параметров.


Другие HTTP-методы

Requests поддерживает все основные HTTP-методы:

🔘requests.put() — для обновления;
🔘requests.delete() — для удаления.
🔘requests.head() — для получения только заголовков ответа;
🔘requests.options() — для получения поддерживаемых сервером методов.


Подготовка запроса

Requests позволяет подготовить запрос:

from requests import Request, Session

req = Request('GET', 'https://example.com', params={'q': 'python'})
prepared = req.prepare()

with Session() as session:
    response = session.send(prepared)
    print(response.text)

Это полезно, если необходимо многократно отправлять одинаковые запросы с разными параметрами.


Аутентификация

Requests поддерживает базовую аутентификацию с помощью параметра auth:

from requests.auth import HTTPBasicAuth

response = requests.get('https://example.com', auth=HTTPBasicAuth('user', 'pass'))

Также поддерживаются другие методы аутентификации, такие как OAuth.


Безопасность

Requests по умолчанию проверяет SSL-сертификаты при работе с HTTPS. Если необходимо отключить проверку (не рекомендуется в производственной среде), можно использовать параметр verify:

response = requests.get('https://example.com', verify=False)

Повторные попытки и сессии

Для улучшения производительности и управления соединениями рекомендуется использовать сессии:

with requests.Session() as session:
    response = session.get('https://example.com')
    print(response.text)

Сессии позволяют повторно использовать соединения и сохранять параметры между запросами. Для автоматических повторных попыток в случае неудачи можно использовать библиотеку urllib3 вместе с Requests.

#основы
@zen_of_python

Функции vs. метод в Python: разница

Тем, кто в языке первый год, разница между этими объектами может показаться неочевидной, для них и написан этот лонгрид.


Что такое функция?

Это блок кода, который принимает входные данные (аргументы), обрабатывает их и возвращает результат. Выделяют два типа:

1️⃣ без побочных эффектов — это чисто математические функции;
2️⃣ с побочными эффектами — функции, которые взаимодействуют с чем-то вне себя, например, с файлом, списком, базой данных или терминалом.

Пример чистой функции

def add(a, b):
    return a + b

print(add(2, 3))  # Всегда возвращает 5

Такая функция при одинаковых входных данных всегда возвращает один и тот же результат.

Пример функции с побочными эффектами:

import random

def random_point():
    x = random.randint(0, 10)
    y = random.randint(0, 10)
    return x, y

print(random_point())  # Каждый раз возвращает разные значения

Здесь функция использует внешний модуль random, и результат может меняться при каждом вызове. Это и есть побочный эффект.


Что такое метод?

Это та же функция, которая принадлежит объекту класса. Пока определение запутывает, но посмотрите пример ниже. Здесь set_name — это метод, используемый только для объектов Employee:

class Employee:
    def set_name(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

# Создаём объекты
emp1 = Employee()
emp2 = Employee()

# Используем метод
emp1.set_name("Alice", "Smith")
emp2.set_name("Bob", "Brown")

print(emp1.first_name, emp1.last_name)  # Alice Smith
print(emp2.first_name, emp2.last_name)  # Bob Brown

#основы
@zen_of_python

Про with

with позволяет обернуть выполнение блока кода в так называемый контекстный менеджер, который автоматически управляет ресурсами. Это особенно полезно для операций, требующих явного освобождения ресурсов, таких как работа с файлами, сетевыми соединениями или базами данных:

with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

В этом примере файл автоматически закроется после выхода из блока, даже если в процессе чтения произойдет исключение.


Как работает?

Оператор работает с объектами, реализующими протокол контекстного менеджера, то есть имеющими методы:

🔘__enter__(): выполняется при входе в блок with. Готовит ресурс и возвращает его;
🔘__exit__(): выполняется при выходе из блока. Отвечает за очистку ресурса, например, закрытие файла.


Примеры использования

Взаимодействие с базой данных:

import sqlite3

with sqlite3.connect('example.db') as conn:
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM users")
    print(cursor.fetchall())

Соединение с базой данных будет автоматически закрыто, даже если запрос вызовет исключение.


Зачем нужен with

🔘Гарантирует, что ресурсы будут освобождены после использования;
🔘Устраняет необходимость в явных блоках try / finally;
🔘Позволяет корректно обрабатывать исключения и освобождать ресурсы даже в случае ошибок;
🔘Повышение читаемости.

#основы
@zen_of_python

Этот код демонстрирует:
🔘 короткое замыкание (401 и 429 останавливают конвейер);
🔘 прохождение запроса дальше при None;
🔘 терминальный обработчик 404.


Политики прохождения запроса

🔘 Short-circuit (рекомендуется по умолчанию): первый, кто вернул результат, «закрывает» цепочку;
🔘 Fall-through: все обработчики обязаны отработать (например, аудит/метрики/логирование), результат — агрегация;
🔘 Микс: часть «жёстких» (аутентификация, лимиты) — short-circuit; «мягкие» (логирование) — всегда проходят.

#основы
@zen_of_python

Что такое линтер и что он делает

Линтер - это инструмент статического анализа кода, который проверяет ваш код на темы:
🔘 Синтаксис - правильно ли расставлены скобки, двоеточия;
🔘 Импорты - все ли импорты используются;
🔘 Переменные - все ли переменные определены;
🔘 Стиль - соответствие PEP 8;
🔘 Типы - если используется типизация.


Зачем запускать после изменений

⚡️ Обнаружение новых ошибок

# После добавления нового кода
def new_feature():
    unused_var = "not used"  # Линтер найдет неиспользуемую переменную
    return "feature"

⚡️ Проверка совместимости

# После изменения импортов
from new_module import new_function
# Линтер проверит, существует ли new_function

⚡️ Соблюдение стандартов

# После рефакторинга
class MyClass:
    def __init__(self):
        self.very_long_attribute_name_that_should_be_shorter = None
        # Линтер предложит сократить имя

⚡️ Проблемы безопасности

import subprocess
user_input = input("Enter command: ")
subprocess.run(user_input, shell=True)  # Линтер предупредит о SQL injection

⚡️ Неэффективный код

# Неэффективно
my_list = []
for i in range(1000):
    my_list.append(i)

# Линтер может предложить list comprehension
my_list = [i for i in range(1000)]

Настройка линтера
Обычно линтер настраивается через файлы конфигурации:

# pyproject.toml
[tool.ruff]
line-length = 88 # Максимальная длина строки
target-version = "py38" # Версия Python

Мы можем тонко настраивать, каким именно правилам следовать:

[tool.ruff.lint]
select = ["E", "F", "W", "C90", "I", "N", "UP", "YTT", "S", "BLE", "FBT", "B", "A", "COM", "C4", "DTZ", "T10", "EM", "EXE", "FA", "ISC", "ICN", "G", "INP", "PIE", "T20", "PYI", "PT", "Q", "RSE", "RET", "SLF", "SLOT", "SIM", "TID", "TCH", "INT", "ARG", "PTH", "TD", "FIX", "ERA", "PD", "PGH", "PL", "TRY", "FLY", "NPY", "AIR", "PERF", "FURB", "LOG", "RUF"]
ignore = ["E501", "S101", "PLR0913", "PLR0912", "PLR0915"]

Классические линтеры
🔘Pylint
🔘ruff
🔘Flake8
🔘mypy
🔘black

Пользователи Cursor, возможно, обратили внимание на завтозапуск линтера после практически каждого внесенного изменения. Эта IDE не отдает предпочтения какому-то конкретному инструменту, но запускает несколько из них.

Список правил ruff с детализацией в доках
#основы
@zen_of_python

Что значит стрелка ->

Если вы столкнулись со знаком -> в коде на Python и задумались, а не код из R ли это нужно ли это, как это работает и откуда оно взялось, этот лонгрид ответит на такие вопросы.

Стрелка в определении функции служит для аннотации типа возвращаемого значения. Она ставится после списка параметров и перед двоеточием:

def count_titles(titles: list[str]) -> int:
    return len(titles)

Здесь -> int говорит: «ожидается, что функция вернёт int». Аннотации опциональны и сами по себе ничего в рантайме не проверяют — это метаданные.


Краткая история оператора

Идея аннотаций функций впервые появилась в PEP 3107 (Function Annotations), который ввёл возможность добавлять произвольные метаданные к параметрам и к возвращаемому значению. На базе этой синтаксики PEP 484 затем ввёл систему типовых подсказок (type hints) для Python, сделав их стандартной практикой для тех, кто хочет статической проверки типов. Все эти дополнения остались опциональными — сам интерпретатор не будет выбрасывать ошибки, если аннотации не совпадают с фактическим типом во время выполнения.

Простой пример:

import random

def get_game_recommendation(titles: list[str]) -> str:
    return random.choice(titles)

games = ["Minecraft", "Cyberpunk 2077", "The Witcher 3", "Elden Ring"]
recommendation = get_game_recommendation(games)
print(f"Рекомендуемая игра: {recommendation}") # Например, Minecraft
print(f"Тип возвращаемого значения: {type(recommendation).__name__}") # str

Что происходит, если функция возвращает другой тип?

Python сам по себе не будет проверять, совпадает ли реальный возвращаемый тип с аннотацией — код просто выполнится. Но когда вы используете статический анализатор типов (например, mypy) или линтер, несоответствие будет обнаружено и выведет предупреждение / ошибку. Это ключевая идея: аннотации дают выгоду при статической проверке, CI и чтении кода, но не изменяют семантику программы во время выполнения.


Какие типы можно указывать после ->?

Почти любые:
🔘 простые встроенные (int, str, bool),
🔘 коллекции (list[str], dict[str, int]),
🔘 собственные классы и проч.


Где ещё применяются стрелки и аннотации?

Хотя наиболее часто -> встречается в объявлениях функций, аннотации — это часть более широкой системы типизации в Python. Типы используются для:

🔘 аннотаций параметров функций;
🔘 переменных и атрибутов классов (PEP 526);
🔘 аннотаций методов, Callable, Protocol и т.д.;
🔘 документации и автодополнения в IDE.

Инструменты типа mypy, pyright, IDE (PyCharm, VS Code) и линтеры используют аннотации, чтобы находить ошибки и улучшать подсказки.


Ограничения и подводные камни

🔘 Аннотации не выполняются: они не гарантия корректности в рантайме;
🔘 Сложные типы для сложной структуры данных или динамических конструкций типы могут стать громоздкими; иногда приходится балансировать читабельность и строгость;

#основы
@zen_of_python

Что такое JSON и зачем он нужен

JSON (JavaScript Object Notation) — текстовый формат для обмена данными, удобный для людей и машин. Он возник в экосистеме JavaScript, но стал язык-независимым стандартом для API, конфигураций и документных хранилищ. Формат простой: объекты (пар «ключ: значение») и массивы — это основные строительные блоки.

Почему Python-разработчику это важно:

🔘 JSON часто используется в web-API, логах, конфигурациях и при обмене данными между сервисами.
🔘 Python имеет встроенный модуль json, который делает сериализует (Python → JSON) и десериализует (JSON → Python).


Синтаксис JSON

🔘 Строки — в двойных кавычках ("...");
🔘 Логические значения — в нижнем регистре: true / false (в Python — True / False);
🔘 Отсутствующее значение — null (в Python → None);
🔘 Нельзя оставлять комментарии и нельзя ставить завершающие запятые после последнего элемента.

Валидный JSON:

{
  "name": "Frieda",
  "isDog": true,
  "hobbies": ["eating", "sleeping"],
  "age": 8,
  "address": {"home": ["Berlin", "Germany"], "work": null}
}

Модуль json

Главные функции одноименного модуля стандартной библиотеки:

🔘 json.dumps(obj, **opts) — сериализует Python-объект в строку JSON;
🔘 json.dump(obj, fp, **opts) — сериализует и записывает в файл-объект;
🔘 json.loads(s) — парсит JSON-строку в Python-объект;
🔘 json.load(fp) — считывает JSON из файла и парсит.

Эти функции следуют стандартному отображению типов: словари → объекты, списки → массивы, строки → строки, числа → числа, True / False → true / false, None → null.

import json

data = {"name": "Frieda", "age": 8, "is_dog": True}
s = json.dumps(data)        # --> '{"name": "Frieda", "age": 8, "is_dog": true}'
obj = json.loads(s)         # --> {'name': 'Frieda', 'age': 8, 'is_dog': True}

Полезные параметры dumps / dump

При сериализации полезны параметры:

🔘 indent — делает вывод читабельным (pretty print) (например, indent=2);
🔘 sort_keys=True — сортирует ключи объекта по алфавиту;
🔘 separators — позволяет контролировать символы между элементами (полезно для минификации);
🔘 ensure_ascii=False — по умолчанию json экранирует не-ASCII символы; если хотите сохранить UTF-8 в читаемом виде, ставьте False;
🔘 skipkeys=True — пропускает неподдерживаемые типы ключей вместо TypeError (использовать осторожно — вы можете потерять данные).


Маппинг типов

При загрузке JSON в Python выполняется обратное отображение типов:

* object → dict
* array → list
* string → str
* number → int / float
* true`/`false → True`/`False
* null → None

JSON-ключи — всегда строки. Если у вас в исходном Python-словаре были числовые ключи (например {1: "a"}`), при сериализации они станут строками (`"1"`). После `json.loads() вы получите ключи как строки — Python не "угадает" исходный тип. Это частая ловушка при конвертации словарей ключами-числами.


Полезные утилиты и приёмы

🔘 python -m json.tool — встроенная утилита для форматирования/проверки JSON в терминале (можно использовать для prettify/minify);
🔘 Онлайн-валидаторы (например, JSONLint) и редакторы с подсветкой помогут быстро найти синтаксические ошибки (комментарии, лишние запятые и т. п.).


Подборка примеров

Читаем JSON из файла:

import json

with open("data.json", "r", encoding="utf-8") as f:
    data = json.load(f)

Записываем с красивым форматированием:

with open("data_pretty.json", "w", encoding="utf-8") as f:
    json.dump(data, f, indent=2, sort_keys=True, ensure_ascii=False)

Сериализуем datetime:

from datetime import datetime
import json

def default(o):
    if isinstance(o, datetime):
        return o.isoformat()
    raise TypeError

json.dumps({"now": datetime.utcnow()}, default=default)

Проверяем валидность JSON в CLI

python -m json.tool input.json > /dev/null
# код возврата 0 — валидный JSON

#основы
@zen_of_python

Фабрики в Python

В программировании довольно часто встречается задача: в зависимости от входных данных нужно выбрать подходящий класс для обработки. Например, у нас есть XML-файлы и JSON-файлы, и мы хотим написать систему, которая будет их импортировать.

На первый взгляд решение простое — внутри метода проверять расширение файла и создавать соответствующий объект. Но у такого подхода есть несколько серьёзных недостатков. Именно здесь на помощь приходит паттерн «Фабрика».

Рассмотрим упрощённый пример кода:

class XMLImporter:
    def __init__(self, filename):
        self.filename = filename

    def execute(self):
        print("XML imported from", self.filename)


class JSONImporter:
    def __init__(self, filename):
        self.filename = filename

    def execute(self):
        print("JSON imported from", self.filename)


class Document:
    def import_file(self, filename):
        if filename.endswith(".xml"):
            importer = XMLImporter(filename)
        elif filename.endswith(".json"):
            importer = JSONImporter(filename)
        data = importer.execute()


document = Document()
document.import_file("text.xml")
document.import_file("text.json")

На первый взгляд код рабочий, но здесь нарушаются два принципа SOLID:

1️⃣ Принцип единственной ответственности (Single Responsibility Principle): класс Document отвечает сразу за создание объектов XMLImporter, JSONImporter и их использование.

2️⃣ Принцип открытости / закрытости (Open / Closed Principle).
Если появится новый формат (например, CSV), придётся снова лезть в метод import_file и расширять блок if / elif.


Решение: фабрика

Чтобы убрать ответственность за создание объектов из класса Document, вводится так называемася фабрика. Это объект, который берёт на себя ответственность за создание других объектов. Она не избавляет нас полностью от изменения кода при добавлении новых форматов, но значительно улучшает читаемость, гибкость и расширяемость системы.

class ImporterFactory:
    def get_importer(self, filename):
        if filename.endswith(".xml"):
            return XMLImporter(filename)
        elif filename.endswith(".json"):
            return JSONImporter(filename)

Теперь Document больше не знает, как именно создаются нужные классы. Ему просто передают готовую фабрику:

class Document:
    def __init__(self, factory):
        self.factory = factory

    def import_file(self, filename):
        importer = self.factory.get_importer(filename)
        data = importer.execute()


factory = ImporterFactory()
document = Document(factory)

document.import_file("text.xml")
document.import_file("text.json")

Преимущества фабрики

1️⃣ Изоляция ответственности: логика создания объектов теперь сосредоточена только в одном месте — в ImporterFactory.
2️⃣ Гибкость: если нужно добавить поддержку нового формата (CSV, YAML и т.д.), достаточно изменить фабрику, не трогая Document.
3️⃣ Удобное тестирование: в тестах можно подменить фабрику на «фиктивную» (mock) и проверять работу Document независимо от импортеров.


Что дальше?

Фабрика — это базовый паттерн. На его основе строятся более сложные подходы, например:

🔘 Factory Method — когда создание объектов делегируется подклассам.
🔘 Abstract Factory — когда фабрика создаёт целые семейства объектов, согласованных между собой.

#основы
@zen_of_python

Что такое замыкание и зачем оно нужно

Замыкания (Closures) — понятие, которое кажется сложным при первом знакомстве. Но на самом деле вы уже его скорее всего используете неосознанно, настолько это стало базой.

Представим программу, где пользователь вводит число, нажимает OK, и программа сохраняет это число в список, выводя все введённые значения:

numbers = []

def enter_number(x):
    numbers.append(x)
    print(numbers)

enter_number(3) # [3]
enter_number(7) # [3, 7]
enter_number(4) # v

Код работает, но есть проблема: переменная numbers находится вне функции, то есть она глобальная. Это значит, что:

🔘 функция зависит от переменной, объявленной в другом месте;
🔘 код становится менее гибким — нельзя просто перенести функцию в другой модуль, не взяв с собой numbers.

Замыкание помогает «связать» данные и логику в одном месте без использования классов:

def enter_number_outer():
    numbers = []  # локальная переменная

    def enter_number_inner(x):
        numbers.append(x)
        print(numbers)

    return enter_number_inner

Когда мы вызываем внешнюю функцию enter_number_outer(), она создаёт свой контекст с переменной numbers и возвращает внутреннюю функцию, которая имеет к ней доступ.

enter_num = enter_number_outer()
 
enter_num(3) # [3]
enter_num(7) # [3, 7]
enter_num(4) # [3, 7, 4]

Ключевая идея замыкания:

Внутренняя функция «замыкает» (сохраняет) значения переменных из области видимости внешней функции.

Даже когда enter_number_outer() завершает выполнение, её переменные не уничтожаются, потому что они нужны внутренней функции, которая всё ещё существует. Это и есть closure — функция, которая запоминает контекст, в котором была создана.


Используйте замыкания, если хотите:
🔘 инкапсулировать состояние в функции без создания класса;
🔘 нужно создать функцию-конфигуратор (например, с частично зафиксированными параметрами);

Замыкание — это функция, которая:
🔘 определена внутри другой функции;
🔘 использует переменные из внешней функции;
🔘 «запоминает» эти переменные даже после завершения внешней функции.

#основы
@zen_of_python