dans ce code:

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

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

... la variable self représente l'instance de l'objet lui-même. La plupart des langages orientés objet passent ceci 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 la classe A et appelez ses méthodes, elle sera passée 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

la méthode __init__ est grossièrement ce qui représente un constructeur en Python. Lorsque vous appelez A() Python crée un objet pour vous, et le passe comme premier paramètre à la méthode __init__ . Tous les paramètres supplémentaires (par exemple, A(24, 'Hello') ) seront également passés en argument--dans ce cas, provoquant une exception à être soulevée, puisque le constructeur ne s'y attend pas.

Ouais, vous avez raison, ce sont de la programmation orientée objet construit.

__init__ est le constructeur d'une classe. Le paramètre self 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

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

x = Point(1,2)

il est important d'utiliser le paramètre self dans la méthode d'un objet si vous voulez persister la valeur à 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 seraient stockés dans des variables sur la pile et seraient rejetés lorsque la méthode init sort de la portée. Définir ces variables comme self._x et self._y définit ces variables comme des membres de l'objet Point (accessible pour la durée de vie de l'objet).

Un bref exemple

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 fonction __init__ :

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

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

en bref:

1. self comme il 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 fera référence à une instance séparée 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 langues OOP telles que C++/Java. L'idée de base est qu'il s'agit d'une méthode spéciale qui est automatiquement appelée lorsqu'un objet de cette classe est créé

__init__ agit comme un constructeur. Vous aurez besoin de passer "self" à n'importe quelles fonctions de classe comme premier argument si vous voulez qu'elles se comportent comme des méthodes non-statiques. "self" sont des variables d'instance pour votre classe.

essayez ce code. J'espère que ça aidera beaucoup de programmeurs C comme moi à apprendre le 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

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

pour bien comprendre la méthode __init__ vous devez comprendre vous-même.

L'auto Paramètre

les arguments acceptés par la méthode __init__ sont:

def __init__(self, arg1, arg2):

mais nous ne lui donnons que deux arguments:

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

Où est l'argument supplémentaire vient ?

lorsque nous accédons aux attributs d'un objet, nous le faisons par son nom (ou par référence). Voici 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'un objet dans la __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é comme premier argument. par convention vous appelez toujours ce premier argument à vos méthodes self.

cela signifie que dans la méthode __init__ nous pouvons faire:

self.arg1 = arg1
self.arg2 = arg2

ici, nous définissons les attributs sur l'objet. vous pouvez vérifier cela en faisant ce qui suit :

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

les valeurs comme celles-ci sont connues sous le nom d'objet attribut. ici, la méthode __init__ définit les attributs arg1 et arg2 de l'instance.

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

notez que self pourrait en fait ê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 ça marcherait exactement pareil. Il est cependant recommandé d'utiliser self car d'autres pythoners le reconnaîtront plus facilement.

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 spéciale qui vous ne pouvez pas attribuer à un objet, et __init__ est une fonction qui est appelée pour initialiser l'objet - qui est, définissez les valeurs des variables etc. - juste après que la mémoire est allouée pour elle.

fondamentalement, vous devez utiliser le mot-clé "self" lorsque vous utilisez une variable dans plusieurs fonctions au sein de la même classe. Comme pour init , il est utilisé pour configurer les valeurs par défaut incase aucune autre fonction de cette classe ne sont appelées.

1. __init__ est fondamentalement une fonction qui va "initialiser" / "activer" les propriétés de la classe d'un objet spécifique, une fois créé et adapté à la classe correspondante..
2. self représente l'objet qui héritera de ces propriétés.

Le "self" est une référence à l'instance de la classe

class foo:
    def bar(self):
            print "hi"

maintenant nous pouvons créer une instance de foo et appeler la méthode dessus, le paramètre self est ajouté par Python dans ce cas:

f = foo()
f.bar()

mais il peut être passé aussi bien si l'appel de méthode n'est pas dans le contexte d'une instance de la classe, le code ci-dessous fait la même chose

f = foo()
foo.bar(f)

il est intéressant de noter que le nom de la variable "self" n'est Convention. La définition ci-dessous fonctionnera exactement de la même façon.. Après avoir dit que c'est convention très forte qui devrait être suivi toujours , mais il dit quelque chose sur la nature flexible de la langue

