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


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__(?):
        ....
    ....

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

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

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


571
2018-03-09 05:09


origine


Réponses:


Dans ce code:

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

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

... la self variable représente l'instance de l'objet lui-même. La plupart des langages orientés objets le transmettent comme un paramètre caché aux méthodes définies sur un objet; Python ne le fait pas. Vous devez le déclarer explicitement. Lorsque vous créez une instance de A class et appelle ses méthodes, il sera passé automatiquement, comme dans ...

a = A()               # We do not pass any argument to the __init__ method
a.method_a('Sailor!') # We only pass a single argument

le __init__ méthode est à peu près ce qui représente un constructeur en Python. Quand vous appelez A() Python crée un objet pour vous et le transmet comme premier paramètre au __init__ méthode. Tout paramètre supplémentaire (par exemple, A(24, 'Hello')) sera également passé en argument - dans ce cas, une exception sera levée, puisque le constructeur ne les attend pas.


461
2018-03-09 05:18



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

__init__ est le constructeur pour une classe. le self paramètre se réfère à l'instance de l'objet (comme this en C ++).

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

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

x = Point(1,2)

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

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

Votre x et y les paramètres seraient stockés dans des variables de la pile et seraient supprimés lorsque la méthode init est hors de portée. Définir ces variables comme self._x et self._y définit ces variables en tant que membres du Point objet (accessible pour la durée de vie de l'objet).


184
2018-03-09 05:18



Un bref exemple illustratif

Dans l'espoir que cela pourrait aider un peu, voici un exemple simple que j'ai utilisé pour comprendre la différence entre une variable déclarée à l'intérieur d'une classe, et une variable déclarée à l'intérieur d'une classe. __init__ fonction:

class MyClass(object):
     i = 123
     def __init__(self):
         self.i = 345

a = MyClass()
print a.i
345
print MyClass.i
123

137
2018-06-23 12:15



En bref:

  1. self comme il le suggère, fait référence à se- l'objet qui a appelé la méthode. Autrement dit, 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 un spécial méthode qui est appelée automatiquement lorsqu'un objet de cette classe est créé

36
2018-03-09 05:41



__init__ agit comme un constructeur. Vous devrez passer "self" à n'importe quelle fonction de classe comme premier argument si vous voulez qu'ils se comportent comme des méthodes non statiques. "self" sont des variables d'instance pour votre classe.


24
2018-03-09 05:18



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


20
2018-05-10 03:03



Avait du mal à le dénouer moi-même. Même après avoir lu les réponses ici.

Pour bien comprendre le __init__ méthode que vous devez comprendre soi-même.

L'auto-paramètre

Les arguments acceptés par le __init__ méthode sont:

def __init__(self, arg1, arg2):

Mais nous ne faisons que passer deux arguments:

instance = OurClass('arg1', 'arg2')

D'où vient l'argument supplémentaire?

Lorsque nous accédons aux attributs d'un objet, nous le faisons par nom (ou par référence). Ici, l'instance est une référence à notre nouvel objet. Nous accédons à la méthode printargs de l'objet instance en utilisant instance.printargs.

Pour accéder aux attributs d'objet depuis l'intérieur __init__ méthode, nous avons besoin d'une référence à l'objet.

Chaque fois qu'une méthode est appelée, une référence à l'objet principal est passée en premier argument. Par convention, vous appelez toujours ce premier argument à vos propres méthodes.

Cela signifie dans le __init__ méthode que nous pouvons faire:

self.arg1 = arg1
self.arg2 = arg2

Ici, nous définissons des attributs sur l'objet. Vous pouvez vérifier cela en procédant comme suit:

instance = OurClass('arg1', 'arg2')
print instance.arg1
arg1

De telles valeurs sont appelées attributs d'objet. Ici le __init__ method définit les attributs arg1 et arg2 de l'instance.

la source: http://www.voidspace.org.uk/python/articles/OOP.shtml#the-init-method


19
2018-01-09 22:39