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 objet transmettent cela comme un paramètre caché aux méthodes définies sur un objet; Python ne fonctionne pas. Vous devez le déclarer explicitement. Lorsque vous créez une instance de la A
classe et appelez ses méthodes, elle sera transmise 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 __init__
méthode est à peu près ce qui représente un constructeur en Python. Lorsque vous appelez A()
Python, crée un objet pour vous et le transmet en tant que premier paramètre à la __init__
méthode. Tous les paramètres supplémentaires (par exemple, A(24, 'Hello')
) seront également passés en tant qu'arguments - dans ce cas, provoquant une exception, car le constructeur ne les attend pas.
x = 'Hello'
dehors init mais à l'intérieur de la classe? est-ce comme java où c'est pareil, ou devient-il comme une variable statique qui n'est initialisée qu'une seule fois?A.x
oua.x
. Notez que le remplacer sur une classe spécifique n'affectera pas la base, doncA.x = 'foo'; a.x = 'bar'; print a.x; print A.x
imprimerabar
alorsfoo
self
, c'est simplement par convention.object
déclaration de classe? J'ai remarqué que certaines classes en ont et d'autres nonobject
car cela se produit par défaut.Oui, vous avez raison, ce sont des constructions oop.
__init__
est le constructeur d'une classe. Leself
paramètre fait référence à l'instance de l'objet (commethis
en C ++).La
__init__
méthode est appelée lorsque la mémoire de l'objet est allouée:Il est important d'utiliser le
self
paramètre à l'intérieur de la méthode d'un objet si vous souhaitez conserver la valeur avec l'objet. Si, par exemple, vous implémentez la__init__
méthode comme ceci:Vos paramètres
x
ety
seraient stockés dans des variables sur la pile et seraient ignorés lorsque la méthode init sortira du cadre. Définir ces variables en tant queself._x
etself._y
définit ces variables en tant que membres de l'Point
objet (accessible pendant la durée de vie de l'objet).la source
self
pas être dans le constructeur? Pourquoi devez-vous même le préciser, ne serait-il pas préférable que ce soit implicite?Un bref exemple illustratif
Dans l'espoir que cela puisse 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
__init__
fonction:Production:
la source
__init__
est ce qui est transmis aux instances de la classe, pas la variable «statique» de la classe elle-même qui porte le même nom ...En bref:
self
comme il le suggère, se réfère à lui - même - l'objet qui a appelé la méthode. Autrement dit, si vous avez N objets appelant la méthode, alorsself.a
fera référence à une instance distincte de la variable pour chacun des N objets. Imaginez N copies de la variablea
pour chaque objet__init__
est ce qu'on appelle en tant que constructeur dans d'autres langages OOP tels 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ééla source
__init__
agit comme un constructeur. Vous devrez passer "self" à toutes les 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.la source
Essayez ce code. J'espère que cela aide de nombreux programmeurs C comme moi à apprendre Py.
Production:
Jay
Sum = 5
Doc - Inside Class
Doc - __init__ Constructor
Doc - Inside Show
Destructor Deleting object - Jay
la source
Les objets de classe prennent en charge deux types d'opérations: les références d'attribut et l'instanciation
Les références d'attribut utilisent la syntaxe standard utilisée pour toutes les références d'attribut dans Python: obj.name. 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éé. Donc, si la définition de classe ressemblait à ceci:
alors
MyClass.i
etMyClass.f
sont des références d'attribut valides, renvoyant respectivement un entier et un objet fonction. Les attributs de classe peuvent également être affectés à, vous pouvez donc modifier la valeur deMyClass.i
par affectation.__doc__
est également un attribut valide, renvoyant la docstring appartenant à la classe: "Un exemple de classe simple".L'instanciation de classe utilise la notation de fonction. Imaginez simplement que l'objet classe est une fonction sans paramètre qui renvoie une nouvelle instance de la classe. Par exemple:
L' opération d' instanciation («appeler» un objet de classe) crée un objet vide. De nombreuses 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 nommée
__init__()
, comme ceci:Lorsqu'une classe définit une
__init__()
méthode, l'instanciation de classe appelle automatiquement__init__()
pour l'instance de classe nouvellement créée. Ainsi, dans cet exemple, une nouvelle instance initialisée peut être obtenue par:Bien sûr, la
__init__()
méthode 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,Tiré de la documentation officielle qui m'a le plus aidé au final.
Voici mon exemple
Lorsque vous créez une instance de classe Bill:
Vous obtenez:
la source
J'ai eu du mal à comprendre cela moi-même. Même après avoir lu les réponses ici.
Pour bien comprendre la
__init__
méthode, vous devez vous comprendre.Le paramètre auto
Les arguments acceptés par la
__init__
méthode sont:Mais nous ne lui transmettons en fait que deux arguments:
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 à l'aide de instance.printargs.
Afin d'accéder aux attributs d'objet à partir de 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 transmise comme premier argument. Par convention, vous appelez toujours ce premier argument à vos méthodes.
Cela signifie que dans la
__init__
méthode que nous pouvons faire:Ici, nous définissons des attributs sur l'objet. Vous pouvez le vérifier en procédant comme suit:
des valeurs comme celle-ci sont appelées attributs d'objet. Ici, la
__init__
méthode définit les attributs arg1 et arg2 de l'instance.source: http://www.voidspace.org.uk/python/articles/OOP.shtml#the-init-method
la source
notez que cela
self
pourrait en fait être n'importe quel identifiant python valide. Par exemple, nous pourrions tout aussi facilement écrire, à partir de l'exemple de Chris B:et cela fonctionnerait exactement de la même manière. Il est cependant recommandé d'utiliser self car les autres pythoners le reconnaîtront plus facilement.
la source
Fondamentalement, vous devez utiliser le mot-clé «self» lorsque vous utilisez une variable dans plusieurs fonctions au sein de la même classe. Quant à init , il est utilisé pour configurer les valeurs par défaut car aucune autre fonction de cette classe n'est appelée.
la source
__init__
est fondamentalement une fonction qui "initialisera" / "activera" les propriétés de la classe pour un objet spécifique, une fois créée et mise en correspondance avec la classe correspondante.self
représente cet objet qui héritera de ces propriétés.la source
Le 'self' est une référence à l'instance de classe
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:
Mais il peut aussi être passé 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
Fait intéressant, le nom de variable «self» n'est qu'une convention. La définition ci-dessous fonctionnera exactement de la même manière. Cela dit, il s'agit d' une convention très forte qui doit toujours être suivie , mais elle dit quelque chose sur la nature flexible du langage.
la source
s
) montrait la flexibilité de python.Juste une démo pour la question.
la source
Dans ce code:
Ici, il
__init__
agit comme un constructeur pour la classe et lorsqu'un objet est instancié, cette fonction est appelée.self
représente l'objet instanciant.Le résultat des déclarations ci-dessus sera le suivant:
la source
Le premier argument de chaque méthode de classe, y compris init, est toujours une référence à l'instance actuelle de la classe . Par convention, cet argument est toujours nommé
self
. Dans la méthode init,self
fait référence à l'objet nouvellement créé; dans d'autres méthodes de classe, il fait référence à l'instance dont la méthode a été appelée.Python ne vous oblige pas à utiliser " self ". Vous pouvez lui donner le nom que vous voulez. Mais rappelez - vous que le premier argument d'une définition de méthode est une référence à l'objet . Python ajoute l'
self
argument à la liste pour vous; vous n'avez pas besoin de l'inclure lorsque vous appelez les méthodes. si vous n'avez pas fourni la méthode self in init, vous obtiendrez une erreurinit
est l'abréviation de l'initialisation. C'est un constructeur qui est appelé lorsque vous créez une instance de la classe et ce n'est pas nécessaire . Mais généralement, il est de 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 un état de l'objet au départ, vous n'avez pas besoin d'écrire cette méthode.la source
la source
L'exemple donné n'est pas correct, alors laissez-moi créer un exemple correct basé sur lui:
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 l' on appelleSomeObject
avec'blah'
ci - dessous (qui pourrait être quelque chose), il est transmis à la__init__
fonction de l'argument,blah
:L'
self
argument est l'instanceSomeObject
qui sera affectée àan_object
.Plus tard, nous pourrions vouloir appeler une méthode sur cet objet:
Faire la recherche en pointillés, 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 transmettre explicitement l'instance à l'appel de méthode .L'appel de méthode obtient l'instance car elle était liée à la recherche en pointillé, et lorsqu'elle est appelée, elle exécute le code qu'elle a été programmée pour exécuter.
L'
self
argument implicitement passé est appeléself
par convention. Nous pourrions utiliser tout autre nom Python légal, mais vous serez probablement goudronné et plumé par d'autres programmeurs Python si vous le changez pour autre chose.__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 cela__new__
ne soit pas obligatoire sauf si vous sous-classez un type de données immuable).la source
Ici, le gars a écrit assez bien et simplement: https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/
Lisez le lien ci-dessus comme référence à ceci:
la source