class foo:
    def bar(s):
            print "hi"

Classe d'objets prennent en charge deux types d'opérations: attribut de références et d'instanciation

attribut references utilisez la syntaxe standard utilisée pour toutes les références d'attribut en Python: obj.nom. Les noms d'attribut valides sont tous les noms qui se trouvaient dans l'espace de noms de la classe lorsque l'objet de classe a été créé. Ainsi, si la définition de la classe ressemblait à ça:

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

puis MyClass.i et MyClass.f sont des références d'attribut valides, renvoyant respectivement un entier et un objet de fonction. Les attributs de classe peuvent aussi être assignés, de sorte que vous pouvez changer la valeur de MyClass.i par assignation. __doc__ est aussi un attribut valide, renvoyant le docstring appartenant à la classe:"A simple example class".

de l'instanciation de Classe utilise notation de fonction. Il suffit de prétendre que l'objet de classe est une fonction sans paramètre qui renvoie une nouvelle instance de la classe. Par exemple:

x = MyClass()

le instantiation opération ("calling" a class object) crée un objet vide. Beaucoup de classes aiment créer des objets avec des instances personnalisées à un état initial spécifique. Par conséquent, une classe peut définir une méthode spéciale appelée __init__() , comme ceci:

def __init__(self):
    self.data = []

Lorsqu'une classe définit une méthode __init__() , l'instanciation de classe invoque automatiquement __init__() pour l'instance de classe nouvellement créée. Ainsi, dans cet exemple, une nouvelle instance initialisée peut être obtenue par:

x = MyClass()

bien sûr, la méthode __init__() peut avoir des arguments pour une plus grande flexibilité. Dans ce cas, les arguments donnés à l'opérateur d'instanciation de classe sont transmis à __init__() . Par exemple,

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart

x = Complex(3.0, -4.5)
x.r, x.i

tiré de documentation qui m'a le plus aidé à la fin.

Voici mon exemple

class Bill():
    def __init__(self,apples,figs,dates):
        self.apples = apples
        self.figs = figs
        self.dates = dates
        self.bill = apples + figs + dates
        print ("Buy",self.apples,"apples", self.figs,"figs 
                and",self.dates,"dates. 
                Total fruitty bill is",self.bill," pieces of fruit :)")

quand vous créez l'instance de Bill de classe:

purchase = Bill(5,6,7)

, Vous obtenez:

> Buy 5 apples 6 figs and 7 dates. Total fruitty bill is 18  pieces of
> fruit :)

# Source: Class and Instance Variables
# https://docs.python.org/2/tutorial/classes.html#class-and-instance-variables

class MyClass(object):
    # class variable
    my_CLS_var = 10

    # sets "init'ial" state to objects/instances, use self argument
    def __init__(self):
        # self usage => instance variable (per object)
        self.my_OBJ_var = 15

        # also possible, class name is used => init class variable
        MyClass.my_CLS_var = 20


def run_example_func():
    # PRINTS    10    (class variable)
    print MyClass.my_CLS_var

    # executes __init__ for obj1 instance
    # NOTE: __init__ changes class variable above
    obj1 = MyClass()

    # PRINTS    15    (instance variable)
    print obj1.my_OBJ_var

    # PRINTS    20    (class variable, changed value)
    print MyClass.my_CLS_var


run_example_func()

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 de la classe et lorsqu'un objet est instancié, cette fonction est appelée. self représente l'objet instanciant.

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

le résultat des énoncés ci-dessus sera le suivant:

I am a cat and I am called Kitty

Python __init__ et self que font-ils?

Que fait self ? Qu'est-ce que cela veut dire? Est-il obligatoire?

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

L'exemple donné n'est pas correct, alors permettez-moi de créer un bon exemple:

class SomeObject(object):

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

    def method(self):
        return self.blah 

