Понимание создания объектов и метаклассов

Оригинал статьи находиться здесь.

Автор: Rupesh Mishra

Дата: 25 ноября 2020

Если вы переходите на Python с другого языка, то вполне нормально чувствовать себя немного запутанным в отношении создания объектов и наследования, особенно когда люди начинают говорить о «метаклассах». В этой статье Рупеш Мишра объясняет, как создание экземпляров, наследование и даже метаклассы работают в Python.

В этой статье мы рассмотрим процесс инстанцирования объектов, за которым следует внутренний Python для создания объектов. Я начну с основ создания объектов, а затем мы углубимся в понимание конкретных методов, таких как __new__, __init__ и __call__. Мы также поймем метакласс в Python и его роль в процессе создания объекта. Хотя это продвинутые темы, статья объясняет каждую тему шаг за шагом и с нуля, так что даже новички могут ее понять.

Обратите внимание, что эта статья написана с учетом Python3.

Оглавление

Внутреннее создание объектов и метаклассов в Python:

• Оглавление

• Базовый класс object в Python

• Объекты и типы в Python

• Метакласс в Python

• Процесс создания экземпляра объекта в Python

• Метод __new__

  • Переопределение метода __new__

• Метод __init__

• Метод __call__

• callable()

• Заключение

• Использованная литература

Базовый класс object в Python3

В Python3 все классы неявно наследуются от встроенного базового класса object. Класс object предоставляет некоторые общие методы, такие как __init__, __str__ и __new__, которые могут быть переопределены дочерним классом. Рассмотрим код ниже, например:

class Human:
    pass

В приведенном выше коде класс Human не определяет никаких атрибутов или методов. Однако по умолчанию класс Human наследует базовый класс object и в результате имеет все атрибуты и методы, определенные базовым классом object. Мы можем проверить все атрибуты и методы, унаследованные или определенные классом Human, используя функцию dir.

Функция dir возвращает список всех атрибутов и методов, определенных для любого объекта Python.

dir(Human)

# Output:
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__',
'__eq__', '__format__', '__ge__', '__getattribute__', '__gt__',
'__hash__', '__init__', '__init_subclass__', '__le__', '__lt__',
'__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__', '__weakref__']

Вывод функции dir показывает, что класс Human имеет множество методов и атрибутов, большинство из которых доступны классу Human из базового класса object. Python предоставляет атрибут __bases__ для каждого класса, который можно использовать для получения списка классов, наследуемых данным классом.

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

print(Human.__bases__)
# Output: (<class 'object'>,)

Приведенный выше вывод показывает, что класс Human имеет object в качестве базового класса. Мы также можем просмотреть атрибуты и методы, определенные классом object, используя функцию dir.

dir(object)

# Output:
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__gt__',
'__hash__', '__init__', '__init_subclass__', '__le__',
'__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

Приведенное выше определение класса Human эквивалентно следующему коду; здесь мы явно наследуем базовый класс object. Хотя вы можете явно наследовать базовый класс object, это не обязательно!

class Human(object):
    pass

Базовый класс object предоставляет методы __init__ и __new__, которые используются для создания и инициализации объектов класса. Мы подробно обсудим __init__ и __new__ в последней части руководства.

Объекты и типы в Python

Python — это объектно-ориентированный язык программирования. Всё в Python является объектом или экземпляром. Классы, функции и даже простые типы данных, такие как целое число и число с плавающей запятой, также являются объектами некоторого класса в Python. У каждого объекта есть класс, из которого он создается. Чтобы получить класс или тип объекта, Python предоставляет нам функцию type и свойство __class__, определенные для самого объекта.

Давайте разберемся с функцией type с помощью простых типов данных, таких как int и float.

# Простой целочисленный тип данных
a = 9

# Тип a - это int (то есть, a - это объект класса int)
type(a)
# Output:
<class 'int'>

# Тип b - это float (то есть, b - это объект класса float)
b = 9.0
type(b)
# Output:
<class 'float'>

В отличие от других языков, в Python 9 является объектом класса int, и на него ссылается переменная a. Аналогично, 9.0 — это объект класса float, на который ссылается переменная b.

