Шаблоны проектирования на Python

Паттерны проектирования на Python: Паттерн Строитель
Паттерны проектирования на Python: Паттерн Фабричный метод
Паттерны проектирования на Python: Паттерн Прототип
SOLID принципы на Python: SRP - Принцип единственной ответственности
SOLID принципы на Python: OCP - Принцип открытости / закрытости
SOLID принципы на Python: LSP - Принцип подстановки Лисков
SOLID принципы на Python: ISP - Принцип разделения интерфейса
SOLID принципы на Python: DIP - Принцип инверсии зависимостей

Полный курс на youtube

👉@BookPython

❓Вы когда-нибудь хотели стать лучшей версией себя?
Применять SQLAlchemy эффективнее — быстрее, лучше, умнее!

23 декабря, 20:00 мск — открытый урок для Python-разработчиков.

📒Что делать, если методы, использующие SQLAlchemy и СУБД, тормозят? Когда оптимизация внутри SQLAlchemy — благо, а когда — беда? Как создать удобную панель администрирования поверх SQLAlchemy?

Спикер Дмитрий Панкрашов — ведущий разработчик в компании-партнере вендора СЭД «Директум».

🟢Регистрируйтесь прямо сейчас, чтобы не пропустить мероприятие: https://vk.cc/cGeHTz

Все участники открытого урока получат скидку на курс "Python Developer. Professional"

Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576

Как использовать *args и **kwargs в python?

В видео про декораторы мы использовали *args и **kwargs для того, чтобы передать в функцию любое количество позиционных и именованных аргументов. Для того, чтобы понять как это работает, сначала познакомимся с тем, что такое распаковка.

👉@BookPython

Распаковка параметров функций в Python 2 и 3

В Python 2 существовала интересная возможность распаковывать параметры функций прямо в их определении. Пример:

def between(x, (start, stop)):
    return start < x < stop

interval = (5, 10)
print(between(2, interval))  # False
print(between(7, interval))  # True

Более того, это работало даже рекурсивно:

def determinant_2_x_2(((a, b), (c, d))):
    return a * d - c * b

matrix = [
    (1, 2),
    (3, 4),
]
print(determinant_2_x_2(matrix))  # -2

Но начиная с Python 3, эта возможность была удалена из языка. Чтобы добиться того же результата, теперь нужно распаковывать параметры вручную:

def determinant_2_x_2(matrix):
    row1, row2 = matrix
    a, b = row1
    c, d = row2
    return a * d - c * b

matrix = [
    (1, 2),
    (3, 4),
]
print(determinant_2_x_2(matrix))  # -2

Удаление этой функциональности сделало код более явным и читаемым, но для любителей компактности Python 2 по-прежнему вызывает лёгкую ностальгию.

👉 @BookPython

Почему `range()` в Python использует полуоткрытые интервалы?

Функция range() в Python работает с полуоткрытыми интервалами. Например, range(2, 10) задаёт числа в диапазоне [2, 10), то есть [2, 3, 4, 5, 6, 7, 8, 9]. На первый взгляд это может показаться неочевидным или асимметричным, но у такого подхода есть свои преимущества.

Почему полуоткрытые интервалы?
Полуоткрытые интервалы позволяют легко "склеивать" смежные диапазоны без риска ошибок на единицу:

- Если a = 2, b = 5, и c = 10, то [a, c) можно выразить как:

  [a, c) = [a, b) + [b, c)
  

Это работает идеально, потому что конец одного интервала (`b`) автоматически становится началом следующего.

В случае закрытых интервалов, такая "склейка" требует дополнительной обработки:

[a, c] = [a, b] + [b+1, c]

Связь с индексацией с нуля
Индексация с нуля в Python также связана с этим принципом. Рассмотрим диапазон range(0, N):
- Этот диапазон включает ровно N элементов, что делает код более предсказуемым:

  for i in range(0, N):
      print(i)
  

Здесь i проходит значения от 0 до N-1, что логично и удобно.

Преимущества для работы с массивами
Полуоткрытые интервалы идеально подходят для работы с индексами массивов:

arr = [10, 20, 30, 40, 50]
print(arr[1:3])  # [20, 30]

Интервал [1:3) охватывает элементы с индексами 1 и 2, но не 3, что упрощает вычисления границ.

