Où est écrit le processus d'instanciation python?

Lors de l'initialisation d'une instance avec python, elle est souvent décrite dans une méthode spéciale appelée __init __ (), mais l'instance n'est pas créée ici. Tout en confirmant ce fait, découvrons où est écrit le processus de création d'une instance.

** Environnement d'exécution **

new est exécuté avant init

class Foo():
    def __init__(self):
        print('init')
        print('self = %s' % self)

Foo()
# => 
# init
# self = <__main__.Foo object at 0x10dacb9b0> 

L'écriture de Class () appellera la méthode spéciale __init__ de cette classe. Ceci est une méthode d'instance. La raison en est qu'il prend soi-même comme argument, c'est-à-dire comme instance. Puisque le nom de la variable self n'est pas fixé dans la grammaire, d'autres noms peuvent être utilisés, mais il semble qu'il soit habituellement utilisé comme self.

Alors, où cette instance est-elle créée? Tout d'abord, supprimons new qui est exécuté avant __init __ ().

[Document officiel](http://docs.python.jp/3.4/reference/datamodel.html?highlight=%E7%89%B9%E6%AE%8A%E3%83%A1%E3%82%BD% E3% 83% 83% E3% 83% 89 # specialnames) indique que __new__ () sera appelé pour créer une nouvelle instance. Et ce __new__ () est automatiquement défini au moment de la création de la classe même s'il n'est pas spécifié.

class Foo():
    def __init__(self):
        pass

foo = Foo()
`__new__' in dir(foo)
# =>  True

Vous pouvez également voir dans la documentation officielle que ce __new __ () est exécuté avant le __init __ ().

Si new () renvoie une instance de cls, l'instance init () est appelée comme init (self [, ...]). À ce stade, self est l'instance nouvellement créée et les arguments restants sont les mêmes que ceux passés à new (). 3. Modèle de données - Python 3.4.3 Documents </ cite>

Cela peut être confirmé dans le code source ci-dessous.

class Foo():
    def __new__(cls, var1):
        print('new')
        print('var1 = %s' % var1)
        return super().__new__(cls)

    def __init__(self, var1):
        print('init')
        print('self = %s' % self)
        print('var1 = %s' % var1)

Foo('my_value')
# => 
# new
# var1 = my_value
# init
# self = <test.Foo object at 0x103bd0208> 
# var1 = my_value * Jusqu'ici, c'est print()C'est la sortie en.
#<test.Foo at 0x103bd0208> 

super () appelle la classe parente. Cette fois, l'instanciation est laissée à la classe parente. Puisqu'il remplace __new__ (), j'ai utilisé super (). __ new__ (cls) pour écrire moi-même le processus de création explicite de l'instance.

Où sont les méthodes héritées?

Même si vous ne remplacez pas __new__ (), si vous laissez la création de l'instance à la classe parent __new__ (), le processus d'instanciation réel est écrit dans l'objet __new__ () de tous les objets de classes parentes. Ça sera fait. Alternativement, le processus d'instanciation peut être écrit dans «new ()» de chaque classe.

Je ne savais toujours pas où le processus d'instanciation était écrit. Cependant, j'ai trouvé que ** Class () appelait __new__ **.

Pour confirmer que ce processus __new__ () est écrit, exécutez-le sans ajouter de parenthèses () au nom de la méthode.

class Super():
    @classmethod
    def hello(cls):
        print('super hello')

    @classmethod
    def say(cls):
        print('super say')

class Sub(Super):
    @classmethod
    def hello(cls):
        print('super hello')

#Vérifiez la méthode que vous avez définie et la classe dans laquelle elle est définie
Super.hello
# => <bound method type.hello of <class 'test.Super'> > 
Sub.hello
# => <bound method type.hello of <class 'test.Sub'> > 

#Si non annulé
Sub.say
# => <bound method type.say of <class 'test.Sub'> > 

Super.__new__
# => <function object.__new__> 
Super.__init__
# => <slot wrapper '__init__' of 'object' objects> 
Super.__le__
# => <slot wrapper '__le__' of 'object' objects> 

Non seulement __new__, mais d'autres méthodes spéciales elles-mêmes sont définies par objet. Il s'avère que tous les objets sont laissés à l'objet pour être instanciés, sauf s'ils sont remplacés.