type используется для поиска типа или класса объекта. Он принимает объект, тип которого мы хотим узнать, в качестве первого аргумента и возвращает тип или класс этого объекта.

Мы также можем использовать свойство __class__ объекта, чтобы найти тип или класс объекта.

__class__ — это атрибут объекта, который ссылается на класс, из которого был создан объект.

a.__class__
# Output:
<class 'int'>
b.__class__
# Output:
<class 'float'>

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

# определение класса Human
class Human:
    pass

# создание объекта Human
human_obj = Human()

Приведенный выше код создает экземпляр human_obj класса Human. Мы можем узнать класс (или тип human_obj), из которого был создан human_obj, используя либо функцию type, либо свойство __class__ объекта human_obj.

# human_obj - это тип Human
type(human_obj)
# Output:
<class '__main__.Human'>

human_obj.__class__
# Output:
<class '__main__.Human'>

Выводы type(human_obj) и human_obj.__class__ показывают, что human_obj имеет тип Human (т. е. human_obj был создан из класса Human).

Поскольку функции в Python также являются объектами, мы можем найти их тип или класс, используя функцию type или атрибут __class__.

# Проверяем тип функции
def simple_function():
    pass

type(simple_function)
# Output:
<class 'function'>
simple_function.__class__
# Output:
<class 'function'>

Таким образом, simple_function является объектом класса function.

Классы, из которых создаются объекты, также являются объектами в Python.

Например, класс Human (из которого был создан human_obj) сам по себе является объектом. Да, вы не ослышались! Даже классы имеют класс, из которого они создаются или инстанцируются.

Давайте узнаем тип или класс класса Human.

class Human:
    pass

type(Human)
# Output:
<class 'type'>
Human.__class__
# Output:
<class 'type'>

Таким образом, приведенный выше код показывает, что класс Human и любой другой класс в Python являются объектами класса type. Этот type является классом и отличается от функции type, которая возвращает тип объекта. Класс type, из которого создаются все классы, в Python называется метаклассом Metaclass. Давайте узнаем больше о метаклассе.

Метакласс в Python

Метакласс — это класс, из которого создаются экземпляры классов, или метакласс — это класс класса.

Ранее в статье мы проверили, что переменные a и b являются объектами классов int и float соответственно. Поскольку int и float являются классами, они должны иметь класс или метакласс, из которого они созданы.

type(int)
# Output:
<class 'type'>
type(float)# Output:
<class 'type'>

# Даже тип класса объекта - это type
type(object)
# Output:
<class 'type'>

Таким образом, класс type является метаклассом классов int и float. Класс type является даже метаклассом для встроенного класса object, который является базовым классом для всех классов в Python. Поскольку type сам по себе является классом, что такое метакласс класса type? Класс type является метаклассом самого себя!

type(type)
# Output:
<class 'type'>

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

Две важные концепции, которые мы рассмотрели до сих пор, заключаются в следующем:

• Все классы в Python являются объектами класса type, и этот класс типов называется Metaclass.

• Каждый класс в Python по умолчанию наследуется от базового класса object.

Процесс создания экземпляра объекта в Python

Имея общее представление о метаклассе Metaclass и объектах в Python, давайте теперь разберемся с процессом создания и инициализации объекта в Python. Рассмотрим класс Human, как определено ниже:

class Human:
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

human_obj = Human("Virat", "Kohli")

isinstance(human_obj, Human)
# Output:
True

# Поскольку object является базовым классом для всего класса, следовательно
# isinstance(human_obj, object) is True
isinstance(human_obj, object)
# Output:
True

Вывод приведенного выше кода показывает, что human_obj является экземпляром класса Human с first_name как Virat и last_name как Kohli. Если мы внимательно посмотрим на приведенный выше код, естественно возникнут некоторые вопросы:

• В соответствии с определением класса Human мы ничего не возвращаем из метода __init__; как вызов класса Human возвращает human_obj?

• Мы знаем, что метод __init__ используется для инициализации объекта, но как метод __init__ получает себя?