Исторический контекст
Этот подход имеет глубокие корни в компьютерной науке. Эдсгер Дейкстра, один из пионеров программирования, в 1982 году написал блестящую статью, в которой обосновал преимущества полуоткрытых интервалов. Это не просто удобство — это вопрос корректности и простоты работы с данными.

👉 @BookPython

Как узнать размер генератора в Python?

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

Пример с len()
Некоторые итераторы, такие как range, поддерживают вызов len():

len(range(10000))  # 10000

Однако генераторы не имеют длины, и попытка вызвать len() вызовет ошибку:

gen = (x ** 2 for x in range(10000))
len(gen)  # TypeError: object of type 'generator' has no len()

Стандартное решение: преобразование в список
Один из способов получить размер генератора — это преобразовать его в список:

gen = (x ** 2 for x in range(10000))
print(len(list(gen)))  # 10000

Этот подход работает, но имеет серьёзный недостаток: он требует загрузить все значения генератора в память. Если генератор очень большой, это может привести к нехватке памяти.

Более эффективный подход: подсчёт с помощью sum
Чтобы избежать лишнего расхода памяти, можно подсчитать количество элементов в генераторе с использованием sum():

gen = (x ** 2 for x in range(10000))
print(sum(1 for _ in gen))  # 10000

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

Резюме
- Используйте len() только для итераторов, поддерживающих его (например, `range`).
- Для генераторов избегайте преобразования в список, если важна экономия памяти.
- Используйте sum(1 for _ in gen) для эффективного подсчёта элементов генератора.

👉 @BookPython

Когда вам нужно очистить список в Python, вы, скорее всего, используете lst = []. Однако на самом деле вы просто создаёте новый пустой список и присваиваете его переменной lst, а все другие переменные, которые ссылаются на исходный список, продолжают хранить его содержимое.

Пример:

lst = [1, 2, 3]
lst2 = lst
lst = []
print(lst2)  # [1, 2, 3]

Хотя это кажется очевидным, правильное решение стало доступно только с введением метода lst.clear() в Python 3.3.

До этого для очистки списка приходилось использовать:
- del lst[:], или
- lst[:] = [].

Оба варианта работают, поскольку срезы позволяют модифицировать часть списка. Если вы берёте срез [:], он охватывает весь список.

Теперь же lst.clear() является более читаемым и современным решением.

👉 @BookPython

Подборка Telegram каналов для программистов

Системное администрирование 📌
https://t.me/sysadmin_girl Девочка Сисадмин
https://t.me/srv_admin_linux Админские угодья
https://t.me/linux_srv Типичный Сисадмин

https://t.me/linux_odmin Linux: Системный администратор
https://t.me/devops_star DevOps Star (Звезда Девопса)
https://t.me/i_linux Системный администратор
https://t.me/linuxchmod Linux
https://t.me/sys_adminos Системный Администратор
https://t.me/tipsysdmin Типичный Сисадмин (фото железа, было/стало)
https://t.me/sysadminof Книги для админов, полезные материалы
https://t.me/i_odmin Все для системного администратора
https://t.me/i_odmin_book Библиотека Системного Администратора
https://t.me/i_odmin_chat Чат системных администраторов
https://t.me/i_DevOps DevOps: Пишем о Docker, Kubernetes и др.
https://t.me/sysadminoff Новости Линукс Linux

1C разработка 📌
https://t.me/odin1C_rus Cтатьи, курсы, советы, шаблоны кода 1С

Программирование C++📌
https://t.me/cpp_lib Библиотека C/C++ разработчика
https://t.me/cpp_knigi Книги для программистов C/C++
https://t.me/cpp_geek Учим C/C++ на примерах

Программирование Python 📌
https://t.me/pythonofff Python академия. Учи Python быстро и легко🐍
https://t.me/BookPython Библиотека Python разработчика
https://t.me/python_real Python подборки на русском и английском
https://t.me/python_360 Книги по Python Rus

Java разработка 📌
https://t.me/BookJava Библиотека Java разработчика
https://t.me/java_360 Книги по Java Rus
https://t.me/java_geek Учим Java на примерах

GitHub Сообщество 📌
https://t.me/Githublib Интересное из GitHub

Базы данных (Data Base) 📌
https://t.me/database_info Все про базы данных

