Est un constructeur __init__ nécessaires pour une classe en Python?

Je vois un malentendu entre un constructeur, la construction de l'objet et de l'initialisation de l'objet:

Python utilisation de __new__ et __init__?

Utilisation __new__ lorsque vous avez besoin de contrôler la création d'un nouvelle instance. Utilisation __init__ quand vous en avez besoin pour le contrôle de l'initialisation d'une nouvelle instance.

Nous nous devons donc d'être prudent ici.

J'ai lu que le constructeur est comme le premier argument passé à la classe, ce qui fait sens pour moi étant donné que les paramètres semblent être transmis à la classe via le __init__ méthode.

Le constructeur n'est pas transmis à la classe, pour être précis, le résultat du constructeur (__new__) sera le premier argument pour chaque méthode d'instance de la classe ou de ses sous-classes (note: __new__ fonctionne uniquement pour les nouvelles classes de style):

class A:
    def __new__(self):
            return 'xyz'

Voir ce qui se passe lorsque vous appelez la classe (création de l'objet):

>>> A()
'xyz'
>>> type(A())
<class 'str'>

L'appel de la classe n'est plus de retour instance de type A, parce que nous avons changé le mécanisme du constructeur __new__. En fait en faisant de sorte que vous pouvez modifier la signification de votre classe, et pas seulement, c'est assez difficile à déchiffrer. Il est peu probable que vous allez changer le type de l'objet lors de la création de temps de cet objet spécifique. J'espère que cette phrase a un sens, si non, comment peut-elle donner un sens à votre code!

class A:
    def __new__(self):
            return 'xyz'

    def type_check(self):
            print(type(self))

Regardez ce qui se passe lorsque nous essayons de faire appel type_check méthode:

>>> a = A()
>>> a
'xyz'
>>> a.type_check()
AttributeError: 'str' object has no attribute 'type_check'

a n'est pas un objet de la classe A, donc, fondamentalement, vous n'avez pas accès à la classe A plus.

__init__ est utilisé pour initialiser l'état de l'objet. Au lieu d'appeler des méthodes qui leur permettront d'initialiser les membres de l'objet après sa création, __init__ résout ce problème en initialisant les membres de l'objet lors de la création du temps, donc si vous avez un membre appelé name à l'intérieur d'une classe et que vous voulez initialiser name lorsque vous créez la classe au lieu d'appeler une méthode supplémentaire init_name('name'), vous serait certainement utiliser __init__ à cette fin.

Donc quand je l'appel de la classe, je passe les paramètres de la __init__ méthode?

Lorsque vous appelez la classe, vous transmettez les paramètres (de) __init__ méthode?

Quels que soient les arguments que vous passez la classe, tous les paramètres seront passés à __init__ avec un paramètre supplémentaire ajouté automatiquement pour vous, qui est l'objet impliqué généralement appelé self (l'instance elle-même) qui sera transmise toujours comme le la plus à gauche argument par Python automatiquement:

class A:
    def __init__(self, a, b):
        self.a = a
        self.b = b 

---

        A(  34,  35) 
 self.a = 34 |    |  
             |    | 
             |    | self.b = 35  
  init(self, a,   b)
        |
        |
        | 
       The instance that you created by calling the class A() 

Remarque: __init__ fonctionne pour les deux classique de classes et de nouvelles classes de style. Alors que, __new__ œuvres uniquement pour les nouveaux-classes de style.

OriginalL'auteur direprobs

Classes Python travail un peu différent de classes dans d'autres langues.
Par exemple, il n'y a pas privé les attributs en python. Juste des conventions de nommage pour dire qu'une méthode ou une variable de membre n'est pas prévu pour une utilisation publique (l'un des principaux _).

Alors que chaque classe doit avoir les attributs de __new__ et __init__, qui, ensemble, construire ce que d'autres langues pourrait appeler un constructeur, la base de classes python implémente ces méthodes. Vous n'avez pas à les ignorer, si vous n'avez pas besoin.

Ce qui est parfaitement correct:

class A:
   def hello(self):
        print('Hello, World')

a = A()
a.hello()

En python __new__(cls, ...) est d'abord utilisée pour créer une instance de classe de la demande de cls. Ensuite, l'instance nouvellement créée est passé à __init__(self, ...) comme self.

La __new__ et __init__ méthodes à la fois de recevoir les arguments que vous passez à la de la construction de l'expression. C'est de cette façon python appels m = MyClas(1, 2, 3).

class A:
    def __new__(cls, *args, **kwargs):
        print('In __new__')
        print(args)
        print(kwargs)
        return object.__new__(cls) # create a new object of type cls

    def __init__(self, *args, **kwargs):
        print('In __init__')
        print(args)
        print(kwargs)


a = A(1, 2, c=3)

Résultats dans:

In __new__
(1, 2)
{'c': 3}
In __init__
(1, 2)
{'c': 3}

OriginalL'auteur MaxNoe

Il n'est pas trop difficile à comprendre Python constructeurs de classe, mais assurez-vous un peu compliqué, surtout si l'on entend déjà certains la programmation orientée objet, aux termes d'autres langues que le soutien de la programmation orientée objet comme C++ ou Java.

But principal d'un constructeur de la classe est de créer des objets avec les instances personnalisé à un état initial. C'est très important de comprendre en Python parce que les données des attributs (variables membres) n'ont pas besoin d'être déclarés et leur ressort dans l'existence quand ils sont d'abord affectés à des. Donc, bon endroit pour le groupe de tous les attributs de données d'une instance est constructeur.

Tout attribut de données affectée à l'extérieur de toutes les fonctions d'une classe sont partagés par toutes les instances de la classe. Ici, Python est plus difficile, car il a mutable types de données et immuable types de données.

Par exemple, voir l'extrait de code suivant:

 
class Maclasse: 
i = 3 
arr = [] 

x = Maclasse() 
x.i = 4 
x.arr.append('x') 

y = Maclasse() 
y.i = 5 
y.arr.append('y') 

MyClass.arr.append('m') 

imprimer "{}, {}, {}".format(x.j', y.j', MyClass.j') 
imprimer "{}, {}, {}".format(x.arr, y.arr, MyClass.arr.) 

et la sortie sera:

 
4, 5, 3 
['x', 'y', 'm'], ['x', 'y', 'm'], ['x', 'y', 'm'] 

Depuis entier est immuable type de données en Python, chaque commande crée de nouvelles copie de l'entier de l'objet, cela pourrait être trompeur de certains programmeurs, car il semble que chaque instance possède sa propre copie privée de variable membre. Liste type de données est mutable, donc au-dessus extrait de code modifie même copie de la liste de toutes les instances.

Donc on n'a pas besoin d'écrire constructeur de la classe Python si tous les membres sont partagés par toutes les instances de la classe, sinon c'est une bonne pratique d'écrire un constructeur de groupe et toutes les données privées des membres à l'intérieur.

Dans l'extrait de code ci-dessus, si le programmeur voulait vraiment un membre de données privées, je pour des instances de classe, alors au lieu de s'appuyer sur immuable de la propriété de l'un devrait écrire un constructeur et initialiser une variable.

Modifié le code à utiliser constructeur:

 
class Maclasse: 
arr = [] 
def __init__(self, i): 
auto.i = i 


x = Maclasse(4) 
y = Maclasse(5) 
print "{}, {}".format(x.j', y.j') 

sortie sera:

 
4, 5 

Espère que ça aide un peu sur le dessus de connaissances utiles, qui a déjà été partagée par d'autres sur ce fil. Bonne chance.

OriginalL'auteur Kevin