Que font __init__ et soi sur Python?
J'apprends le langage de programmation Python et j'ai découvert quelque chose que je ne comprends pas bien.
Dans une méthode comme:
def method(self, blah):
def __init__(?):
....
....
Que fait self? Que veut-il être? Est-ce obligatoire?
Que fait la méthode __init__? Pourquoi est-ce nécessaire? (etc.)
Je pense qu’ils pourraient être OOP constructions, mais je ne sais pas grand chose.
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 transmettent cela en tant que paramètre masqué aux méthodes définies sur un objet; Python pas. Vous devez le déclarer explicitement. Lorsque vous créez une instance de la classe A et appelez ses méthodes, elle sera automatiquement passée, 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 à 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 comme premier paramètre à la méthode __init__. Tous les paramètres supplémentaires (par exemple, A(24, 'Hello')) seront également transmis en tant qu'arguments. Dans ce cas, une exception sera déclenchée, car le constructeur ne les attend pas.
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 souhaitez conserver la valeur avec cet 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 de la pile et seraient ignorés lorsque la méthode init serait hors de portée. Définir ces variables comme self._x et self._y définit ces variables comme membres de l’objet Point (accessible pendant la durée de vie de l’objet).
Un bref exemple illustratif
Dans l’espoir que cela puisse aider un peu, voici un exemple simple que j’avais utilisé pour comprendre la différence entre une variable déclarée dans une classe et une variable déclarée dans 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:
selfcomme il le suggère, fait référence à lui-même - l'objet qui a appelé la méthode. Autrement dit, si vous avez N objets appelant la méthode, alorsself.afera référence à une instance distincte de la variable pour chacun des N objets. Imaginez N copies de la variableapour 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éé.
__init__ agit comme un constructeur. Vous aurez besoin de 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.
Essayez ce code. J'espère que cela aide de nombreux 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
J'ai eu du mal à comprendre cela moi-même. Même après avoir lu les réponses ici.
Pour bien comprendre la méthode __init__, vous devez vous comprendre.
Le paramètre auto
Les arguments acceptés par la méthode __init__ sont les suivants:
def __init__(self, arg1, arg2):
Mais nous ne lui transmettons en réalité que 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, instance est une référence à notre nouvel objet. Nous accédons à la méthode printargs de l'objet d'instance à l'aide d'instance.printargs.
Pour accéder aux attributs d'objet depuis la méthode __init__, 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. By convention vous appelez toujours ce premier argument à vos méthodes auto.
Cela signifie que dans la méthode __init__, nous pouvons faire:
self.arg1 = arg1
self.arg2 = arg2
Nous définissons ici les attributs de l'objet. Vous pouvez le vérifier en procédant comme suit:
instance = OurClass('arg1', 'arg2')
print instance.arg1
arg1
de telles valeurs sont appelées attributs d'objet. La méthode __init__ définit ici les attributs arg1 et arg2 de l'instance.
source: http://www.voidspace.org.uk/python/articles/OOP.shtml#the-init-method
Les objets de classe prennent en charge deux types d'opérations: références d'attribut et instanciation
Les références d'attribut utilisent la syntaxe standard utilisée pour toutes les références d'attribut en Python: nom_objet. Les noms d'attributs valides sont tous les noms qui étaient dans l'espace de noms de la classe lorsque l'objet de classe a été créé. Donc, si la définition de la classe ressemblait à ceci:
class MyClass:
"""A simple example class"""
i = 12345
def f(self):
return 'hello world'
alors MyClass.i et MyClass.f sont des références d'attribut valides, renvoyant un entier et un objet fonction, respectivement. Les attributs de classe peuvent également être attribués. Vous pouvez donc modifier la valeur de MyClass.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. Supposons simplement que l'objet de classe est une fonction sans paramètre qui renvoie une nouvelle instance de la classe. Par exemple:
x = MyClass()
L'opération d'instanciation ("appel" d'un objet de classe) crée un objet vide. De nombreuses classes aiment créer des objets avec des instances personnalisées pour un état initial spécifique. Par conséquent, une classe peut définir une méthode spéciale nommée __init__(), comme ceci:
def __init__(self):
self.data = []
Lorsqu'une classe définit une méthode __init__(), l'instanciation de classe appelle automatiquement __init__() pour l'instance de classe nouvellement créée. Donc, 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 passés à __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 l’officiel documentation qui m’a le plus aidé au final.
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 :)")
Lorsque vous créez une instance de classe Bill:
purchase = Bill(5,6,7)
Vous obtenez:
> Buy 5 apples 6 figs and 7 dates. Total fruitty bill is 18 pieces of
> fruit :)
notez que self pourrait en réalité être n'importe quel identifiant valide python. Par exemple, nous pourrions tout aussi facilement é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 de la même façon. Il est toutefois recommandé d'utiliser self car d'autres pythoners le reconnaîtront plus facilement.
Fondamentalement, vous devez utiliser le mot clé 'self' lorsque vous utilisez une variable dans plusieurs fonctions de la même classe. Quant à init, il est utilisé pour définir les valeurs par défaut si aucune autre fonction de cette classe n’est appelée.
__init__est fondamentalement une fonction qui "initialise"/"active" les propriétés de la classe pour un objet spécifique, une fois créé et adapté à la classe correspondante.selfreprésente cet 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 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
f = foo()
foo.bar(f)
Fait intéressant, le nom de variable 'self' est juste une convention. La définition ci-dessous fonctionnera exactement de la même manière. Cela dit convention très stricte à suivre toujours, mais cela dit quelque chose à propos de la nature flexible du langage
class foo:
def bar(s):
print "hi"
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 __== '__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
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 en tant que constructeur pour 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 de ces déclarations sera le suivant:
I am a cat and I am called Kitty
# 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()
Qu'est-ce que self fait? Qu'est-ce que c'est destiné être? Est-ce obligatoire?
Le premier argument de chaque méthode de classe, y compris init, est toujours un 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 au nouvel objet 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 de votre choix. Mais rappelez-vous le premier argument d'une définition de méthode est une référence à l'objet . Python ajoute l'argument self à la liste pour vous; vous n'avez pas besoin de l'inclure lorsque vous appelez les méthodes. si vous ne fournissez pas l'auto dans la méthode init, vous obtiendrez une erreur
TypeError: __init___() takes no arguments (1 given)
Que fait la méthode init? Pourquoi est-ce nécessaire? (etc.)
init est l'abréviation d'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 habituellement, notre pratique est d'écrire la méthode init pour définir l'état par défaut de l'objet. Si vous ne souhaitez pas définir initialement un état de l'objet, vous n'avez pas besoin d'écrire cette méthode.
Python
__init__etselfque font-ils?Que fait
self? Que veut-il ê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é sur celui-ci:
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. C'est-à-dire que lorsque nous appelons SomeObject avec 'blah' ci-dessous (ce qui pourrait être n'importe quoi), il est transmis à la fonction __init__ en tant qu'argument, blah:
an_object = SomeObject('blah')
L'argument self est l'instance de SomeObject qui sera affectée à an_object.
Plus tard, nous voudrons peut-être appeler une méthode sur cet objet:
an_object.method()
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 passer explicitement le exemple à 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, exécute ensuite le code à exécuter.
L'argument implicitement passé self est appelé self par convention. Nous pourrions utiliser n'importe quel autre nom légal Python, mais d'autres programmeurs Python risquent de vous gâter si vous le changez.
__init__ est une méthode spéciale documentée dans la Python documentation du modèle de données . 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-classez un type de données immuable).
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 /
Lire le lien ci-dessus en référence à ceci:
self? Alors, quel est le paramètre auto pour toutes les méthodes du client? Qu'Est-ce que c'est? Pourquoi, c'est le cas, bien sûr! En d'autres termes, une méthode comme retirer définit les instructions pour retirer de l'argent d'un compte client abstrait. L'appel de jeff.withdraw (100.0) place ces instructions à utiliser dans l'instance de jeff.Ainsi, lorsque nous disons def retrait (self, amount), 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). jeff.withdraw (100.0) est simplement un raccourci pour Customer.withdraw (jeff, 100.0), ce qui est parfaitement valide (si ce n’est pas souvent le cas). code.
init self peut avoir un sens pour d'autres méthodes, mais qu'en est-il de init ? Lorsque nous appelons init , nous sommes en train de créer un objet. Comment peut-il déjà y avoir un self? Python nous permet d'étendre le motif auto au moment où les objets sont également construits, même s'il ne correspond pas exactement. Imaginez simplement que jeff = Customer ('Jeff Knupp', 1000.0) équivaut à appeler jeff = Customer (jeff, 'Jeff Knupp', 1000.0); le jeff qui est passé est également fait le résultat.
C'est pourquoi, lorsque nous appelons init , nous initialisons les objets en disant des choses comme self.name = name. Rappelez-vous, puisque self est l'instance, cela équivaut à dire jeff.name = name, ce qui est identique à jeff.name = 'Jeff Knupp. De même, self.balance = balance est identique à jeff.balance = 1000.0. Après ces deux lignes, nous considérons que l'objet Client est "initialisé" et prêt à être utilisé.
Faites attention à ce que vous
__init__Une fois que init est terminé, l'appelant peut supposer à juste titre que l'objet est prêt à être utilisé. C'est-à-dire qu'après que jeff = Customer ('Jeff Knupp', 1000.0), nous pouvons commencer à effectuer un dépôt et à retirer des appels sur jeff; Jeff est un objet entièrement initialisé.