В этом разделе мы подробно обсудим каждый из этих вопросов и ответим на них.

Создание объекта в Python — это двухэтапный процесс. На первом этапе Python создает объект, а на втором этапе он инициализирует объект. В большинстве случаев нас интересует только второй шаг (т. е. шаг инициализации). Python использует метод __new__ на первом этапе (т. е. создание объекта) и использует метод __init__ на втором этапе (т. е. инициализации).

Если класс не определяет эти методы, они наследуются от базового класса object. Поскольку класс Human не определяет метод __new__, в процессе инстанцирования объекта вызывается метод __new__ класса object, а для инициализации вызывается метод __init__ класса Human. Далее мы подробно рассмотрим каждый из этих методов.

Метод __new__

Метод __new__ — это первый шаг в процессе создания экземпляра объекта. Это статический метод класса object, который принимает cls или ссылку на класс в качестве первого параметра. Остальные аргументы (Вират и Кохли) передаются при вызове класса - Human("Virat", "Kohli"). Метод __new__ создает экземпляр типа cls (т. е. он выделяет память для объекта, вызывая метод __new__ суперкласса, т. е. класса object, с помощью super().__new__(cls)). Затем он возвращает экземпляр типа cls.

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

Сигнатура метода __new__.

Переопределение метода __new__

# cls - является обязательным аргументом.
# Объект, возвращенный методом __new__ имеет тип cls
@staticmethod
def __new__(cls[,...]):
    pass

Мы можем изменить процесс создания объекта, переопределив метод __new__ класса object. Рассмотрим пример ниже:

class Human:
    def __new__(cls, first_name=None):
        # cls = Human. cls - это класс, с помощью которого будет создан объект.
        # Создаваемый объект будет типа cls.
        # Мы должны вызвать класс объекта __new__, чтобы выделить память
        obj = super().__new__(cls) # Это эквивалентно object.__new__(cls)

        # Изменяем созданный объект
        if first_name:
            obj.name = first_name
        else:
            obj.name = "Virat"

        print(type(obj)) # Печатает: <__main__.Human object at 0x103665668>
        # возвращаем объект
        return obj

# Создаем объект
# __init__ метод класса `object` будет вызван.
virat = Human()

print(virat.name)
# Output:
Virat

sachin = Human("Sachin")
print(sachin.name)
# Output:
Sachin

В приведенном выше примере мы переопределили метод __new__ класса object. Он принимает первые аргументы как cls — ссылку на класс Human.

Метод __new__ — это особый случай в Python. Хотя это статический метод класса объекта, при его переопределении нам не нужно украшать его декоратором staticmethod.

Внутри метода __new__ класса Human мы сначала вызываем метод __new__ класса object, используя super().__new__(cls). Метод __new__ класса object создает и возвращает экземпляр класса, который был передан в качестве аргумента методу __new__. Здесь, когда мы передаем cls (т. е. ссылку на класс Human); метод __new__ класса object вернет экземпляр типа Human.

Мы должны вызвать метод __new__ класса object внутри переопределенного метода __new__, чтобы создать объект и выделить память для объекта.

Метод __new__ класса Human изменяет объект obj, возвращаемый методом __new__ класса object, и добавляет к нему свойство name. Таким образом, все объекты, созданные с помощью класса Human, будут иметь свойство name. Вуаля! Мы изменили процесс создания объекта класса Human.

Рассмотрим другой пример. В этом примере мы создаем новый класс с именем Animal и переопределяем метод __new__. Здесь, когда мы вызываем метод __new__ класса object из метода __new__ класса Animal, вместо передачи ссылки на класс Animal в качестве аргумента методу __new__ класса object мы передаем ссылку на класс Human. Следовательно, объект, возвращаемый методом __new__ класса object, будет иметь тип Human, а не Animal. В результате объект, возвращаемый при вызове класса Animal (т. е. Animal()), будет иметь тип Human.

