Comment éviter le «soi» explicite en Python?

J'ai appris Python en suivant quelques tutoriels pygame .

J'y ai trouvé une utilisation intensive du mot-clé self , et venant d'un fond principalement Java, je constate que j'oublie toujours de taper self . Par exemple, au lieu de self.rect.centerxje taperais rect.centerx, car, pour moi, rect est déjà une variable membre de la classe.

Le parallèle Java auquel je peux penser pour cette situation est de devoir préfixer toutes les références aux variables membres avec ceci .

Suis-je bloqué en préfixant toutes les variables membres avec self , ou y a-t-il un moyen de les déclarer qui me permettrait d'éviter d'avoir à le faire?

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

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

• Python - pourquoi utiliser «self» dans une classe?
• Pourquoi avez-vous besoin explicitement de l'argument «self» dans une méthode Python?

Python nécessite de spécifier soi-même. 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 sans la définition complète de la classe visible. Cela conduit à des propriétés utiles, telles que: vous ne pouvez pas ajouter de membres qui occultent accidentellement des non-membres et interrompent ainsi le code.

Un exemple extrême: vous pouvez écrire une classe sans aucune connaissance des classes de base qu'elle pourrait 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 code complet ! (some_function renvoie 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, et je ne suggère pas non plus que vous devriez souvent écrire du code comme celui-ci, mais ils montrent clairement que les aspects de soi sont explicitement requis.

Les réponses précédentes sont toutes fondamentalement 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 dans le sens de ce que la question pose. Une chose que je rencontre parfois est de longues équations mathématiques où l'utilisation de noms longs rend l'équation méconnaissable. Voici quelques façons de procéder dans un exemple en conserve:

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 for k in self.__dict__ : exec(k+'= self.'+k)est essentiellement ce que la question demande réellement, mais laissez-moi être clair que je ne pense pas que ce soit généralement une bonne idée.

Pour plus d'informations et pour parcourir les variables de classe, ou même les fonctions, consultez les réponses et la discussion à cette question . Pour une discussion sur d'autres façons de nommer dynamiquement des variables, et pourquoi ce n'est généralement pas une bonne idée, consultez cet article de blog .

MISE À JOUR: Il semble qu'il n'y ait aucun moyen de mettre à jour ou de modifier dynamiquement les paramètres locaux d'une fonction dans Python3, donc calc3 et les variantes similaires ne sont plus possibles. La seule solution compatible python3 à laquelle je puisse penser maintenant est d'utiliser 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.

En fait, ce selfn'est pas un mot-clé, c'est juste le nom conventionnellement donné 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.

Vous pouvez utiliser le nom de votre choix, 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 coincé avec l'utilisation d'un nom pour la portée.

Je ne vous recommande pas d'utiliser quelque chose de différent de vous-même, sauf si vous avez une raison convaincante, car cela le rendrait étranger pour les pythonistes expérimentés.

oui, vous devez toujours spécifier self, car explicite vaut mieux qu'implicite, selon la philosophie de python.

Vous découvrirez également que la façon dont vous programmez en python est très différente de la façon dont vous programmez en java, d'où l'utilisation de a selftendance à diminuer car vous ne projetez pas tout à l'intérieur de l'objet. Au contraire, vous utilisez davantage la fonction au niveau du module, qui peut être mieux testée.

au fait. Je détestais ça au début, maintenant je déteste le contraire. idem pour le contrôle de flux indenté.

Le «self» est l'espace réservé conventionnel de l'instance d'objet courante d'une classe. Il est utilisé lorsque vous voulez faire référence à la propriété, au champ ou à la méthode de l'objet à l'intérieur d'une classe comme si vous faisiez référence à «lui-même». Mais pour raccourcir les choses, quelqu'un dans le domaine de la programmation Python a commencé à utiliser "self", d'autres royaumes utilisent "this" mais ils en font un mot-clé qui ne peut pas être remplacé. J'ai plutôt utilisé "son" pour augmenter la lisibilité du code. C'est l'une des bonnes choses de Python - vous avez la liberté de choisir votre propre espace réservé pour l'instance de l'objet autre que "self". Exemple pour soi:

class UserAccount():    
    def __init__(self, user_type, username, password):
        self.user_type = user_type
        self.username = username            
        self.password = encrypt(password)        

    def get_password(self):
        return decrypt(self.password)

    def set_password(self, password):
        self.password = encrypt(password)

Maintenant, nous remplaçons 'self' par 'its':

class UserAccount():    
    def __init__(its, user_type, username, password):
        its.user_type = user_type
        its.username = username            
        its.password = encrypt(password)        

    def get_password(its):
        return decrypt(its.password)

    def set_password(its, password):
        its.password = encrypt(password)

qui est plus lisible maintenant?

self fait partie de la syntaxe python pour accéder aux membres des objets, donc j'ai peur que vous soyez coincé

En fait, vous pouvez utiliser la recette "Auto implicite" de la présentation d'Armin Ronacher "5 ans de mauvaises idées" (google it).

C'est une recette très intelligente, comme presque tout d'Armin Ronacher, mais je ne pense pas que cette idée soit très attrayante. Je pense que je préférerais cela explicite en C # / Java.

Mettre à jour. Lien vers "recette de mauvaise idée": https://speakerdeck.com/mitsuhiko/5-years-of-bad-ideas?slide=58

Ouais, le moi est fastidieux. Mais est-ce mieux?

class Test:

    def __init__(_):
        _.test = 'test'

    def run(_):
        print _.test

De: Self Hell - Plus de fonctions avec état.

... une approche hybride fonctionne mieux. Toutes vos méthodes de classe qui effectuent réellement des calculs doivent être déplacées dans des fermetures, et les extensions pour nettoyer la syntaxe doivent être conservées dans des classes. Farcissez les fermetures dans des classes, en traitant la classe comme un espace de noms. Les fermetures sont essentiellement des fonctions statiques, et ne nécessitent donc pas de selfs *, même dans la classe ...

Je pense que ce serait plus facile et plus lisible s'il y avait une instruction «membre» tout comme il y a «global» pour que vous puissiez dire à l'interpréteur quels sont les objets membres de la classe.