Comment éviter le " self " explicite en Python ?

Question

J'ai appris Python en suivant quelques tutoriels pygame .

J'y ai trouvé une utilisation intensive du mot-clé self et venant d'un milieu principalement Java, je trouve que je continue à oublier de taper self . Par exemple, au lieu de self.rect.centerx Je taperais rect.centerx parce que, pour moi, rect est déjà une variable membre de la classe.

Le parallèle Java auquel je peux penser pour cette situation est d'avoir à préfixer toutes les références aux variables de membre avec este .

Suis-je obligé de préfixer toutes les variables membres avec self ou existe-t-il un moyen de les déclarer qui me permettrait d'éviter de devoir le faire ?

Même si ce que je suggère n'est pas pythonique mais j'aimerais quand même savoir si c'est possible.

J'ai jeté un coup d'œil à ces questions connexes sur la SO, mais elles ne répondent pas tout à fait à ce que je cherche :

• Python - pourquoi utiliser "self" dans une classe ?
• Pourquoi faut-il avoir explicitement l'argument "self" dans une méthode Python ?

Answer 1

Python exige de spécifier self. Le résultat est qu'il n'y a jamais de confusion sur ce qui est un membre et ce qui ne l'est pas, même si la définition complète de la classe n'est pas visible. Cela conduit à des propriétés utiles, telles que : vous ne pouvez pas ajouter des membres qui font accidentellement de l'ombre à des non-membres et ainsi casser le code.

Un exemple extrême : vous pouvez écrire une classe sans savoir quelles classes de base elle peut avoir, et toujours savoir si vous accédez à un membre ou non :

class A(some_function()):
  def f(self):
    self.member = 42
    self.method()

C'est le complet code ! (some_function retourne le type utilisé comme base).

Un autre, où les méthodes d'une classe sont composées dynamiquement :

class B(object):
  pass

print B()
# <__main__.B object at 0xb7e4082c>

def B_init(self):
  self.answer = 42
def B_str(self):
  return "<The answer is %s.>" % self.answer
# notice these functions require no knowledge of the actual class
# how hard are they to read and realize that "members" are used?

B.__init__ = B_init
B.__str__ = B_str

print B()
# <The answer is 42.>

N'oubliez pas que ces deux exemples sont extrêmes et que vous ne les verrez pas tous les jours. Je ne suggère pas non plus que vous devriez souvent écrire du code comme celui-ci, mais ils montrent clairement que certains aspects du soi sont explicitement requis.

Answer 2

Les réponses précédentes sont toutes des variantes de "vous ne pouvez pas" ou "vous ne devriez pas". Bien que je sois d'accord avec ce dernier sentiment, la question reste techniquement sans réponse.

En outre, il existe des raisons légitimes pour lesquelles quelqu'un pourrait vouloir faire quelque chose allant dans le sens de ce que la question actuelle demande. Je rencontre parfois de longues équations mathématiques pour lesquelles l'utilisation de noms longs rend l'équation méconnaissable. Voici quelques façons de procéder dans un exemple concret :

import numpy as np
class MyFunkyGaussian() :
    def __init__(self, A, x0, w, s, y0) :
        self.A = float(A)
        self.x0 = x0
        self.w = w
        self.y0 = y0
        self.s = s

    # The correct way, but subjectively less readable to some (like me) 
    def calc1(self, x) :
        return (self.A/(self.w*np.sqrt(np.pi))/(1+self.s*self.w**2/2)
                * np.exp( -(x-self.x0)**2/self.w**2)
                * (1+self.s*(x-self.x0)**2) + self.y0 )

    # The correct way if you really don't want to use 'self' in the calculations
    def calc2(self, x) :
        # Explicity copy variables
        A, x0, w, y0, s = self.A, self.x0, self.w, self.y0, self.s
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

    # Probably a bad idea...
    def calc3(self, x) :
        # Automatically copy every class vairable
        for k in self.__dict__ : exec(k+'= self.'+k)
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

g = MyFunkyGaussian(2.0, 1.5, 3.0, 5.0, 0.0)
print(g.calc1(0.5))
print(g.calc2(0.5))
print(g.calc3(0.5))

Le troisième exemple - c'est-à-dire l'utilisation de for k in self.__dict__ : exec(k+'= self.'+k) est en fait ce que la question demande, mais laissez-moi être clair : je ne pense pas que ce soit une bonne idée en général.

Pour plus d'informations, et pour connaître les moyens d'itérer à travers les variables de classe, ou même les fonctions, voir les réponses et la discussion sur cette question . Pour une discussion sur les autres façons de nommer dynamiquement des variables, et sur les raisons pour lesquelles ce n'est généralement pas une bonne idée, voir cet article de blog .

UPDATE : Il semble y avoir pas du tout pour mettre à jour ou changer dynamiquement les locales d'une fonction dans Python3, donc calc3 et les variantes similaires ne sont plus possibles. La seule solution compatible avec Python3 à laquelle je pense pour l'instant est l'utilisation de globals :

def calc4(self, x) :
        # Automatically copy every class variable in globals
        globals().update(self.__dict__)
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

Ce qui, encore une fois, serait une pratique terrible en général.

Answer 3

En fait, self n'est pas un mot-clé, c'est juste le nom donné par convention au premier paramètre des méthodes d'instance en Python. Et ce premier paramètre ne peut pas être ignoré, car c'est le seul mécanisme dont dispose une méthode pour savoir sur quelle instance de votre classe elle est appelée.

Answer 4

Vous pouvez utiliser le nom que vous voulez, par exemple

class test(object):
    def function(this, variable):
        this.variable = variable

ou même

class test(object):
    def function(s, variable):
        s.variable = variable

mais vous êtes obligé d'utiliser un nom pour la portée.

Je ne vous recommande pas d'utiliser quelque chose de différent de vous-même, à moins que vous n'ayez une raison convaincante, car cela le rendrait étranger aux pythonistes expérimentés.

Answer 5

Oui, vous devez toujours spécifier self car l'explicite est meilleur que l'implicite, selon la philosophie de Python.

Vous découvrirez également que la manière de programmer en python est très différente de la manière de programmer en java, d'où l'utilisation de self a tendance à diminuer car on ne projette pas tout à l'intérieur de l'objet. Au contraire, vous utilisez davantage les fonctions au niveau du module, qui peuvent être mieux testées.

d'ailleurs. Je l'ai détesté au début, maintenant je déteste le contraire. Même chose pour le contrôle de flux avec indentation.