Мобильная разработка: iOS, Android 📌
https://t.me/developer_mobila Мобильная разработка
https://t.me/kotlin_lib Подборки полезного материала по Kotlin

Фронтенд разработка 📌
https://t.me/frontend_1 Подборки для frontend разработчиков
https://t.me/frontend_sovet Frontend советы, примеры и практика!
https://t.me/React_lib Подборки по React js и все что с ним связано

Разработка игр 📌
https://t.me/game_devv Все о разработке игр

Библиотеки 📌
https://t.me/book_for_dev Книги для программистов Rus
https://t.me/programmist_of Книги по программированию
https://t.me/proglb Библиотека программиста
https://t.me/bfbook Книги для программистов
https://t.me/books_reserv Книги для программистов

БигДата, машинное обучение 📌
https://t.me/bigdata_1 Data Science, Big Data, Machine Learning, Deep Learning

Программирование 📌
https://t.me/bookflow Лекции, видеоуроки, доклады с IT конференций
https://t.me/coddy_academy Полезные советы по программированию
https://t.me/rust_lib Полезный контент по программированию на Rust
https://t.me/golang_lib Библиотека Go (Golang) разработчика
https://t.me/itmozg Программисты, дизайнеры, новости из мира IT
https://t.me/php_lib Библиотека PHP программиста 👨🏼‍💻👩‍💻
https://t.me/nodejs_lib Подборки по Node js и все что с ним связано
https://t.me/ruby_lib Библиотека Ruby программиста

QA, тестирование 📌
https://t.me/testlab_qa Библиотека тестировщика

Шутки программистов 📌
https://t.me/itumor Шутки программистов

Защита, взлом, безопасность 📌
https://t.me/thehaking Канал о кибербезопасности
https://t.me/xakep_1 Статьи из "Хакера"

Книги, статьи для дизайнеров 📌
https://t.me/ux_web Статьи, книги для дизайнеров

Английский 📌
https://t.me/UchuEnglish Английский с нуля

Математика 📌
https://t.me/Pomatematike Канал по математике
https://t.me/phis_mat Обучающие видео, книги по Физике и Математике

Excel лайфхак📌
https://t.me/Excel_lifehack

https://t.me/tikon_1 Новости высоких технологий, науки и техники💡
https://t.me/mir_teh Мир технологий (Technology World)

Вакансии 📌
https://t.me/sysadmin_rabota Системный Администратор
https://t.me/progjob Вакансии в IT

Если вы пишете много Python-кода, наверняка сталкивались с типичной задачей: определение класса с простым конструктором и базовыми методами вроде __repr__. Например:

class Server:
    def __init__(self, ip, version=4):
        self.ip = ip
        self._version = version

    def __repr__(self):
        return '{klass}("{ip}", {version})'.format(
            klass=type(self).__name__,
            ip=self.ip,
            version=self._version,
        )

Это выглядит однообразно, но легко автоматизируется. Популярный пакет attrs позволяет избавиться от такого шаблонного кода:

from attrs import define, field

@define
class Server:
    ip = field()
    _version = field(default=4)

server = Server(ip='192.168.0.0.1', version=4)

Пакет attrs генерирует конструктор, метод __repr__, а также методы сравнения (__eq__, __lt__, и т.д.) — всё это минимальными усилиями.

Однако с появлением Python 3.7 разработчики получили встроенное решение для этой задачи — data classes. Это стандартный инструмент, который использует аннотации типов для автоматического создания тех же самых методов:

from dataclasses import dataclass

@dataclass
class InventoryItem:
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost(self) -> float:
        return self.unit_price * self.quantity_on_hand

Почему стоит обратить внимание на data classes:
1. Чистый код: Конструкция читается просто и выглядит лаконично.
2. Поддержка стандартной библиотеки: Не нужно добавлять зависимости.
3. Типы и валидация: С аннотациями типов ваш код становится более понятным и безопасным.

attrs остаётся полезным инструментом, особенно если вам нужны более продвинутые возможности (например, валидация значений полей), но для большинства задач data classes — отличное решение прямо "из коробки".

👉@BookPython

Пагинация — это стандартная задача, с которой ежедневно сталкиваются тысячи разработчиков. Если вы используете реляционную базу данных, то можно задать смещение через LIMIT, например:

