Skip to content

Создание объектов (__new__ против __init__) ​

Большинство разработчиков на Python считают, что за создание нового объекта отвечает метод __init__. Однако это распространенное заблуждение. На самом деле __init__ — это лишь метод инициализации (он наполняет уже существующий объект начальными свойствами, словно расставляет мебель в построенной квартире).

За физическое создание объекта и выделение памяти под него отвечает совершенно другой метод — магический метод __new__.

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

1. Анатомия рождения объекта: __new__ vs __init__ ​

Когда вы вызываете класс для создания нового экземпляра:

python
# box = ParcelBox("Книги")

Python под капотом выполняет строго двухэтапный процесс:

  1. __new__(cls, *args, **kwargs):

    • Это метод самого класса (статический по своей природе, хотя декоратор @classmethod ему не нужен). Он принимает первым аргументом сам класс (cls).
    • Его единственная задача — вернуть новый «пустой» экземпляр вашего класса.
    • Если __new__ не вернет объект этого класса, то второй этап (__init__) вообще не запустится.
  2. __init__(self, *args, **kwargs):

    • Это метод экземпляра. Он принимает первым аргументом уже созданный объект (self).
    • Он ничего не возвращает (точнее, всегда возвращает None), а просто записывает в self атрибуты.

2. Зачем переопределять метод __new__? ​

В реальной практике __new__ переопределяют для решения трех ключевых задач:

  1. Управление уникальностью (Паттерн Singleton): Гарантия того, что у класса может быть создан строго один-единственный экземпляр во всей программе (например, единая точка подключения к базе данных или один центральный пульт управления логистикой).
  2. Кэширование объектов (Паттерн Flyweight / Приспособленец): Переиспользование уже созданных ранее объектов вместо выделения памяти под новые (экономия ресурсов).
  3. Наследование от неизменяемых типов (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:

  1. Переопределите метод __new__. Храните единственный экземпляр во внутреннем приватном атрибуте класса _instance.
  2. Если _instance равен None, создайте объект через super().__new__(cls) и сохраните его. Если объект уже был создан ранее — просто верните его.
  3. В методе __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:

  1. Метод __new__(cls, roman_str: str) должен принудительно переводить входящую строку в верхний регистр с помощью .upper().
  2. Передайте преобразованную строку в вызов super().__new__(cls).
  3. В методе __init__(self, roman_str: str) сохраните значение в self.value. Вы увидите, что в __init__ придет строка, уже измененная методом __new__.
python
# Ожидаемое поведение:
# num = RomanUpperFactory("xiv")
# print(num.value)  # Вывод строго большими буквами: XIV

Упражнение 3: Пул дежурных курьеров (CourierFlyweight) ​

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

Задание: Создайте класс CourierFlyweight:

  1. Класс должен принимать один аргумент — имя курьера name.
  2. На уровне класса создайте словарь _courier_pool = {}.
  3. В методе __new__ проверяйте: если курьер с таким именем уже создавался, возвращайте его из пула. Если нет — создавайте нового курьера и добавляйте в пул.
  4. Добавьте защиту от повторного затирания свойств в __init__.

Упражнение 4: Расширение неизменяемой строки Почтового Индекса (ZipCode) ​

Иногда требуется создать класс, наследующийся от встроенных неизменяемых (immutable) типов Python, таких как str. Поскольку строки нельзя изменять после создания, логика их трансформации внутри __init__ работать не будет. Изменить значение строки-наследника можно только в методе __new__.

Задание: Создайте класс ZipCode, который наследуется от встроенного класса str (class ZipCode(str):):

  1. Метод __new__(cls, code_input) должен принимать число или строку (например, почтовый индекс 101000 или " 101000 ").
  2. Внутри __new__ очистите входящие данные: приведите их к строке, удалите пробелы по краям с помощью .strip().
  3. Передайте очищенную строку в конструктор базового класса строк: return super().__new__(cls, cleaned_code).
  4. Метод __init__ в данном классе писать не нужно.
python
# Ожидаемое поведение:
# zip_code = ZipCode("  190000   ")
# print(f"'{zip_code}'")  # Вывод без пробелов: '190000'
# print(isinstance(zip_code, str))  # Вывод: True (объект полноценно работает как строка)

Упражнение 5: Запрет на отправку посылок в определенные страны (RestrictedParcel) ​

Бизнес-логика запрещает отправку международных посылок в определенные регионы (например, из-за таможенных ограничений). Метод __new__ может полностью заблокировать создание объекта класса и вернуть None, если условия нарушены.

Задание: Создайте класс RestrictedParcel:

  1. Конструктор принимает два параметра: item_name: str и country: str.
  2. На уровне класса создайте список запрещенных стран: BANNED_COUNTRIES = ["Островневезения", "Атлантида"].
  3. В методе __new__ проверьте аргумент country. Если страна находится в черном списке, метод должен вывести предупреждение: "Отправка в страну {country} запрещена! Объект не создан." и вернуть None.
  4. Если страна разрешена, объект создается стандартным способом.
  5. Проверьте поведение: если __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__.