class Animal:
    def __new__(cls):
        # Передача ссылки на класс Human вместо ссылки на класс Animal
        obj = super().__new__(Human) # Это эквивалентно object.__new__(Human)

        print(f"Type of obj: {type(obj)}")
        # Напечатает: Type of obj: <class '__main__.Human'>

        # возвращаем объект
        return obj

# Создаем объект
cat = Animal()
# Output:
Type of obj: <class '__main__.Human'>

type(cat)
# Output:
<class '__main__.Human'>

Метод __init__

Метод __init__ — это второй шаг процесса создания экземпляра объекта в Python. Он принимает первый аргумент как объект или экземпляр, возвращаемый методом __new__. Остальные аргументы - это аргументы, переданные при вызове класса (Human("Virat", "Kohli")). Эти аргументы используются для инициализации объекта. Метод __init__ не должен ничего возвращать. Если вы попытаетесь вернуть что-либо с помощью метода __init__, это вызовет исключение, как показано ниже:

class Human:
    def __init__(self, first_name):
        self.first_name = first_name
        return self

human_obj = Human('Virat')
# Output:
TypeError: __init__() should return None, not 'Human'

Рассмотрим простой пример, чтобы понять методы __new__ и __init__.

class Human:
    def __new__(cls, *args, **kwargs):
        # Здесь необходимо вызвать метод __new__ класса object
        # для создания объекта и выделения ему памяти.
        print("Inside new method")
        print(f"args arguments {args}")
        print(f"kwargs arguments {kwargs}")

        # В приведенном ниже коде вызывается метод __new__ класса object.
        # Метод __new__ класса object выделяет память для экземпляра
        # и возвращает этот экземпляр
        human_obj = super(Human, cls).__new__(cls)

        print(f"human_obj instance - {human_obj}")
        return human_obj

    # Поскольку мы переопределили метод __init__,
    # метод __init__ класса object вызываться не будет.
    def __init__(self, first_name, last_name):
        print("Inside __init__ method")
        # self = human_obj возвращается из метода __new__

        self.first_name = first_name
        self.last_name = last_name

        print(f"human_obj instance inside __init__ {self}: {self.first_name}, {self.last_name}")

human_obj = Human("Virat", "Kohli")

# Output
# Inside new method
# args arguments ('Virat', 'Kohli')
# kwargs arguments {}
# human_obj instance - <__main__.Human object at 0x103376630>
# Inside __init__ method
# human_obj instance inside __init__ <__main__.Human object at 0x103376630>: Virat, Kohli

В приведенном выше коде мы переопределили методы __new__ и __init__ класса object. __new__ создает объект (human_obj) типа класса Human и возвращает его. Как только метод __new__ завершен, Python вызывает метод __init__ с объектом human_obj в качестве первого аргумента. Метод __init__ инициализирует human_obj с first_name как Virat и last_name как Kohli. Поскольку создание объекта — это первый шаг, а инициализация — второй шаг, метод __new__ всегда будет вызываться перед методом __init__.

И __init__, и __new__ называются магическими методами в Python. Магические методы имеют имена, которые начинаются и заканчиваются на __ (двойное подчеркивание или "dunder"). Магические методы вызываются Python неявно; вам не нужно вызывать их явно. Например, Python неявно вызывает метод __new__ и __init__. Давайте рассмотрим еще один волшебный метод, __call__.

Метод __call__

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

Рассмотрим пример, чтобы лучше понять вызываемые объекты:

def print_function():
    print("I am a callable object")

# print_function  - вызываемый объект,
# так как ее можно вызывать с помощью круглых скобок
print_function()

# Output
# I am a callable object

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

a = 10

# Поскольку целочисленный объект нельзя вызывать,
# вызов `a` с использованием круглых скобок вызовет исключение.
a()
# Output:
TypeError: 'int' object is not callable

callable()

Вызываемая (callable) функция используется для определения того, является ли объект вызываемым. Вызываемая функция принимает ссылку на объект в качестве аргумента и возвращает значение True, если объект кажется вызываемым, или False, если объект не является вызываемым. Если вызываемая функция возвращает значение True, объект может быть не вызываемым; однако, если он возвращает False, то объект определенно не может быть вызван.