SELECT *
FROM table
LIMIT 1001, 100;

Этот запрос действительно вернет 100 записей, с 1001-й по 1100-ю. Но проблема в том, что для базы данных это так же сложно, как и выборка всех первых 1001 записей. Чем дальше запрашиваемая страница, тем медленнее будет выполняться запрос.

Более оптимальным решением является использование фильтрации через WHERE, где клиент передает идентификатор последней записи текущей страницы ($last_seen_id в примере):

SELECT *
FROM table
WHERE id > $last_seen_id
ORDER BY id ASC
LIMIT 100;

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

Если хотите разобраться подробнее, рекомендую почитать отличную статью на эту тему!

👉 @BookPython

Как ускорить вычисления в Python с помощью multiprocessing.Pool

Когда речь заходит о ресурсоемких задачах, которые нагружают ваш CPU, стоит обратить внимание на библиотеку multiprocessing, а именно на класс Pool. Он позволяет задействовать все доступные ядра процессора, автоматически распределяя задачи между ними.

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

import math
from multiprocessing import Pool

# Генерируем список входных данных
inputs = [i ** 2 for i in range(100, 130)]

# Функция для вычислений
def f(x):
    return len(str(math.factorial(x)))

# Последовательное выполнение
%timeit [f(x) for x in inputs]
# Результат: ~1.44 сек

# Параллельное выполнение
p = Pool(4)  # Создаем пул из 4 процессов
%timeit p.map(f, inputs)
# Результат: ~451 мс

👉 @BookPython

Модуль multiprocessing в Python: потоки против процессов

Модуль multiprocessing позволяет создавать не только процессы, но и потоки. Однако стоит помнить о главной особенности CPython — GIL (Global Interpreter Lock). Этот механизм блокирует выполнение байт-кода Python несколькими потоками одновременно.

Это означает, что потоки полезны в основном в случаях, когда программа выполняет операции, не связанные с Python-интерпретатором, например, ожидание ввода-вывода (IO). К примеру, загрузка трёх различных статей из Википедии будет одинаково эффективной как с потоками, так и с процессами. Причём результат в три раза быстрее по сравнению с выполнением задачи в одном процессе:

from multiprocessing import Pool
from multiprocessing.pool import ThreadPool
import requests

def download_wiki_article(article):
    url = 'http://de.wikipedia.org/wiki/'
    return requests.get(url + article)

process_pool = Pool(3)
thread_pool = ThreadPool(3)

thread_pool.map(download_wiki_article, ['a', 'b', 'c'])
# ~376 ms

process_pool.map(download_wiki_article, ['a', 'b', 'c'])
# ~373 ms

[download_wiki_article(a) for a in ['a', 'b', 'c']]
# ~1.09 s

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

import math
from multiprocessing import Pool
from multiprocessing.pool import ThreadPool

def f(x):
    return len(str(math.factorial(x)))

process_pool = Pool(4)
thread_pool = ThreadPool(4)
inputs = [i ** 2 for i in range(100, 130)]

[f(x) for x in inputs]
# ~1.48 s

thread_pool.map(f, inputs)
# ~1.48 s

process_pool.map(f, inputs)
# ~478 ms

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

👉 @BookPython

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

Стандартная библиотека Python предоставляет возможность использовать бинарный поиск без его непосредственной реализации. Функция bisect_left возвращает самую левую позицию элемента в отсортированном списке, а bisect_right — самую правую.

from random import randrange
from bisect import bisect_left

n = 1000000
look_for = 555555
lst = sorted(randrange(0, n) for _ in range(n))

%timeit look_for in lst
# 69.7 ms ± 449 µs на цикл

%timeit look_for == lst[bisect_left(lst, look_for)]
# 927 ns ± 2.28 ns на цикл

Результаты демонстрируют, что использование бинарного поиска через bisect_left быстрее, чем стандартный поиск в списке с помощью оператора in.

👉 @BookPython

📌 О представлении данных в байтах в Python

Когда мы храним данные в памяти или на устройстве хранения, их необходимо представить в виде байтов. Python позволяет работать с абстракцией данных, не задумываясь об их байтовом представлении. Однако при записи строки в файл мы фактически работаем с физической структурой данных.

