Como evitar 'self' explícito em Python?

Eu tenho aprendido Python seguindo alguns tutoriais de pygame .

Nele, encontrei o uso extensivo da palavra-chave self e, vindo de um background principalmente em Java, acho que continuo esquecendo de digitar self . Por exemplo, em vez de self.rect.centerxdigitar rect.centerx, porque, para mim, rect já é uma variável de membro da classe.

O paralelo Java em que posso pensar para esta situação está tendo que prefixar todas as referências a variáveis-membro com isso .

Estou preso prefixando todas as variáveis ​​de membro com self , ou existe uma maneira de declará-las que me permitiria evitar isso?

Mesmo que o que estou sugerindo não seja pitônico , ainda gostaria de saber se é possível.

Dei uma olhada nessas perguntas relacionadas ao SO, mas elas não respondem muito bem o que estou procurando:

• Python - por que usar "self" em uma classe?
• Por que você precisa ter explicitamente o argumento "self" em um método Python?

Python requer especificação própria. O resultado é que nunca há confusão sobre o que é membro e o que não é, mesmo sem a definição completa da classe visível. Isso leva a propriedades úteis, como: você não pode adicionar membros que ocultam acidentalmente os não membros e, portanto, quebram o código.

Um exemplo extremo: você pode escrever uma classe sem ter conhecimento de quais classes base ela pode ter e sempre saber se está acessando um membro ou não:

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

Esse é o código completo ! (some_function retorna o tipo usado como base.)

Outro, onde os métodos de uma classe são compostos 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.>

Lembre-se de que ambos os exemplos são extremos e você não os verá todos os dias, nem estou sugerindo que você escreva frequentemente códigos como esse, mas eles mostram claramente aspectos de auto explicitamente exigidos.

As respostas anteriores são basicamente variantes de "você não pode" ou "você não deveria". Embora eu concorde com o último sentimento, tecnicamente a pergunta ainda não foi respondida.

Além disso, existem razões legítimas pelas quais alguém pode querer fazer algo como a pergunta real. Uma coisa que eu encontro às vezes são longas equações matemáticas, nas quais o uso de nomes longos torna a equação irreconhecível. Aqui estão algumas maneiras de como você pode fazer isso em um exemplo fixo:

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

O terceiro exemplo - ou seja, usar for k in self.__dict__ : exec(k+'= self.'+k)é basicamente o que a pergunta está realmente pedindo, mas deixe-me esclarecer que geralmente não acho que seja uma boa ideia.

Para obter mais informações e maneiras de percorrer variáveis ​​de classe ou até funções, consulte as respostas e a discussão desta pergunta . Para uma discussão de outras maneiras de nomear dinamicamente variáveis ​​e por que isso geralmente não é uma boa ideia, consulte esta postagem no blog .

ATUALIZAÇÃO: Parece não haver maneira de atualizar ou alterar dinamicamente os locais em uma função no Python3, portanto, o calc3 e variantes semelhantes não são mais possíveis. A única solução compatível com python3 que consigo pensar agora é usar 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 )

O que, novamente, seria uma prática terrível em geral.

Na verdade, selfnão é uma palavra-chave, é apenas o nome dado convencionalmente ao primeiro parâmetro dos métodos de instância no Python. E esse primeiro parâmetro não pode ser ignorado, pois é o único mecanismo que um método tem para saber em qual instância da sua classe está sendo chamada.

Você pode usar o nome que quiser, por exemplo

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

ou mesmo

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

mas você está preso ao usar um nome para o escopo.

Eu não recomendo que você use algo diferente de si mesmo, a menos que tenha um motivo convincente, pois isso o tornaria estranho para os pythonistas experientes.

sim, você sempre deve especificar self, porque explícito é melhor que implícito, de acordo com a filosofia python.

Você também descobrirá que a maneira como você programa em python é muito diferente da maneira como você programa em java; portanto, o uso de selftende a diminuir porque você não projeta tudo dentro do objeto. Em vez disso, você faz um uso maior da função no nível do módulo, que pode ser melhor testada.

a propósito. Eu odiava no começo, agora eu odeio o oposto. o mesmo para controle de fluxo acionado por recuo.

O "self" é o espaço reservado convencional da instância atual do objeto de uma classe. É usado quando você deseja se referir à propriedade, ao campo ou ao método do objeto dentro de uma classe, como se estivesse se referindo a "ele próprio". Mas, para tornar mais curto, alguém no domínio de programação Python começou a usar "self", outros domínios usam "this", mas o fazem como uma palavra-chave que não pode ser substituída. Eu usei "its" para aumentar a legibilidade do código. É uma das coisas boas em Python - você tem a liberdade de escolher seu próprio espaço reservado para a instância do objeto que não seja "self". Exemplo para self:

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)

Agora substituímos 'self' por '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)

qual é mais legível agora?

self faz parte da sintaxe python para acessar membros de objetos, então, receio que você esteja preso a ela

Na verdade, você pode usar a receita "Eu implícito" da apresentação de Armin Ronacher "5 anos de más idéias" (pesquise no google).

É uma receita muito inteligente, como quase tudo, de Armin Ronacher, mas não acho que essa ideia seja muito atraente. Eu acho que prefiro isso explícito em C # / Java.

Atualizar. Link para "receita para más ideias": https://speakerdeck.com/mitsuhiko/5-years-of-bad-ideas?slide=58

Sim, o eu é tedioso. Mas é melhor?

class Test:

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

    def run(_):
        print _.test

From: Self Hell - Funções mais stateful.

... uma abordagem híbrida funciona melhor. Todos os métodos de classe que realmente calculam devem ser movidos para fechamentos, e as extensões para limpar a sintaxe devem ser mantidas nas classes. Coloque os fechamentos em classes, tratando a classe como um espaço para nome. Os fechamentos são essencialmente funções estáticas e, portanto, não exigem selfs *, mesmo na classe ...

Eu acho que seria mais fácil e mais legível se houvesse uma declaração "membro", assim como existe "global", para que você possa dizer ao intérprete quais são os objetos membros da classe.