# Функции можно вызывать
callable(print_function)
# Output:
True

# Целочисленный объект не вызывается
callable(a)
# Output:
False

Давайте определим, являются ли классы в Python вызываемыми. Здесь мы определим, можно ли вызвать определенный ранее класс Human.

callable(Human)
# Output:
True

Да, классы в Python можно вызывать, и они должны быть такими! Вы так не думаете? Когда мы вызываем класс, он возвращает экземпляр этого класса. Давайте выясним, являются ли объекты, созданные из класса, вызываемыми.

human_obj = Human("Virat", "Kohli")

callable(human_obj)
# Output:
False

# Давайте попробуем вызвать human_obj
human_obj()

# Поскольку human_obj не вызывается, возникает исключение
# Output:
TypeError: 'Human' object is not callable

Таким образом, human_obj не вызывается через класс human_obj (т. е. класс Human является вызываемым).

Чтобы сделать любой объект в Python вызываемым, Python предоставляет метод __call__, который должен быть реализован классом объекта. Например, чтобы сделать объект human_obj вызываемым, класс Human должен реализовать метод __call__. Как только класс Human реализует метод __call__, все объекты класса Human могут вызываться как функции (т. е. с использованием круглых скобок).

class Human:
    def __init__(self, first_name, last_name):
        print("I am inside __init__ method")
        self.first_name = first_name
        self.last_name = last_name

    def __call__(cls):
        print("I am inside __call__ method")

human_obj = Human("Virat", "Kohli")
# Output:
I am inside __init__ method

# Оба human_obj() и human_obj.__call__() эквивалентны
human_obj()
# Output:
I am inside __call__ method

human_obj.__call__()
# Output:
I am inside __call__ method

callable(human_obj)
# Output:
True

Приведенный выше вывод кода показывает, что после реализации метода __call__ в классе Human human_obj становится вызываемым объектом. Мы можем вызвать human_obj, используя круглые скобки (например, human_obj()). Когда мы используем human_obj(), в фоновом режиме Python вызывает метод __call__ класса Human. Итак, вместо того, чтобы вызывать human_obj как human_obj(), мы можем напрямую вызвать метод __call__ для human_obj (т. е. human_obj.__call()). И human_obj(), и human_obj.__call__() эквивалентны, и это одно и то же.

Для всех вызываемых объектов их классы должны реализовывать метод __call__.

Мы знаем, что функции являются вызываемыми объектами, поэтому их класс (то есть function) должен реализовывать метод __call__. Давайте вызовем метод __call__ для определенной ранее функции print_function.

print_function.__call__()
# Output:
I am a callable object

В Python класс class также является вызываемым объектом; следовательно, это класс класса (метакласса) (т. е. класс type должен иметь определенный для него метод вызова call). Следовательно, когда мы вызываем Human(), в фоновом режиме Python вызывает метод вызова call класса type.

Грубо говоря, метод __call__ для класса type выглядит примерно так, как показано ниже. Это просто для целей объяснения; мы рассмотрим фактическое определение метода __call__ позже в этом руководстве.

class type:
    def __call__():
        # Вызывается при вызове класса, т.е. Human()
        print("type's call method")

Имея представление о методе __call__ и о том, как вызов класса вызывает метод __call__ класса type, давайте найдем ответы на следующие вопросы, касающиеся процесса инициализации объекта:

• Кто вызывает метод __new__ и __init__?

• Кто передает объект self методу __init__?

• Поскольку метод __init__ вызывается после метода __new__, а метод __init__ ничего не возвращает, как вызов класса возвращает объект (т. е. как вызов класса Human возвращает объект human_obj)?

Рассмотрим пример создания экземпляра объекта в Python.

class Human:
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name


human_obj = Human("Virat", "Kohli")

Мы знаем, что когда мы вызываем класс (например, Human("Virat", "Kohli")), вызывается метод __call__ класса type. Однако каково определение метода __call__ класса type? Поскольку мы говорим о CPython, определение метода __call__ класса type определено на языке C. Если мы конвертируем его в Python и упрощаем, он будет выглядеть примерно так:

