Python __init__ et moi-même que font-ils?


Answers

Oui, vous avez raison, ce sont des constructions oop.

__init__ est le constructeur d'une classe. Le paramètre self fait référence à l'instance de l'objet (comme this en C ++).

class Point:
    def __init__(self, x, y):
        self._x = x
        self._y = y

La méthode __init__ est appelée lorsque la mémoire de l'objet est allouée:

x = Point(1,2)

Il est important d'utiliser le paramètre self dans la méthode d'un objet si vous voulez conserver la valeur avec l'objet. Si, par exemple, vous implémentez la méthode __init__ comme ceci:

class Point:
    def __init__(self, x, y):
        _x = x
        _y = y

Vos paramètres x et y seront stockés dans des variables de la pile et seront supprimés lorsque la méthode init est hors de portée. La définition de ces variables sous self._x et self._y définit ces variables en tant que membres de l'objet Point (accessible pour la durée de vie de l'objet).

Question

J'apprends le langage de programmation Python et je suis tombé sur quelque chose que je ne comprends pas complètement.

Dans une méthode comme:

def method(self, blah):
    def __init__(?):
        ....
    ....

Que fait le self ? Qu'est-ce que ça veut dire être? Est-ce obligatoire?

Que fait la méthode __init__ ? Pourquoi est-ce nécessaire? (etc.)

Je pense qu'ils pourraient être construits OOP, mais je ne sais pas beaucoup.




En bref:

  1. self comme il le suggère, se réfère à lui - même - l'objet qui a appelé la méthode. C'est-à-dire, si vous avez N objets appelant la méthode, alors self.a se référera à une instance distincte de la variable pour chacun des N objets. Imaginez N copies de la variable a pour chaque objet
  2. __init__ est ce qu'on appelle un constructeur dans d'autres langages OOP tels que C ++ / Java. L'idée de base est que c'est une méthode spéciale qui est automatiquement appelée quand un objet de cette classe est créé



Python __init__ et self - self que font-ils?

Que fait le self ? Qu'est-ce que ça veut dire être? Est-ce obligatoire?

Que fait la méthode __init__ ? Pourquoi est-ce nécessaire? (etc.)

L'exemple donné n'est pas correct, alors laissez-moi créer un exemple correct basé dessus:

class SomeObject(object):

    def __init__(self, blah):
        self.blah = blah

    def method(self):
        return self.blah 

Lorsque nous créons une instance de l'objet, le __init__ est appelé pour personnaliser l'objet après sa création. Autrement dit, lorsque nous appelons SomeObject avec 'blah' ci-dessous (ce qui pourrait être n'importe quoi), il est passé à la fonction __init__ comme argument, blah :

an_object = SomeObject('blah')

L'argument self est l'instance de SomeObject qui sera assignée à un an_object .

Plus tard, nous pourrions vouloir appeler une méthode sur cet objet:

an_object.method()

Faire la recherche pointée, c'est-à-dire, an_object.method , lie l'instance à une instance de la fonction, et la méthode (appelée ci-dessus) est maintenant une méthode "bound" - ce qui signifie que nous n'avons pas besoin de passer l'appel de méthode.

L'appel de méthode obtient l'instance car il était lié à la recherche pointée, et lorsqu'il est appelé, il exécute tout code qu'il a été programmé pour effectuer.

L'argument self implicitement passé est appelé self by convention. Nous pourrions utiliser n'importe quel autre nom Python légal, mais d'autres programmeurs Python vous donneront probablement des goudrons et des plumes si vous le changez en quelque chose d'autre.

__init__ est une méthode spéciale, documentée dans la documentation du modèle de données Python . Il est appelé immédiatement après la création de l'instance (généralement via __new__ - bien que __new__ ne soit pas nécessaire sauf si vous sous- __new__ un type de données immuable).




Vous auriez raison, ce sont des constructions orientées objet. Fondamentalement self est une référence (un peu comme un pointeur, mais self est une référence particulière que vous ne pouvez pas assigner) à un objet, et __init__ est une fonction qui est appelée pour initialiser l'objet - c'est-à-dire, définir les valeurs de variables etc. - juste après que la mémoire soit allouée pour cela.




  1. __init__ est fondamentalement une fonction qui va "initialiser" / "activer" les propriétés de la classe pour un objet spécifique, une fois créé et mis en correspondance avec la classe correspondante.
  2. self représente cet objet qui héritera de ces propriétés.



Dans ce code:

class Cat:
    def __init__(self, name):
        self.name = name
    def info(self):
        print 'I am a cat and I am called', self.name

Ici __init__ agit comme un constructeur pour la classe et quand un objet est instancié, cette fonction est appelée. self représente l'objet instanciant.

c = Cat('Kitty')
c.info()

Le résultat des déclarations ci-dessus sera le suivant:

I am a cat and I am called Kitty



Essayez ce code. J'espère que cela aidera beaucoup de programmeurs C comme moi à apprendre Py.

#! /usr/bin/python2

class Person:

    '''Doc - Inside Class '''

    def __init__(self, name):
        '''Doc - __init__ Constructor'''
        self.n_name = name        

    def show(self, n1, n2):
        '''Doc - Inside Show'''
        print self.n_name
        print 'Sum = ', (n1 + n2)

    def __del__(self):
        print 'Destructor Deleting object - ', self.n_name

p=Person('Jay')
p.show(2, 3)
print p.__doc__
print p.__init__.__doc__
print p.show.__doc__

Sortie:

Jay

Sum = 5

Doc - Inside Class

Doc - __init__ Constructor

Doc - Inside Show

Destructor Deleting object - Jay




Juste une démo pour la question.

class MyClass:

    def __init__(self):
        print('__init__ is the constructor for a class')

    def __del__(self):
        print('__del__ is the destructor for a class')

    def __enter__(self):
        print('__enter__ is for context manager')
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print('__exit__ is for context manager')

    def greeting(self):
        print('hello python')


if __name__ == '__main__':
    with MyClass() as mycls:
        mycls.greeting()
$ python3 class.objects_instantiation.py
__init__ is the constructor for a class
__enter__ is for context manager
hello python
__exit__ is for context manager
__del__ is the destructor for a class



Notez que self peut être n'importe quel identifiant python valide. Par exemple, nous pourrions tout aussi bien écrire, à partir de l'exemple de Chris B:

class A(object):
    def __init__(foo):
        foo.x = 'Hello'

    def method_a(bar, foo):
        print bar.x + ' ' + foo

et cela fonctionnerait exactement la même chose. Il est cependant recommandé d'utiliser self car d'autres pythoners le reconnaîtront plus facilement.