La méthode de la double python --- vous amener à voir le python logique sous-jacente (__ __ str, __ __ rééd, __ __ del, __ call__)

Nous sommes en train de l' écriture de code, souvent ramasser des fonctions appel directement telles que len (), impression () entrée () et ainsi de suite, en fait, ces méthodes ou fonctions au cours de l'appel, a déclenché beaucoup de mécanisme de fonctionnement interne et la logique sous - jacente, après des recherches approfondies, nous pouvons voir un python différent, la part qui suit quelques méthode à deux sous et leur logique de fonctionnement avec vous.
Double Down méthode: se réfère à la méthode avec double souligné, comme notre très commun dans la __init__ de classe, aujourd'hui , nous voulons introduire __str__, rééd , del , Appel :
---------- ------------------------- ligne de démarcation entre ----------------------- ------------
str
on définit la classe telle et instancier:

class A:
    pass
a=A()
print(a)

La sortie est:
< principale II.A, AT objet 0x0000026034D36E08>
Ce résultat est en fait assez d'adresses de mémoire, et peut voir qu'il est une sous - classe d'objet, modifier à nouveau le test de code:

class A:
    pass
    def __str__(self):
        return '我已经打印了'
a=A()
print(str(a))
print(a)

A cette sortie est:
je l' ai déjà imprimé
j'ai imprimé
méthode __str__ expliqué dans la classe est appelée deux fois, ce qui est la logique:
Quand on appelle la méthode str () dans la classe, ou imprimer un objet déclenché __str__ méthode, nous pouvons utiliser cette fonction pour définir la valeur de retour est nécessaire comme référence, lorsque l'objet est une méthode par défaut du programme d'impression des appels à une cible, et lorsque l'objet est pas un ensemble, quand vous le trouvez d'appeler l'objet de la classe parent, ce qui est la raison pour laquelle nous avons mis en place __str__ méthode, la raison sera déclenchée.
----------------------------------- ligne de séparation ------------- ----------------------
la repr
la fonction repr () pour convertir l'objet en lecture par l'interpréteur, et est simplement converti en sa forme originale. comme

a='1'
print(a)
print(repr(a))

Imprimer les résultats:
1
« 1 »
si un type de chaîne de nombres, mais quand nous imprimons directement le numéro montre 1, lorsque vous utilisez le rééd, une chaîne est affichée, qui est, sa forme originale. Ou le même exemple ci - dessus, nous allons changer rééd str

class A:
    def __repr__(self):
        return '我已经打印了repr'
a = A()
print(a)

Les résultats sont les suivants:
I ont imprimé rééd

De même, lorsqu'une classe d'objets d'impression, cela déclenchera les méthodes, les résultats et __str__ le même aspect, s'il __str__ et __repr__ en même temps, l'ordre est de savoir comment le code sous test?

class A:
     def __str__(self):
        return '我已经打印了str'
     def __repr__(self):
        return '我已经打印了repr'
a = A()
print(a)

Les résultats sont les suivants:
I ont imprimé str

Exécuter la logique: quand str__ et __repr__ exist, priorité __str , lorsqu'il n'y a pas __str__, continueront __repr__.
----------------------------------- ligne de séparation ------------- ----------------------
méthode del__ destructor: lorsque nous l' exécution du programme est terminé, il libérera la mémoire, il déclenchera __del . Tels que les exemples suivants:

class A:
    def __del__(self):
        print( '我已经执行了')
a = A()
del a

Nous instancier l'objet de classe A a, puis supprimer un, il va déclencher __del__ méthode.
Les résultats sont suit comme:
je l' ai effectué
à ce moment si nous imprimons un objet, trouvera les résultats suivants:
NameError: nom « A » ne définit pas la
description que nous utilisons del supprimer, il déclenche non seulement __del__ méthode objets également supprimer et il est la première mise en œuvre de l'ancien.
Parce que non seulement il dans l'utilisation de del déclenchement sera déclenchée à la fin du programme, la libération de la mémoire, nous pouvons utiliser __del__ comme les travaux de finition, de sorte que des opérations telles que la fermeture des dossiers.
----------------------------------- ligne de séparation ------------- ----------------------
Appel : cette méthode habituellement nous voyons rarement, mais très intéressant, regardez le code suivant

class A:
    def __call__(self):
        print('我已经执行了')
a = A()()

Les résultats:
Je l' ai déjà mis en œuvre

A partir des résultats ci - dessus peuvent être déduites, quand un objet plus (), la méthode __call__ de déclenchement, les résultats d'exploitation réels et notre estimation est le même.
Résumé:
. 1) STR : déclenchée lors de l' impression dans la classe
2) la repr : déclenchée lors de l' impression dans la classe, mais la présence de __str__, __str__ préférentiellement exécuté
3). Del : del déclenché lors de l' exécution ou de libérer de la mémoire
4). Appel : se déclenche lorsque l'objet est ajouté ()
plus d' applications, vous pouvez essayer d'explorer