# __call__ метода type который вызывается, когда вызывается класс Human,
# т.е. Human()
def __call__(cls, *args, **kwargs):
    # cls = Human класс
    # args = ["Virat", "Kohli"]
    # Вызов метода __new__ класса Human, так как метод __new__
    # не определен на Human, вызывается метод __new__ класса объекта
    human_obj = cls.__new__(*args, **kwargs)

    # После того, как метод __new__ вернет объект,
    # метод __init__ будет вызываться только в том случае, если
    # 1. human_obj не является None
    # 2. human_obj является экземпляром класса Human
    # 3. __init__ метод определен в классе Human
    if (human_obj is not None and isinstance(human_obj, cls) and\
        hasattr(human_obj, '__init__')
    ):
        # Поскольку __init__ вызывается для human_obj,
        # self будет равно human_obj в методе __init__
        human_obj.init(*args, **kwargs)

    return human_obj

Давайте разберемся в приведенном выше коде; когда мы делаем Human("Virat", "Kohli") в фоновом режиме, Python вызовет метод __call__ класса type, который определен как приведенный выше фрагмент кода. Как показано выше, метод __call__ класса type принимает класс Human в качестве первого аргумента (cls — это класс Human), а остальные аргументы передаются при вызове класса Human. Метод __call__ класса type сначала вызовет метод __new__, определенный в классе Human, если таковой имеется; в противном случае вызывается метод __new__ родительского класса класса Human (т. е. метод __new__ класса object). Метод __new__ вернет объект human_obj. Теперь метод __call__ класса type будет вызывать метод __init__, определенный в классе Human, с human_obj в качестве первого аргумента. __init__ инициализирует human_obj переданными аргументами, и, наконец, метод __call__ вернет human_obj.

Итак, при создании и инициализации объекта в Python выполняются следующие шаги:

1. Вызвать класс Human - Human(); это внутренне вызывает метод __call__ класса type (т. е. type.__call__(Human, "Virat", "Kohli")).

2. type.__call__ сначала вызовет метод __new__, определенный в классе Human. Если метод __new__ не определен в классе Human, будет вызван метод __new__ класса object.

3. Метод __new__ вернет объект типа Human, т.е. human_obj.

4. Теперь type.__call__ вызовет метод __init__, определенный в классе Human, с human_obj в качестве первого аргумента. Этот human_obj будет self в методе __init__.

5. Метод __init__ инициализирует human_obj с first_name как Virat и thelast_name как Kohli. Метод __init__ ничего не вернет.

6. В конце концов, type.__call__ вернет объект human_obj.

В соответствии с определением type.__call__ всякий раз, когда мы создаем новый объект, всегда будет вызываться метод __new__, но вызов метода __init__ зависит от вывода метода __new__. Метод __init__ будет вызываться только в том случае, если метод __new__ возвращает объект типа класса Human или подкласса класса Human.

Давайте разберемся в некоторых случаях.

Случай 1: если возвращаемый объект из метода __new__ имеет тип Human (т. е. класс метода __init__), будет вызван метод __init__.

class Human:
    def __new__(cls, *args, **kwargs):
        print(f"Creating the object with cls: {cls} and args: {args}")
        obj = super().__new__(cls)
        print(f"Object created with obj: {obj} and type: {type(obj)}")
        return obj

    def __init__(self, first_name, last_name):
        print(f"Started: __init__ method of Human class with self: {self}")
        self.first_name = first_name
        self.last_name = last_name
        print(f"Ended: __init__ method of Human class")

human_obj = Human("Virat", "Kohli")

Выведет:

Creating the object with cls: <class '__main__.Human'> and args: ('Virat', 'Kohli')
Object created with obj: <__main__.Human object at 0x102f6a4e0> and type: <class '__main__.Human'>
Started: __init__ method of Human class with self: <__main__.Human object at 0x102f6a400>
Ended: __init__ method of Human class with self: <__main__.Human object at 0x102f6a400>

Случай 2: Если метод __new__ ничего не возвращает, то __init__ вызываться не будет.