quand nous créons une instance du l'objet, le __init__ est appelé à personnaliser l'objet après qu'il a été créé. C'est-à-dire, quand nous appelons SomeObject avec 'blah' ci-dessous (qui pourrait être n'importe quoi), il passe à la fonction __init__ comme argument, blah :

an_object = SomeObject('blah')

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

plus Tard, nous pourrions appeler une méthode sur cet objet:

an_object.method()

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

l'appel de méthode reçoit l'instance parce qu'elle était liée sur la recherche pointillée, et quand elle est appelée, elle exécute le code pour lequel elle a été programmée.

le implicitement passé self argument est appelé self par convention. Nous pourrions utiliser n'importe quel autre nom Python légal, mais vous serez probablement tarré et plumé par d'autres programmeurs Python Si vous le changez en quelque chose d'autre.

__init__ est une méthode spéciale, documentée dans la documentation de datamodel de Python . Il est appelé immédiatement après la création de l'instance (habituellement via __new__ - bien que __new__ ne soit pas requis à moins que vous ne soyez sous-classe un type de données immuable).

ici, le gars a écrit assez bien et simple: https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming /

lire le lien ci-dessus comme référence à ceci:

self ? Donc, qu'est-ce que l'auto paramètre pour tous les Clients méthodes? Quel est-il? Pourquoi, c'est l'exemple, bien sûr! Mettez-en un autre une méthode comme withdraw définit la instructions de retrait de l'argent provenant d'un compte abstrait d'un client. Appel Jeff.retirer (100.0) met ces instructions à utiliser sur le jeff instance.

donc quand nous disons Def retirer (soi, montant):, nous disons, "voici comment vous retirez de l'argent d'un objet client (que nous appellerons Auto) et un montant en dollars (que nous appellerons montant). le soi est l'instance du Le client qui se désiste est appelé. C'est pas à moi de faire des les analogies. Jeff.retirer(100.0) est juste un raccourci pour Client.retirer(jeff, 100.0), ce qui est parfaitement valide (si pas souvent vu le code.

init auto peut faire sens pour d'autres méthodes, mais que dire de init ? Quand nous appelons init , nous sommes en train de créer un objet, alors comment peut-il déjà y avoir un soi? Python nous permet d'étendre l'auto motif lorsque les objets sont construits ainsi, quoique il n'est pas exactement la forme. Imaginez que jeff = client ('Jeff Knupp', 1000.0) est la même chose que d'appeler jeff = client (jeff, ' Jeff Knupp', 1000.0); le jeff qui est passée est également fait le résultat.

c'est pourquoi lorsque nous appelons init , nous initialisons les objets en disant des choses comme moi.nom = nom. Rappelez-vous, puisque le soi est l'instance, c'est équivalent à dire jeff.nom = nom, qui est le même que jeff.nom = ' Jeff Knupp. De même, l'auto.solde = solde est le même comme jeff.solde = 1000.0. Après ces deux lignes, nous considérons l' Objet client "initialisé" et prêt à l'emploi.

faites attention à ce que vous __init__

après init a terminé, l'appelant peut à juste titre supposer que le l'objet est prêt à être utilisé. C'est-à-dire, après jeff = client ("Jeff Knupp", 1000.0), nous pouvons commencer à faire de dépôt et retirer appelle jeff, jeff est un objet initialisé.

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

Quoi auto ? Qu'est-ce que signifie être? Est-ce que c'est obligatoire ?

le premier argument de chaque méthode de classe, y compris init, est toujours un référence à l'instance courante du clas S. Par convention, cet argument est toujours appelé self.Dans la méthode init, self se réfère à l'objet nouvellement créé; dans d'autres méthodes de classe, il se réfère à l'instance dont la méthode a été appelée.

Python ne vous force pas sur l'utilisation de " auto ". Vous pouvez lui donner n'importe quel nom que vous voulez. Mais rappelez-vous que le premier argument dans une définition de méthode est une référence à l'objet.Python ajoute l'auto argument de la liste pour vous; vous n'avez pas besoin de l'inclure lorsque vous appelez les méthodes. si vous n'avez pas fourni vous-même dans la méthode init, alors vous obtiendrez une erreur

TypeError: __init___() takes no arguments (1 given)

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

INIT abréviation de l'initialisation. Il est un constructeur qui quand vous faites instance de la classe et de il n'est pas nécessaire . Mais habituellement c'est notre pratique d'écrire la méthode init pour définir l'état par défaut de l'objet. Si vous n'êtes pas prêt à définir n'importe quel état de l'objet initialement, alors vous n'avez pas besoin d'écrire ceci méthode.