questions de débutant concernant les classes Python

Question

Je suis nouveau à Python donc s'il vous plaît ne me flamme pas si je demande quelque chose de trop noobish :)

1.

Tenir compte J'ai une classe:

class Test: 
    def __init__(self, x, y): 
     self.x = x 
     self.y = y 
    def wow(): 
     print 5 * 5 

maintenant, j'essaie de créer un objet de la classe:

x = Test(3, 4) 

Cela fonctionne comme prévu. Cependant, lorsque je tente d'appeler la méthode wow(), il renvoie une erreur, qui est fixée en changeant wow() à:

def wow(self) 

Pourquoi ai-je besoin d'inclure self et si je fais ce pas, la méthode signifie-t-elle?

2. Dans la définition de __init__:

def __init__(self, x, y): 
    self.x = x 
    self.y = y 

Pourquoi dois-je déclarer x et y, quand je peux le faire:

def __init__(self): 
    self.x = x 
    self.y = y 

J'espère que je suis être clair ...

Merci pour votre temps.

Answer 1

La référence d'instance dans Python est explicite. De cette façon, il peut être manipulé par ex. décorateurs avant d'être finalement passé à la méthode.

Nous devons déclarer x et y comme arguments de la fonction afin que nous puissions utiliser leurs noms dans la fonction, liés aux arguments passés dans l'appel de fonction correspondant.

Answer 2

1. En Python, les méthodes doivent toujours prendre « un supplémentaire » argument, qui est la référence à l'instance la méthode est appelée. C'est automatique dans d'autres langages tels que Java, C#, etc. mais Python est bavard à ce sujet.

2. Cela n'a aucun sens. Où sont x et y dans cet exemple? Si vous voulez que le constructeur prenne deux arguments qui peuplent l'objet, définissez-le comme tel. Sinon, vous faites autre chose.

Answer 3

Python est différent des langages comme C++ et Java en ce sens que la référence d'instance d'objet est explicitement transmise. Autrement dit, si vous avez un objet qui est une instance de la classe et que vous voulez appeler une méthode qui fonctionne sur cette instance (par exemple, lit ses champs), vous utilisez les auto-références en tant qu'objet.

En C++ et Java, vous avez une référence implicite "this" qui est présente dans la version compilée de votre programme mais pas dans le code source. Vous utilisez le mot-clé static pour le transformer en une méthode de classe qui n'a pas de "this".

Answer 4

Pour être clair

Pourquoi dois-je déclarer x et y, quand je peux le faire:

def __init__(self): 
    self.x = x 
    self.y = y 

Ce^ne fonctionnera que si x et y peuvent être trouvé à l'exécution - s'ils n'ont pas été transmis, ils doivent avoir été définis ailleurs (globalement) ou générer une erreur.

>>> class c: 
    def __init__(self): 
     self.x = x 

>>> x = 1 
>>> q = c() 
>>> q.x 
1 
>>> del x 
>>> q.x 
1 
>>> w = c() 

Traceback (most recent call last): 
    File "<pyshell#24>", line 1, in <module> 
    w = c() 
    File "<pyshell#14>", line 3, in __init__ 
    self.x = x 
NameError: global name 'x' is not defined 
>>> 
>>> w = c(2) 

Traceback (most recent call last): 
    File "<pyshell#19>", line 1, in <module> 
    w = c(2) 
TypeError: __init__() takes exactly 1 argument (2 given) 

Ceci est la raison pour laquelle vous voulez/besoin de les spécifier comme paramètres - il pourrait travailler avec la recherche mondiale, mais cela violerait probablement le « principle of least astonishment »

Answer 5

Si vous le faites:

def __init__(self): 
    self.x = x 
    self.y = y 

vous attribuez la Gobal vars x et y (ce qu'ils existent) à votre instance

avec:

def __init__(self, x, y): 
     self.x = x 
     self.y = y 

vous attribuez ce que vous donnez comme paramètre au constructeur

et qui est beaucoup plus souple :-)

Answer 6

auto est un nom « magique » - il peut vraiment être quelque chose, mais l'auto est utilisé pour la cohérence et la clarté. Pour répondre à votre question, chaque méthode/fonction de classe nécessite une référence explicite à la classe en tant que premier paramètre. En utilisant Ipython:

In [66]: class Test: 
    ....:  def __init__(self): 
    ....:   pass 
    ....:  def wow(self): 
    ....:   print self 
    ....: 
    ....: 

In [67]: x = Test() 

In [68]: x.wow() 
<__main__.Test instance at 0x0159FDF0> 

Votre deuxième exemple ne fonctionnera pas à moins que vous avez en fait déjà un x et y dans votre espace de noms.

Par exemple, si vous avez défini votre classe:

class Test: 
    def __init__(self): 
     self.x = x 
     self.y = y 

et essayé

x = Test() 

il lancera une NameError.

Toutefois, si vous écrivez:

x = 3 
y = 4 
test = Test() 

il fonctionnera. Cependant, ce n'est pas une bonne idée de faire une telle chose. Pour la raison pourquoi lire la ligne 2:

In [72]: import this 
The Zen of Python, by Tim Peters 

Beautiful is better than ugly. 
Explicit is better than implicit. 
Simple is better than complex. 
Complex is better than complicated. 
Flat is better than nested. 
Sparse is better than dense. 
Readability counts. 
Special cases aren't special enough to break the rules. 
Although practicality beats purity. 
Errors should never pass silently. 
Unless explicitly silenced. 
In the face of ambiguity, refuse the temptation to guess. 
There should be one-- and preferably only one --obvious way to do it. 
Although that way may not be obvious at first unless you're Dutch. 
Now is better than never. 
Although never is often better than *right* now. 
If the implementation is hard to explain, it's a bad idea. 
If the implementation is easy to explain, it may be a good idea. 
Namespaces are one honking great idea -- let's do more of those!