Чтобы записать символы в файл, их нужно преобразовать в байты — это называется кодированием (encoding). Когда вы читаете байты из файла и хотите преобразовать их в понятные символы, этот процесс называется декодированием (decoding).

🔤 Кодировки и их применение

Существует множество методов кодирования. Один из самых популярных — Unicode, но сам по себе Unicode не является кодировкой в традиционном смысле. Unicode определяет соответствие между символами и их числовыми кодами. Например, 🐍 имеет код 128 013.

Однако, чтобы записать числа в файл, нужна настоящая кодировка. Unicode обычно используется с utf-8, которая (в большинстве случаев) является кодировкой по умолчанию в Python. При чтении из файла Python автоматически декодирует данные, используя utf-8.

Если вы хотите использовать другую кодировку, просто укажите её с помощью параметра encoding= в функции open. А чтобы работать с "чистыми" байтами, добавьте символ b к режиму открытия файла.

Пример:

# Кодирование строки в файл
with open('example.txt', 'w', encoding='utf-8') as f:
    f.write('Привет, мир!')

# Чтение в байтовом режиме
with open('example.txt', 'rb') as f:
    data = f.read()
    print(data)  # Вывод: b'\xd0\x9f\xd1\x80\xd0\xb8...'

👉 @BookPython

🔑 Использование объектов в качестве ключей словаря в Python

В Python вы можете использовать любой объект в качестве ключа словаря, если он реализует метод __hash__. Этот метод возвращает целое число, но при этом важно соблюдать одно ключевое требование: равные объекты должны иметь одинаковый хэш (обратное утверждение необязательно).

👉 Не используйте изменяемые объекты в качестве ключей! Если объект изменяется после добавления в словарь, он становится "невидимым" для поиска, так как его хэш может измениться.

🌀 Странность с отрицательными хэшами

Есть интересная особенность, которая может вас удивить при отладке или написании юнит-тестов. Рассмотрим следующий пример:

class A:
    def __init__(self, x):
        self.x = x

    def __hash__(self):
        return self.x

Результаты хэширования экземпляров класса:

>>> hash(A(2))
2
>>> hash(A(1))
1
>>> hash(A(0))
0
>>> hash(A(-1))  # внимание!
-2
>>> hash(A(-2))
-2

💡 В CPython значение -1 зарезервировано для внутренних ошибок. Если хэш-значение равно -1, интерпретатор автоматически преобразует его в -2. Это может вызывать неожиданные проблемы при сравнении или использовании объектов в качестве ключей.

👉 @BookPython

Иногда нужно создать функцию на основе более универсальной. Например, у функции int() есть параметр base, который можно зафиксировать, чтобы получить новую функцию base2:

>>> int("10")
10
>>> int("10", 2)
2
>>> def base2(x):
...     return int(x, 2)
...
>>> base2("10")
2

Для более точной и семантически понятной реализации можно использовать functools.partial:

from functools import partial

base2 = partial(int, base=2)

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

>>> list(map(partial(int, base=2), ["1", "10", "100"]))
[1, 2, 4]

Без использования partial пришлось бы писать код так:

>>> list(map(lambda x: int(x, base=2), ["1", "10", "100"]))
[1, 2, 4]

👉@BookPython

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

Приглашаем на открытый урок «Визуализация данных на Python», посвященный курсу «Machine Learning» от Otus.

✅ Практика: визуализация данных Python на основных библиотеках: Matplotlib; Seaborn; Plotly

👉 Регистрация и подробности: https://vk.cc/cH48zk

Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576, www.otus.ru

Метод format в Python для строк — мощный инструмент, поддерживающий множество возможностей, о которых вы, возможно, даже не знали. Каждый заменяемый плейсхолдер ({...}) может содержать три части: имя поля, преобразование и спецификацию формата.

Имя поля используется для указания, какой именно аргумент должен быть подставлен:

>>> '{}'.format(42)
'42'
>>> '{1}'.format(1, 2)
'2'
>>> '{y}'.format(x=1, y=2)
'2'

Преобразование позволяет указать, что вместо str() следует использовать repr() (или ascii()) при преобразовании объектов в строки:

>>> '{!r}'.format(datetime.now())
'datetime.datetime(2018, 5, 3, 23, 48, 49, 157037)'
>>> '{}'.format(datetime.now())
'2018-05-03 23:49:01.060852'

