Библиотека Python разработчика | Книги по питону
Погружение в CPython и архитектуру. Разбираем неочевидное поведение (GIL, Memory), Best Practices (SOLID, DDD) и тонкости Django/FastAPI. Решаем задачи с подвохом и оптимизируем алгоритмы. 🐍 По всем вопросам @evgenycarter РКН clck.ru/3Ko7Hq
Mostrar más📈 Análisis del canal de Telegram Библиотека Python разработчика | Книги по питону
El canal Библиотека Python разработчика | Книги по питону (@bookpython) en el segmento lingüístico de Ruso es un actor destacado. Actualmente la comunidad reúne a 17 904 suscriptores, ocupando la posición 7 304 en la categoría Tecnologías y Aplicaciones y el puesto 36 554 en la región Rusia.
📊 Métricas de audiencia y dinámica
Desde su creación el невідомо, el proyecto ha mostrado un crecimiento acelerado, reuniendo a 17 904 suscriptores.
Según los últimos datos del 15 noviembre, 2026, el canal mantiene una actividad estable. En los últimos 30 días la variación de miembros fue de -116, y en las últimas 24 horas de -5, conservando un alto alcance.
- Estado de verificación: No verificado
- Tasa de interacción (ER): El promedio de interacción de la audiencia es 5.44%. Durante las primeras 24 horas tras publicar, el contenido suele obtener 2.71% de reacciones respecto al total de suscriptores.
- Alcance de las publicaciones: Cada publicación recibe en promedio 974 visualizaciones. En el primer día suele acumular 486 visualizaciones.
- Reacciones e interacción: La audiencia responde de forma activa: el promedio de reacciones por publicación es 3.
- Intereses temáticos: El contenido se centra en temas clave como numbers, yield, модуль, none, декоратор.
📝 Descripción y política de contenido
El autor describe el recurso como un espacio para expresar opiniones subjetivas:
“Погружение в CPython и архитектуру. Разбираем неочевидное поведение (GIL, Memory), Best Practices (SOLID, DDD) и тонкости Django/FastAPI. Решаем задачи с подвохом и оптимизируем алгоритмы. 🐍
По всем вопросам @evgenycarter
РКН clck.ru/3Ko7Hq”
Gracias a la alta frecuencia de actualizaciones (últimos datos recibidos el 16 noviembre, 2026), el canal mantiene la vigencia y un amplio alcance. La analítica demuestra que la audiencia interactúa activamente con el contenido, lo que lo convierte en un punto de referencia dentro de la categoría Tecnologías y Aplicaciones.
Cargando datos
| Fecha | Crecimiento de Suscriptores | Menciones | Canales | |
| 15 noviembre | 0 | |||
| 14 noviembre | 0 | |||
| 13 noviembre | 0 | |||
| 12 noviembre | 0 | |||
| 11 noviembre | +2 | |||
| 10 noviembre | 0 | |||
| 09 noviembre | 0 | |||
| 08 noviembre | 0 | |||
| 07 noviembre | 0 | |||
| 06 noviembre | 0 | |||
| 05 noviembre | +2 | |||
| 04 noviembre | 0 | |||
| 03 noviembre | 0 | |||
| 02 noviembre | +2 | |||
| 01 noviembre | 0 |
| 2 | В Python имя переменной может состоять из одного символа подчёркивания: _. Хотя такие имена обычно недостаточно описательны и их не стоит использовать, существует по крайней мере три случая, когда _ имеет общепринятое значение.
Во-первых, в интерактивных интерпретаторах Python _ используется для хранения результата последнего выполненного выражения:
>>> 2 + 2
4
>>> _
4
Во-вторых, в документации модуля gettext рекомендуется создавать псевдоним для функции gettext() в виде _(), чтобы не загромождать код.
В-третьих, _ используется, когда необходимо придумать имя для значения, которое не представляет интереса:
>>> log_entry = '10:50:24 14234 GET /api/v1/test'
>>> time, _, method, location = log_entry.split()
📲 Мы в MAX
👉@BookPython | 64 |
| 3 | Иногда возникает необходимость выполнить участок кода и проигнорировать все возможные исключения. Это оправдано в случае с плагинами, сторонними модулями и другими компонентами, устройство которых вам неизвестно или которым вы не доверяете.
Правильный способ сделать это — использовать конструкцию try с except Exception, а не голый except:
try:
foreign()
except Exception:
logging.warn('fail', exc_info=True)
Голый except эквивалентен except BaseException. А разница между BaseException и Exception в том, что BaseException включает исключения, которые, как правило, ловить не следует, например, KeyboardInterrupt.
📲 Мы в MAX
👉@BookPython | 607 |
| 4 | В Python оператор квадратных скобок [] можно переопределить, реализовав магический метод __getitem__. Это позволяет, например, создать объект, который виртуально содержит бесконечное количество повторяющихся элементов:
class Cycle:
def __init__(self, lst):
self._lst = lst
def __getitem__(self, index):
return self._lst[index % len(self._lst)]
print(Cycle(['a', 'b', 'c'])[100]) # 'b'
Необычность оператора [] в Python в том, что он поддерживает особый синтаксис. Его можно использовать не только так: [2], но и так: [2:10], [2:10:2], [2::2] или даже [:]. Смысл такой записи — [start:stop:step], но в ваших собственных объектах вы можете использовать этот синтаксис как угодно.
Что же передаётся в __getitem__ в таких случаях? Объекты slice созданы специально для этого.
Пример:
class Inspector:
def __getitem__(self, index):
print(index)
Inspector()[1]
# 1
Inspector()[1:2]
# slice(1, 2, None)
Inspector()[1:2:3]
# slice(1, 2, 3)
Inspector()[:]
# slice(None, None, None)
Inspector()[:, 0, :]
# (slice(None, None, None), 0, slice(None, None, None))
Объект slice сам по себе ничего не делает — он просто хранит атрибуты start, stop и step:
s = slice(1, 2, 3)
print(s.start) # 1
print(s.stop) # 2
print(s.step) # 3
📲 Мы в MAX
👉@BookPython | 658 |
| 5 | Существует два понятия с похожими названиями, которые легко перепутать: переопределение (overriding) и перегрузка (overloading).
Переопределение происходит, когда дочерний класс определяет метод, который уже был реализован в родительском классе, фактически заменяя его. В некоторых языках необходимо явно указывать, что метод переопределяется (например, в C# используется модификатор override), в других — это необязательно (в Java можно, но не обязательно использовать аннотацию @Override). В Python нет ни обязательного, ни стандартного способа обозначать такие методы (некоторые программисты применяют пользовательский декоратор @override, который ничего не делает, а служит только для читаемости кода).
Перегрузка, напротив, — это наличие нескольких функций с одним и тем же именем, но разными сигнатурами. Это поддерживается в таких языках, как Java и C++, и часто используется как способ предоставления значений по умолчанию:
class Foo {
public static void main(String[] args) {
System.out.println(Hello());
}
public static String Hello() {
return Hello("world");
}
public static String Hello(String name) {
return "Hello, " + name;
}
}
Python не поддерживает поиск функций по сигнатурам, только по именам. Вы можете написать код, который явно анализирует типы и количество аргументов, но это обычно выглядит громоздко и не очень красиво:
def quadrilateral_area(*args):
if len(args) == 4:
quadrilateral = Quadrilateral(*args)
elif len(args) == 1:
quadrilateral = args[0]
else:
raise TypeError()
return quadrilateral.area()
Если вам нужны подсказки типов для такой реализации, модуль typing предоставляет декоратор @overload, который можно использовать следующим образом:
from typing import overload
@overload
def quadrilateral_area(
q: Quadrilateral
) -> float: ...
@overload
def quadrilateral_area(
p1: Point, p2: Point,
p3: Point, p4: Point
) -> float: ...
📲 Мы в MAX
👉@BookPython | 739 |
| 6 | 🚀 Как логировать без боли в Python
Как настроить логирование в Python один раз — и больше к этому не возвращаться.
Обычно начинающие разработчики либо используют print(), либо подключают logging, но каждый раз пишут кучу однотипного кода. Я так тоже делал. Но потом вывел себе простую универсальную схему, которую теперь кидаю в каждый новый проект:
import logging
def setup_logger(name: str) -> logging.Logger:
logger = logging.getLogger(name)
if not logger.hasHandlers():
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s - %(levelname)s - %(name)s - %(message)s'
)
handler.setFormatter(formatter)
logger.addHandler(handler)
return logger
logger = setup_logger(__name__)
logger.info("Скрипт стартовал")
Что мы получаем:
* Удобный формат времени и уровня лога
* Защиту от дублирования логов (если модуль импортируется несколько раз)
* Готовность к масштабированию (можно легко добавить файл-логгер)
Если вы устали от print(), просто сохраните себе этот сниппет — он сэкономит вам время и нервы.
Пользуетесь ли вы встроенным logging, или предпочитаете что-то вроде loguru?
📲 Мы в MAX
👉@BookPython | 802 |
| 7 | 💡 Как избежать повторения кода с помощью functools.partial
Как упростить код и избежать дублирования с помощью functools.partial.
Допустим, у нас есть функция send_email(to, subject, body, is_html=False), и мы часто вызываем её с одним и тем же параметром is_html=True.
Вместо того чтобы каждый раз писать это явно, можно создать частичную функцию:
from functools import partial
send_html_email = partial(send_email, is_html=True)
# Теперь можно вызывать проще:
send_html_email("user@example.com", "Привет", "<b>Как дела?</b>")
Это удобно, если вы хотите предварительно зафиксировать часть аргументов, например:
* логгеры с предустановленным уровнем
* коннекторы с общими параметрами
* команды CLI с типовыми флагами
Таким образом, вы уменьшаете дублирование и делаете код читаемее. А ещё это красивый способ внедрить DI без фреймворков — просто передайте partial.
📲 Мы в MAX
👉@BookPython | 978 |
| 8 | Встроенные значения float в Python используют оборудование вашего компьютера напрямую, поэтому любое значение представляется внутренне в виде двоичной дроби.
Это означает, что вы обычно работаете с приближениями, а не с точными значениями:
>>> format(0.1, '.17f')
'0.10000000000000001'
Модуль decimal позволяет использовать десятичную арифметику с произвольной точностью:
>>> from decimal import Decimal
>>> Decimal(1) / Decimal(3)
Decimal('0.3333333333333333333333333333')
Но и этого может быть недостаточно:
>>> Decimal(1) / Decimal(3) * Decimal(3) == Decimal(1)
False
Для абсолютно точных вычислений можно использовать модуль fractions, который хранит любое число как рациональное:
>>> from fractions import Fraction
>>> Fraction(1) / Fraction(3) * Fraction(3) == Fraction(1)
True
Очевидное ограничение — всё равно приходится использовать приближения для иррациональных чисел, таких как π.
📲 Мы в MAX
👉@BookPython | 1 003 |
| 9 | Создание объекта в Python включает два ключевых этапа. Сначала вызывается метод __new__, который создаёт и возвращает новый объект. Затем вызывается метод __init__ для инициализации состояния этого объекта.
Однако, если __new__ возвращает объект, который не является экземпляром исходного класса, метод __init__ не будет вызван. Это связано с тем, что возвращаемый объект, вероятно, уже создан другим классом, и его __init__ уже был выполнен:
class Foo:
def __new__(cls, x):
return dict(x=x)
def __init__(self, x):
print(x) # Никогда не вызывается
print(Foo(0))
Важно: не следует создавать экземпляры того же класса в __new__ с использованием обычного конструктора (Foo(...)). Это может привести к двойному вызову __init__ или даже к бесконечной рекурсии.
Пример бесконечной рекурсии:
class Foo:
def __new__(cls, x):
return Foo(-x) # Рекурсия
Пример двойного вызова __init__:
class Foo:
def __new__(cls, x):
if x < 0:
return Foo(-x)
return super().__new__(cls)
def __init__(self, x):
print(x)
self._x = x
Правильный способ:
class Foo:
def __new__(cls, x):
if x < 0:
return cls.__new__(cls, -x)
return super().__new__(cls)
def __init__(self, x):
print(x)
self._x = x
📲 Мы в MAX
👉@BookPython | 1 015 |
| 10 | Как упростить работу с аргументами в командной строке с помощью typer
Раньше для CLI-приложений на Python я использовал argparse, потом был click, но недавно полностью перешёл на typer. Это библиотека от автора FastAPI, и она реально 🔥
Вот простой пример:
import typer
app = typer.Typer()
@app.command()
def hello(name: str, age: int = 18):
print(f"Привет, {name}! Тебе {age} лет.")
if __name__ == "__main__":
app()
Теперь можно запускать в терминале:
$ python main.py hello Alice --age 30
Привет, Alice! Тебе 30 лет.
Что круто:
- Автоматически генерируется --help
- Пишется почти как обычная функция
- Есть автокомплит в оболочках (bash/zsh)
- Поддержка аннотаций типов и валидации "из коробки"
Если ты всё ещё страдаешь с argparse, рекомендую попробовать typer. Особенно если ты уже кайфуешь от FastAPI — синтаксис и подход очень похожи.
📲 Мы в MAX
👉@BookPython | 1 042 |
| 11 | Популярный способ объявить абстрактный метод в Python — это выбросить исключение NotImplementedError:
def human_name(self):
raise NotImplementedError
Хотя этот подход довольно распространён и даже поддерживается IDE (например, PyCharm считает такие методы абстрактными), у него есть недостаток: ошибка возникает только при вызове метода, а не при создании экземпляра класса.
Чтобы избежать этой проблемы, используйте модуль abc:
from abc import ABCMeta, abstractmethod
class Service(metaclass=ABCMeta):
@abstractmethod
def human_name(self):
pass
Также важно помнить, что NotImplemented — это не то же самое, что NotImplementedError. NotImplemented — это специальное значение (как True и False), а не исключение. Оно используется, например, в специальных методах (__eq__(), __add__() и др.), чтобы сообщить Python, что операция не реализована для данного типа, и попытаться вызвать альтернативный метод (например, если a.__add__(b) возвращает NotImplemented, Python попробует вызвать b.__radd__(a)).
📲 Мы в MAX
👉@BookPython | 1 064 |
| 12 | Некоторый код может выводить интересующие вас данные в stdout, вместо того чтобы предоставлять API, возвращающий строку, пригодную для использования в программе.
Вместо рефакторинга такого кода можно воспользоваться менеджером контекста contextlib.redirect_stdout, который позволяет временно перенаправить stdout в любой объект, поддерживающий файловый интерфейс. В сочетании с io.StringIO это позволяет сохранить вывод в переменную.
from contextlib import redirect_stdout
from io import StringIO
s = StringIO()
with redirect_stdout(s):
print(42)
print(s.getvalue())
Также существует contextlib.redirect_stderr для перенаправления вывода sys.stderr.
📲 Мы в MAX
👉@BookPython | 981 |
| 13 | Иногда в программе нужна очередь — контейнер, куда элементы добавляются с одной стороны и извлекаются с другой. В Python для этого можно использовать list:
In : lst = [1, 2, 3]
In : lst.pop()
Out: 3
In : lst
Out: [1, 2]
In : lst[:0] = [4] # push
In : lst
Out: [4, 1, 2]
Однако list выглядит не очень удобно (взгляните на этот "push") и работает неэффективно.
In : lst = [0] * 10_000_000
In : %timeit lst[:0] = [1]
9.5 ms ± 111 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
In : %timeit lst.pop()
84.3 ns ± 4.01 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
Как видно, операция pop() в 100 раз быстрее, чем вставка в начало списка. Это связано с тем, как устроен list в Python: легко добавлять и удалять элементы с конца, но удаление/добавление в начало требует создания нового списка.
Для очередей лучше использовать collections.deque. Он специально для этого создан:
In : from collections import deque
In : d = deque([1] * 100_000_000)
In : %timeit d.popleft()
65 ns ± 0.436 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
📲 Мы в MAX
👉@BookPython | 931 |
| 14 | Скрытые фичи Enum: как выжать максимум
Многие используют Enum как простой список констант. Но у enum.Enum в Python есть куда больше возможностей — и они могут сделать код чище и мощнее.
Вот несколько приёмов, которые мало кто использует — но зря.
1. Добавление поведения в Enum
from enum import Enum
class Status(Enum):
DRAFT = 'draft'
PUBLISHED = 'published'
ARCHIVED = 'archived'
def is_visible(self):
return self in {Status.DRAFT, Status.PUBLISHED}
Теперь Status.DRAFT.is_visible() — это просто и элегантно.
2. Enum с полями
from enum import Enum
class Color(Enum):
RED = ('#FF0000', 'danger')
GREEN = ('#00FF00', 'safe')
def __init__(self, hex_code, label):
self.hex_code = hex_code
self.label = label
Color.RED.hex_code # '#FF0000'
Color.RED.label # 'danger'
3. Автоматические значения с auto()
from enum import Enum, auto
class Role(Enum):
ADMIN = auto()
USER = auto()
GUEST = auto()
Удобно, если не важны конкретные значения, а нужны уникальные.
4. Строгая сериализация
В реальных приложениях (API, базы) лучше контролировать сериализацию enum'ов:
import json
class CustomEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, Enum):
return obj.value
return super().default(obj)
json.dumps(Status.PUBLISHED, cls=CustomEncoder) # "published"
5. Сравнение по значению
Status('draft') == Status.DRAFT # True
Status('draft') is Status.DRAFT # True (enum гарантирует singleton)
Итого: Enum — это не просто константы. Это лёгкий способ инкапсулировать поведение и данные, улучшить читаемость и сделать код устойчивее к ошибкам.
📲 Мы в MAX
👉@BookPython | 778 |
| 15 | default_factory в dataclass: мощнее, чем кажется
Многие используют dataclass как удобный способ задать структуру с полями. Но редко кто по-настоящему раскрывает силу default_factory. А зря — он спасает от багов и даёт гибкость.
Когда нужно задать значение по умолчанию для поля в dataclass, логично тянуться к default=. Но если это изменяемый тип (например, список или словарь) — вас поджидает ловушка.
from dataclasses import dataclass, field
@dataclass
class User:
name: str
tags: list[str] = [] # ⚠️ опасно!
Все экземпляры User будут делить один и тот же список. То есть:
a = User("Alice")
b = User("Bob")
a.tags.append("admin")
print(b.tags) # ['admin'] 😱
Вместо этого используйте default_factory:
@dataclass
class User:
name: str
tags: list[str] = field(default_factory=list)
Теперь у каждого User будет свой список:
a = User("Alice")
b = User("Bob")
a.tags.append("admin")
print(b.tags) # []
Но default_factory не только про списки. Это отличный способ задать любое значение "по умолчанию", включая кастомную логику:
import uuid
@dataclass
class Session:
id: str = field(default_factory=lambda: str(uuid.uuid4()))
Или, например, значения из окружения:
import os
@dataclass
class Config:
debug: bool = field(default_factory=lambda: os.getenv("DEBUG") == "1")
Кстати, это ещё и отличное место для внедрения DI:
@dataclass
class Service:
client: "Client" = field(default_factory=create_default_client)
default_factory — это маленький хак, который позволяет сделать код чище и безопаснее, особенно когда работаешь с изменяемыми структурами или сложной инициализацией.
📲 Мы в MAX
👉@BookPython | 944 |
| 16 | yield from — элегантная передача управления
Если вы пишете генераторы, которые вызывают другие генераторы — забудьте про for x in sub(): yield x. Есть способ проще и мощнее.
Оператор yield from позволяет передавать элементы из подгенератора напрямую, без лишнего кода. Но фишка не только в лаконичности — он также автоматически пробрасывает исключения и возвращаемые значения из подгенератора.
Вот классика:
def gen():
for x in range(3):
yield x
def wrapper():
for x in gen():
yield x
Можно короче и лучше:
def wrapper():
yield from gen()
Но главное — yield from пробрасывает return-значение из подгенератора (начиная с Python 3.3):
def sub():
yield 1
yield 2
return 'done'
def main():
result = yield from sub()
print('Sub returned:', result)
for _ in main():
pass
# Выведет: Sub returned: done
А ещё через yield from можно проксировать значения внутрь генератора — например, в сопрограммах:
def delegator():
result = yield from coroutine()
print('coroutine done:', result)
def coroutine():
x = yield
y = yield
return x + y
g = delegator()
next(g) # Старт
next(g) # coroutine ждет x
g.send(10) # x = 10
print(g.send(20)) # y = 20 → return 30
# Выведет: coroutine done: 30
Итог: если вы пишете генераторы — освоение yield from даст вам лаконичный синтаксис, проброс return-значений, исключений и взаимодействие на новом уровне.
📲 Мы в MAX
👉@BookPython | 901 |
| 17 | Когда вы используете модуль multiprocessing, и в одном из процессов происходит исключение, оно передаётся в основную программу с помощью механизма сериализации (pickling). Исключение сериализуется, передаётся в другой процесс и там десериализуется обратно.
Однако сериализация исключений может быть непростой задачей. Исключение создаётся с любым количеством аргументов, которые сохраняются в атрибуте args. Эти же аргументы используются при десериализации для воссоздания объекта исключения.
Но это может не сработать так, как вы ожидаете, особенно если используется наследование. Посмотрите на пример:
import pickle
class TooMuchWeightError(Exception):
def __init__(self, weight):
super().__init__()
self._weight = weight
pickled = pickle.dumps(TooMuchWeightError(42))
pickle.loads(pickled)
Вызов TooMuchWeightError.__init__ приводит к вызову Exception.__init__, который устанавливает args как пустой кортеж. Этот пустой кортеж затем используется в качестве аргументов при десериализации, что, очевидно, приводит к ошибке:
TypeError: __init__() missing 1 required positional argument: 'weight'
Обходное решение — либо вообще не вызывать super().__init__() (что обычно считается плохой практикой при наследовании), либо передавать все аргументы явно в конструктор родительского класса:
class TooMuchWeightError(Exception):
def __init__(self, weight):
super().__init__(weight)
self._weight = weight
📲 Мы в MAX
👉@BookPython | 1 000 |
| 18 | Функция map вызывает другую функцию для каждого элемента итерируемого объекта. Это значит, что функция должна принимать одно значение в качестве аргумента:
In : list(map(lambda x: x ** 2, [1, 2, 3]))
Out: [1, 4, 9]
Однако если каждый элемент итерируемого объекта — это кортеж, было бы удобно передавать каждый элемент кортежа как отдельный аргумент. В Python 2 это было возможно благодаря распаковке параметров кортежа (обратите внимание на скобки):
>>> map(lambda (a, b): a + b, [(1, 2), (3, 4)])
[3, 7]
В Python 3 эта возможность исчезла, но есть другое решение — itertools.starmap. Она распаковывает кортежи за вас, будто функция вызывается со звёздочкой: f(*arg) (отсюда и название функции):
from itertools import starmap
In [3]: list(starmap(lambda a, b: a + b, [(1, 2), (3, 4)]))
Out[3]: [3, 7]
📲 Мы в MAX
👉@BookPython | 1 034 |
| 19 | Функция super() позволяет обращаться к родительскому (базовому) классу. Это может быть очень полезно в случаях, когда производный класс хочет добавить что-то к реализации метода, а не полностью переопределять его:
class BaseTestCase(TestCase):
def setUp(self):
self._db = create_db()
class UserTestCase(BaseTestCase):
def setUp(self):
super().setUp()
self._user = create_user()
Имя функции super не означает "отличный" или "очень хороший". В данном контексте слово super означает "выше" (как, например, в слове superintendent — заведующий). Несмотря на это, super() не всегда ссылается на базовый класс — он может вернуть и "соседний" класс. Более точным названием была бы, возможно, функция next(), так как возвращается следующий класс согласно цепочке разрешения методов (MRO — Method Resolution Order).
Пример:
class Top:
def foo(self):
return 'top'
class Left(Top):
def foo(self):
return super().foo()
class Right(Top):
def foo(self):
return 'right'
class Bottom(Left, Right):
pass
# выводит 'right'
print(Bottom().foo())
Обрати внимание: результат работы super() может отличаться в зависимости от MRO вызвавшего объекта.
>>> Bottom().foo()
'right'
>>> Left().foo()
'top'
📲 Мы в MAX
👉@BookPython | 1 232 |
| 20 | Стандартный механизм расширения путей в оболочке называется globbing. Шаблоны, которые вы используете для сопоставления путей, называются globs.
$ echo /li*
/lib /lib64
Python поддерживает globbing с помощью модуля glob. Однако есть важное замечание: оболочка возвращает сам шаблон, если файлы не найдены, а Python — нет:
$ echo /zz**
/zz**
$ python -c 'from glob import glob; print(glob("/zz**"))'
[]
📲 Мы в MAX
👉@BookPython | 1 047 |