class Human:
    def __new__(cls, *args, **kwargs):
        print(f"Creating the object with cls: {cls} and args: {args}")
        obj = super().__new__(cls)
        print(f"Object created with obj: {obj} and type: {type(obj)}")
        print("Not returning object from __new__ method, hence __init__ method will not be called")

    def __init__(self, first_name, last_name):
        print(f"Started: __init__ method of Human class with self: {self}")
        self.first_name = first_name
        self.last_name = last_name
        print(f"Ended: __init__ method of Human class")

human_obj = Human("Virat", "Kohli")

Выведет:

Creating the object with cls: <class '__main__.Human'> and args: ('Virat', 'Kohli')
Object created with obj: <__main__.Human object at 0x102f6a5c0> and type: <class '__main__.Human'>
Not returning object from __new__ method, hence __init__ method will not be called

В приведенном выше коде вызывается метод __new__ класса Human; следовательно, создается obj типа Human (т. е. для obj выделяется память). Однако, поскольку метод __new__ не возвратил human_obj, метод __init__ вызываться не будет. Также у human_obj не будет ссылки на созданный объект, так как он не был возвращен из метода __new__.

print(human_obj)
# Output:
None

Случай 3: метод __new__ возвращает целочисленный объект.

class Human:
    def __new__(cls, *args, **kwargs):
        print(f"Creating the object with cls: {cls} and args: {args}")
        obj = super().__new__(cls)
        print(f"Object created with obj: {obj} and type: {type(obj)}")
        print("Not returning object from __new__ method, hence __init__ method will not be called")
        return 10

    def __init__(self, first_name, last_name):
        print(f"Started: __init__ method of Human class with self: {self}")
        self.first_name = first_name
        self.last_name = last_name
        print(f"Ended: __init__ method of Human class")

human_obj = Human("Virat", "Kohli")

В приведенном выше коде вызывается метод __new__ класса Human; следовательно, создается obj типа Human (т. е. для obj выделяется память). Однако метод __new__ вернул не human_obj, а целое число со значением 10, которое не относится к типу Human; следовательно, метод __init__ вызываться не будет. Кроме того, human_obj не будет иметь ссылку на созданный объект, но будет ссылаться на целочисленное значение 10.

print(human_obj)
# Output:
10

В сценариях, где метод __new__ не возвращает экземпляр класса, и мы хотим инициализировать объект, мы должны вызвать метод __init__ явно внутри метода __new__, как показано ниже:

class Human:
    def __new__(cls, *args, **kwargs):
        print(f"Creating the object with cls: {cls} and args: {args}")
        obj = super().__new__(cls)
        print(f"Object created with obj: {obj} and type: {type(obj)}")
        print("Not returning object from __new__ method, hence __init__ method will not be called")
        obj.__init__(*args, **kwargs)
        return 10

    def __init__(self, first_name, last_name):
        print(f"Started: __init__ method of Human class with self: {self}")
        self.first_name = first_name
        self.last_name = last_name
        print(f"Ended: __init__ method of Human class")

human_obj = Human("Virat", "Kohli")

Выведет:

Creating the object with cls: <class '__main__.Human'> and args: ('Virat', 'Kohli')
Object created with obj: <__main__.Human object at 0x102f6a860> and type: <class '__main__.Human'>
Not returning object from __new__ method, hence __init__ method will not be called
Started: __init__ method of Human class with self: <__main__.Human object at 0x102f6a860>
Ended: __init__ method of Human class

В приведенном выше случае метод __new__ вернул целочисленный объект; следовательно, значение human_obj будет равно 10.

print(human_obj)
# Output:
10

Заключение

В этой статье мы рассмотрели магические методы __new__, __init__ и __call__ и обсудили метакласс в Python. При этом теперь мы лучше понимаем процессы создания и инициализации объектов в Python.

Использованная литература

• https://eli.thegreenplace.net/2012/04/16/python-object-creation-sequence

• https://realpython.com/python-metaclasses/#old-style-vs-new-style-classes

• https://docs.python.org/3/reference/datamodel.html#special-method-names