Спецификация формата задаёт, как значения будут представлены:

>>> '{:+,}'.format(1234567)
'+1,234,567'
>>> '{:>19}'.format(1234567)
'            1234567'

Эта спецификация может быть применена и к отдельному объекту с помощью функции format (не метода str):

>>> format(5000000, '+,')
'+5,000,000'

Функция format вызывает метод __format__ объекта, поэтому вы можете изменить его поведение для своих типов.

👉@BookPython

Функция itertools.chain позволяет объединить несколько итерируемых объектов, чтобы работать с ними, как с единым целым:

from itertools import chain

print(list(chain(['a', 'b'], range(3), set('xyz'))))
# Вывод: ['a', 'b', 0, 1, 2, 'x', 'z', 'y']

Иногда нужно проверить, пуст ли генератор (точнее, исчерпан ли он). Для этого можно попытаться получить следующий элемент с помощью next(). Если элемент есть, его нужно вернуть обратно в генератор, но сделать это напрямую невозможно. Однако можно «приклеить» его обратно с помощью chain:

from itertools import chain

def sum_of_odd(gen):
    try:
        first = next(gen)  # Пытаемся получить первый элемент
    except StopIteration:
        raise ValueError('Empty generator')  # Если генератор пуст, выбрасываем исключение

    # Используем chain для возврата первого элемента и объединения с остальными
    return sum(
        x for x in chain([first], gen)
        if x % 2 == 1  # Суммируем только нечетные числа
    )

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

print(sum_of_odd(x for x in range(1, 6)))  # Вывод: 9 (1 + 3 + 5)
print(sum_of_odd(x for x in range(2, 3)))  # Вывод: 0 (нет нечетных чисел)
print(sum_of_odd(x for x in range(2, 2)))  # ValueError: Empty generator

👉@BookPython

В Python блок else можно использовать не только после if, но и после циклов for и while. Код внутри else выполняется только в том случае, если цикл завершился естественным образом, то есть не был прерван с помощью break.

Наиболее распространённый случай использования этого — поиск элемента в цикле с прерыванием через break, если элемент найден:

# Пример 1: Список содержит нечётное число
first_odd = None
for x in [2, 3, 4, 5]:
    if x % 2 == 1:  # Проверяем, является ли число нечётным
        first_odd = x
        break       # Прерываем цикл, так как элемент найден
else:
    raise ValueError('No odd elements in list')  # Выполнится, если цикл завершился без break

print(first_odd)  # Результат: 3

Если в списке нет подходящего элемента, цикл завершается естественным образом, и выполняется блок else:

# Пример 2: Список не содержит нечётных чисел
for x in [2, 4, 6]:
    if x % 2 == 1:
        first_odd = x
        break
else:
    raise ValueError('No odd elements in list')  # Исключение будет поднято

# ValueError: No odd elements in list

👉@BookPython

Когда вы создаете кастомный метод __repr__ для объекта, обычно нужно включить представление его атрибутов. Однако важно помнить, что нужно явно вызывать repr(), так как форматирование вызывает str() вместо repr().

Пример простого кода:

class Pair:
    def __init__(self, left, right):
        self.left = left
        self.right = right
        
    def __repr__(self):
        class_name = type(self).__name__
        repr_left = repr(self.left)
        repr_right = repr(self.right)
        return f'{class_name}({repr_left}, {repr_right})'

Проблема возникает, если вы вызываете repr для объекта, который содержит ссылку на самого себя. Это может привести к рекурсии:

In : p = Pair(1, 2)
In : p
Out: Pair(1, 2)
In : p.right = p
In : p
Out: [...]
RecursionError: maximum recursion depth exceeded while calling a Python object

Для решения этой проблемы можно использовать декоратор reprlib.recursive_repr, который обрабатывает рекурсивные вызовы:

@reprlib.recursive_repr()
def __repr__(self):
    class_name = type(self).__name__
    repr_left = repr(self.left)
    repr_right = repr(self.right)
    return f'{class_name}({repr_left}, {repr_right})'

Теперь код работает корректно:

In : p = Pair(1, 2)
In : p.right = p
In : p
Out: Pair(1, ...)

👉@BookPython