Come evitare il "sé" esplicito in Python?

Ho imparato Python seguendo alcuni tutorial di Pygame .

Qui ho trovato ampio uso della parola chiave self , e proveniente da un background principalmente Java, trovo che continuo a dimenticare di digitare self . Ad esempio, invece di self.rect.centerxdigitare rect.centerx, perché, per me, rect è già una variabile membro della classe.

Il parallelo Java che mi viene in mente per questa situazione è di dover aggiungere tutti i riferimenti alle variabili membro con questo .

Sono bloccato con il prefisso di tutte le variabili membro con self o c'è un modo per dichiararle che mi consentirebbe di evitare di doverlo fare?

Anche se ciò che sto suggerendo non è pitonico , mi piacerebbe comunque sapere se è possibile.

Ho dato un'occhiata a queste relative domande SO, ma non rispondono esattamente a ciò che sto cercando:

• Python: perché usare "self" in una classe?
• Perché hai bisogno esplicitamente di avere l'argomento "self" in un metodo Python?

Python richiede di specificare se stesso. Il risultato è che non c'è mai confusione su cosa sia un membro e cosa no, anche senza la definizione di classe completa visibile. Questo porta a proprietà utili, come: non è possibile aggiungere membri che ombreggiano accidentalmente i non membri e quindi rompono il codice.

Un esempio estremo: puoi scrivere una classe senza alcuna conoscenza di quali classi base potrebbe avere e sapere sempre se stai accedendo a un membro o meno:

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

Questo è il codice completo ! (some_function restituisce il tipo usato come base.)

Un altro, in cui i metodi di una classe sono composti dinamicamente:

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.>

Ricorda, entrambi questi esempi sono estremi e non li vedrai tutti i giorni, né sto suggerendo che dovresti spesso scrivere codice come questo, ma mostrano chiaramente aspetti di sé esplicitamente richiesti.

Le risposte precedenti sono sostanzialmente varianti di "non puoi" o "non dovresti". Mentre sono d'accordo con quest'ultimo sentimento, la domanda è tecnicamente ancora senza risposta.

Inoltre, ci sono motivi legittimi per cui qualcuno potrebbe voler fare qualcosa sulla falsariga di ciò che la domanda reale sta ponendo. Una cosa che incontro a volte sono lunghe equazioni matematiche in cui l'uso di nomi lunghi rende irriconoscibile l'equazione. Ecco un paio di modi per farlo in un esempio predefinito:

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))

Il terzo esempio - vale a dire l'utilizzo for k in self.__dict__ : exec(k+'= self.'+k)è fondamentalmente ciò che la domanda sta effettivamente ponendo, ma vorrei essere chiaro che non penso che sia generalmente una buona idea.

Per ulteriori informazioni e modi per scorrere le variabili di classe o anche le funzioni, vedere le risposte e la discussione a questa domanda . Per una discussione di altri modi per nominare dinamicamente le variabili e perché di solito questa non è una buona idea, vedi questo post sul blog .

AGGIORNAMENTO: sembra che non ci sia modo di aggiornare o cambiare dinamicamente i locali in una funzione in Python3, quindi calc3 e varianti simili non sono più possibili. L'unica soluzione compatibile con python3 che mi viene in mente ora è usare 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 )

Che, di nuovo, sarebbe una pratica terribile in generale.

In realtà selfnon è una parola chiave, è solo il nome convenzionalmente assegnato al primo parametro dei metodi di istanza in Python. E quel primo parametro non può essere ignorato, poiché è l'unico meccanismo che un metodo ha di sapere su quale istanza della tua classe viene chiamata.

Puoi usare qualsiasi nome tu voglia, per esempio

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

o anche

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

ma sei bloccato con l'utilizzo di un nome per l'ambito.

Non raccomando di usare qualcosa di diverso da sé a meno che tu non abbia una ragione convincente, poiché lo renderebbe alieno per i pitonisti esperti.

sì, devi sempre specificare self, perché esplicito è meglio che implicito, secondo la filosofia di Python.

Scoprirai anche che il modo in cui programmi in Python è molto diverso dal modo in cui programmi in Java, quindi l'uso di selftende a diminuire perché non proietti tutto all'interno dell'oggetto. Piuttosto, fai un uso maggiore della funzione a livello di modulo, che può essere testata meglio.

a proposito. All'inizio l'ho odiato, ora odio il contrario. lo stesso per il controllo del flusso indentato.

Il "sé" è il segnaposto convenzionale dell'istanza dell'oggetto corrente di una classe. Viene utilizzato quando si desidera fare riferimento alla proprietà, al campo o al metodo dell'oggetto all'interno di una classe come se si riferisse a "se stesso". Ma per rendere più breve qualcuno nel regno della programmazione Python ha iniziato a usare "self", altri regni usano "this" ma lo rendono come una parola chiave che non può essere sostituita. Ho piuttosto usato "suo" per aumentare la leggibilità del codice. È una delle cose positive di Python: hai la libertà di scegliere il tuo segnaposto per l'istanza dell'oggetto diverso da "sé". Esempio per sé:

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)

Ora sostituiamo 'self' con '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)

quale è più leggibile ora?

self fa parte della sintassi di Python per accedere ai membri degli oggetti, quindi temo che tu sia bloccato con esso

In realtà puoi usare la ricetta "Sé implicito" della presentazione di Armin Ronacher "5 anni di cattive idee" (google it).

È una ricetta molto intelligente, come quasi tutto di Armin Ronacher, ma non credo che questa idea sia molto interessante. Penso che preferirei esplicitare questo in C # / Java.

Aggiornare. Link a "ricetta per idee sbagliate": https://speakerdeck.com/mitsuhiko/5-years-of-bad-ideas?slide=58

Sì, il sé è noioso. Ma è meglio?

class Test:

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

    def run(_):
        print _.test

Da: Self Hell - Funzioni più stateful.

... un approccio ibrido funziona meglio. Tutti i metodi di classe che eseguono effettivamente il calcolo dovrebbero essere spostati in chiusure e le estensioni per ripulire la sintassi dovrebbero essere mantenute nelle classi. Riponi le chiusure in classi, trattando la classe in modo simile a uno spazio dei nomi. Le chiusure sono essenzialmente funzioni statiche e quindi non richiedono sé *, anche nella classe ...

Penso che sarebbe più facile e più leggibile se ci fosse una dichiarazione "membro" così come c'è "globale" in modo da poter dire all'interprete quali sono gli oggetti membri della classe.