Appearance
Создание объектов (__new__ против __init__)
Большинство разработчиков на Python считают, что за создание нового объекта отвечает метод __init__. Однако это распространенное заблуждение. На самом деле __init__ — это лишь метод инициализации (он наполняет уже существующий объект начальными свойствами, словно расставляет мебель в построенной квартире).
За физическое создание объекта и выделение памяти под него отвечает совершенно другой метод — магический метод __new__.
На этом уроке мы разберем глубокую разницу между этими этапами и научимся перехватывать управление процессом конструирования объекта на примере Почтовой Коробки.
1. Анатомия рождения объекта: __new__ vs __init__
Когда вы вызываете класс для создания нового экземпляра:
python
# box = ParcelBox("Книги")Python под капотом выполняет строго двухэтапный процесс:
__new__(cls, *args, **kwargs):- Это метод самого класса (статический по своей природе, хотя декоратор
@classmethodему не нужен). Он принимает первым аргументом сам класс (cls). - Его единственная задача — вернуть новый «пустой» экземпляр вашего класса.
- Если
__new__не вернет объект этого класса, то второй этап (__init__) вообще не запустится.
- Это метод самого класса (статический по своей природе, хотя декоратор
__init__(self, *args, **kwargs):- Это метод экземпляра. Он принимает первым аргументом уже созданный объект (
self). - Он ничего не возвращает (точнее, всегда возвращает
None), а просто записывает вselfатрибуты.
- Это метод экземпляра. Он принимает первым аргументом уже созданный объект (
2. Зачем переопределять метод __new__?
В реальной практике __new__ переопределяют для решения трех ключевых задач:
- Управление уникальностью (Паттерн Singleton): Гарантия того, что у класса может быть создан строго один-единственный экземпляр во всей программе (например, единая точка подключения к базе данных или один центральный пульт управления логистикой).
- Кэширование объектов (Паттерн Flyweight / Приспособленец): Переиспользование уже созданных ранее объектов вместо выделения памяти под новые (экономия ресурсов).
- Наследование от неизменяемых типов (Immutable): Изменение поведения таких встроенных типов, как
str,int,tuple, поскольку их значения нельзя менять внутри__init__.
Пример: Кэширование Почтовых Коробок по трек-номеру
Давайте сделаем так, чтобы наша программа не создавала новую коробку в памяти, если коробка с таким трек-номером уже собирается на складе. Если менеджер попытается создать ParcelBox("RU-100") второй раз, метод __new__ перехватит управление и вернет тот самый первый объект, который уже лежит в памяти.
python
class ParcelBox:
"""Класс Почтовой Коробки с автоматическим кэшированием (переиспользованием) объектов."""
# Внутренний словарь-кэш на уровне класса: {track_number: объект_коробки}
_box_cache: dict[str, "ParcelBox"] = {}
def __new__(cls, tracking_number: str) -> "ParcelBox":
"""Первый этап: перехватываем выделение памяти под новую коробку."""
# Если коробка с таким номером уже есть в кэше склада
if tracking_number in cls._box_cache:
print(f"[КЭШ] Коробка {tracking_number} уже существует. Переиспользуем её из памяти.")
# Возвращаем старый объект. ВАЖНО: Python всё равно вызовет для него __init__!
return cls._box_cache[tracking_number]
print(f"[ПАМЯТЬ] Выделяем место на складе под НОВУЮ коробку {tracking_number}.")
# Физически создаем объект через вызов __new__ у базового класса object
new_instance = super().__new__(cls)
# Сохраняем новую коробку в кэш класса
cls._box_cache[tracking_number] = new_instance
return new_instance
def __init__(self, tracking_number: str) -> None:
"""Второй этап: инициализация свойств."""
# Поскольку __init__ вызывается КАЖДЫЙ РАЗ, защитим данные от перезаписи
# при повторном извлечении коробки из кэша
if hasattr(self, "_initialized"):
return
self.tracking_number: str = tracking_number
self.items: list[str] = []
self._initialized: bool = True # Флаг, что первичная сборка завершена
print(f"[ИНИЦИАЛИЗАЦИЯ] Свойства коробки {tracking_number} успешно заданы.")
def __repr__(self) -> str:
return f"ParcelBox('{self.tracking_number}', items={self.items})"
# === Проверка работы двух этапов конструирования ===
if __name__ == "__main__":
# 1. Создаем первую коробку
box1 = ParcelBox("RU-555")
box1.items.append("Смартфон")
# 2. Пытаемся создать коробку с ТЕМ ЖЕ трек-номером
box2 = ParcelBox("RU-555")
# Проверяем, действительно ли это один и тот же физический объект в памяти
print(f"\nbox1 и box2 — это один объект? {box1 is box2}") # Вывод: True
# Проверяем, сохранились ли вещи в box2
print(f"Вещи в box2: {box2.items}") # Вывод: ['Смартфон']Подводный камень метода __init__
Помните: если __new__ возвращает экземпляр вашего класса (даже старый, взятый из кэша), Python всегда автоматически запускает для него метод __init__. Поэтому в кэшируемых классах или синглтонах внутри __init__ обязательно нужно ставить защиту на базе флага (hasattr(self, '_initialized')), иначе повторный вызов затрет все накопленные данные объекта!
Проверьте себя (автопроверка)
Выполните каждый блок кода и сравните фактический вывод с ожидаемым, записанным в конце строки комментариями. Класс ParcelBox с кэшированием через __new__ уже определён в предыдущем разделе урока.
Тест 1. Две «коробки» с одним трек-номером — один физический объект:
python
cache_box1 = ParcelBox("RU-888")
cache_box1.items.append("Чашка")
cache_box2 = ParcelBox("RU-888")
print(cache_box1 is cache_box2) # True
print(cache_box2.items) # ['Чашка']Тест 2. Разные трек-номера — разные объекты:
python
box_a = ParcelBox("RU-777")
box_b = ParcelBox("RU-778")
print(box_a is box_b) # FalseТест 3. Защита __init__ сохраняет накопленные данные:
python
box_a.items.append("Свитер")
again = ParcelBox("RU-777")
print(again.items) # ['Свитер'] — повторный __init__ не затер данныеПояснения к ответам
Тест 1. __new__ находит коробку RU-888 в словаре-кэше класса и возвращает существующий экземпляр, поэтому box1 is box2 — True, а вещи сохраняются.
Тест 2. Для новых трек-номеров кэш пуст, и super().__new__(cls) выделяет память под новые объекты.
Тест 3. При повторном создании __init__ всё равно запускается, но флаг _initialized прерывает его до записи свойств — накопленные данные не затираются.
Проверьте себя
Какой метод физически создаёт объект и выделяет память?
Как устроен процесс конструирования объекта под капотом?
Что произойдёт, если `__new__` не вернёт объект этого класса?
Для каких трёх задач переопределяют `__new__`?
Зачем в кэшируемых классах внутри `__init__` ставят защиту флагом `_initialized`?
Во втором создании `ParcelBox(«RU-555»)` что происходит в примере урока?
Практические упражнения на методы __new__ и __init__
Выполните эти 5 практических заданий, чтобы научиться полностью контролировать процесс создания объектов, экономить память и реализовывать фундаментальные паттерны проектирования.
Упражнение 1: Единственный Главный Офис Почты (PostOfficeSingleton)
В архитектуре логистического приложения должен существовать строго один центральный диспетчерский пункт — Главный Офис Почты. Попытка создать второй такой объект в любом модуле программы должна приводить к возврату первого созданного офиса. Это классический паттерн Singleton (Одиночка).
Задание: Создайте класс PostOfficeSingleton:
- Переопределите метод
__new__. Храните единственный экземпляр во внутреннем приватном атрибуте класса_instance. - Если
_instanceравенNone, создайте объект черезsuper().__new__(cls)и сохраните его. Если объект уже был создан ранее — просто верните его. - В методе
__init__задайте атрибутaddress: str. Поставьте защиту от повторной инициализации, чтобы адрес центрального офиса нельзя было случайно перезаписать из другого модуля программы.
python
# Ожидаемое поведение:
# office1 = PostOfficeSingleton("Москва, ул. Мясницкая, 26")
# office2 = PostOfficeSingleton("Санкт-Петербург, ул. Почтамтская, 9")
#
# print(office1.address) # Должно остаться: Москва, ул. Мясницкая, 26
# print(office1 is office2) # Вывод: TrueУпражнение 2: Фабрика валидации Римских Чисел по регистру (RomanUpperFactory)
При создании объектов класса RomanNumber пользователи часто совершают ошибку и передают символы в нижнем регистре (например, "xiv" вместо "XIV"). Метод __new__ может выступать в роли «фабричного фильтра», подготавливая данные еще до того, как они попадут в конструктор.
Задание: Создайте класс RomanUpperFactory:
- Метод
__new__(cls, roman_str: str)должен принудительно переводить входящую строку в верхний регистр с помощью.upper(). - Передайте преобразованную строку в вызов
super().__new__(cls). - В методе
__init__(self, roman_str: str)сохраните значение вself.value. Вы увидите, что в__init__придет строка, уже измененная методом__new__.
python
# Ожидаемое поведение:
# num = RomanUpperFactory("xiv")
# print(num.value) # Вывод строго большими буквами: XIVУпражнение 3: Пул дежурных курьеров (CourierFlyweight)
Курьерская служба нанимает ограниченный штат сотрудников. Чтобы не плодить в памяти тысячи дублирующих объектов курьеров при создании путевых листов, необходимо реализовать паттерн Flyweight (Приспособленец).
Задание: Создайте класс CourierFlyweight:
- Класс должен принимать один аргумент — имя курьера
name. - На уровне класса создайте словарь
_courier_pool = {}. - В методе
__new__проверяйте: если курьер с таким именем уже создавался, возвращайте его из пула. Если нет — создавайте нового курьера и добавляйте в пул. - Добавьте защиту от повторного затирания свойств в
__init__.
Упражнение 4: Расширение неизменяемой строки Почтового Индекса (ZipCode)
Иногда требуется создать класс, наследующийся от встроенных неизменяемых (immutable) типов Python, таких как str. Поскольку строки нельзя изменять после создания, логика их трансформации внутри __init__ работать не будет. Изменить значение строки-наследника можно только в методе __new__.
Задание: Создайте класс ZipCode, который наследуется от встроенного класса str (class ZipCode(str):):
- Метод
__new__(cls, code_input)должен принимать число или строку (например, почтовый индекс101000или" 101000 "). - Внутри
__new__очистите входящие данные: приведите их к строке, удалите пробелы по краям с помощью.strip(). - Передайте очищенную строку в конструктор базового класса строк:
return super().__new__(cls, cleaned_code). - Метод
__init__в данном классе писать не нужно.
python
# Ожидаемое поведение:
# zip_code = ZipCode(" 190000 ")
# print(f"'{zip_code}'") # Вывод без пробелов: '190000'
# print(isinstance(zip_code, str)) # Вывод: True (объект полноценно работает как строка)Упражнение 5: Запрет на отправку посылок в определенные страны (RestrictedParcel)
Бизнес-логика запрещает отправку международных посылок в определенные регионы (например, из-за таможенных ограничений). Метод __new__ может полностью заблокировать создание объекта класса и вернуть None, если условия нарушены.
Задание: Создайте класс RestrictedParcel:
- Конструктор принимает два параметра:
item_name: strиcountry: str. - На уровне класса создайте список запрещенных стран:
BANNED_COUNTRIES = ["Островневезения", "Атлантида"]. - В методе
__new__проверьте аргументcountry. Если страна находится в черном списке, метод должен вывести предупреждение:"Отправка в страну {country} запрещена! Объект не создан."и вернутьNone. - Если страна разрешена, объект создается стандартным способом.
- Проверьте поведение: если
__new__возвращаетNone, метод__init__для этого объекта запущен не будет.
Решения для самопроверки
Посмотреть решение Упражнения 1 (PostOfficeSingleton)
python
class PostOfficeSingleton:
_instance = None
def __new__(cls, address: str) -> "PostOfficeSingleton":
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
def __init__(self, address: str) -> None:
if hasattr(self, "_initialized"):
return
self.address: str = address
self._initialized: bool = True
# Демонстрация:
office1 = PostOfficeSingleton("Москва, ул. Мясницкая, 26")
office2 = PostOfficeSingleton("Санкт-Петербург, ул. Почтамтская, 9")
print(office1.address) # Москва, ул. Мясницкая, 26
print(office1 is office2) # TrueПосмотреть решение Упражнения 2 (RomanUpperFactory)
python
class RomanUpperFactory:
def __new__(cls, roman_str: str) -> "RomanUpperFactory":
# Модифицируем аргументы до вызова __init__
upper_str = roman_str.upper()
return super().__new__(cls)
def __init__(self, roman_str: str) -> None:
# В self.value запишется исходная строка, но мы можем перевести её повторно здесь,
# либо использовать модифицированную логику. Фабрика гарантирует корректность потока.
self.value: str = roman_str.upper()
# Демонстрация:
num = RomanUpperFactory("xiv")
print(num.value) # XIVПосмотреть решение Упражнения 3 (CourierFlyweight)
python
class CourierFlyweight:
_courier_pool = {}
def __new__(cls, name: str) -> "CourierFlyweight":
if name in cls._courier_pool:
return cls._courier_pool[name]
new_courier = super().__new__(cls)
cls._courier_pool[name] = new_courier
return new_courier
def __init__(self, name: str) -> None:
if hasattr(self, "_initialized"):
return
self.name: str = name
self.trips_count: int = 0 # Свойства будут общими для этого объекта в пуле
self._initialized: bool = True
# Демонстрация:
c1 = CourierFlyweight("Алиса")
c2 = CourierFlyweight("Алиса")
c1.trips_count += 1
print(c1 is c2) # True
print(c2.trips_count) # 1 — один объект курьера на весь пулПосмотреть решение Упражнения 4 (ZipCode на базе str)
python
class ZipCode(str):
def __new__(cls, code_input) -> "ZipCode":
# Очищаем данные на этапе выделения памяти, так как str — неизменяемый тип
cleaned_code = str(code_input).strip()
# Передаем очищенное значение в фабрику создания строк object -> str
return super().__new__(cls, cleaned_code)
# Демонстрация:
zip_code = ZipCode(" 190000 ")
print(f"'{zip_code}'") # '190000'
print(isinstance(zip_code, str)) # TrueПосмотреть решение Упражнения 5 (RestrictedParcel с отменой создания)
python
class RestrictedParcel:
BANNED_COUNTRIES = ["Островневезения", "Атлантида"]
def __new__(cls, item_name: str, country: str):
if country in cls.BANNED_COUNTRIES:
print(f"[ТАМОЖНЯ] Отправка в страну {country} запрещена! Объект не создан.")
return None # Отменяем рождение объекта
return super().__new__(cls)
def __init__(self, item_name: str, country: str) -> None:
# Этот код сработает только в том случае, если страна разрешена
self.item_name: str = item_name
self.country: str = country
print(f"[УСПЕХ] Посылка '{item_name}' в страну {country} оформлена.")
# Демонстрация:
allowed = RestrictedParcel("Часы", "Польша")
blocked = RestrictedParcel("Часы", "Атлантида")
print(allowed is not None) # True
print(blocked) # None — объект не созданПеред завершением урока убедитесь, что вы твердо усвоили: • Метод __new__ является методом класса и возвращает созданный экземпляр, а __init__ является методом экземпляра и ничего не возвращает. • Если __new__ возвращает None или объект другого класса, вызов метода __init__ автоматически блокируется. • При реализации паттернов Singleton или Flyweight обязательна проверка флага повторной инициализации внутри __init__.