Qual é o propósito da palavra 'eu'?

Qual é o objetivo da selfpalavra em Python? Entendo que se refere ao objeto específico criado a partir dessa classe, mas não consigo entender por que ele precisa ser explicitamente adicionado a todas as funções como parâmetro. Para ilustrar, no Ruby eu posso fazer isso:

class myClass
    def myFunc(name)
        @name = name
    end
end

O que eu entendo facilmente. No entanto, em Python, preciso incluir self:

class myClass:
    def myFunc(self, name):
        self.name = name

Alguém pode me falar sobre isso? Não é algo que me deparei na minha experiência (reconhecidamente limitada).

O motivo pelo qual você precisa usar self.é porque o Python não usa a @sintaxe para se referir aos atributos da instância. O Python decidiu fazer métodos de uma maneira que faça com que a instância à qual o método pertence seja transmitida automaticamente, mas não recebida automaticamente: o primeiro parâmetro dos métodos é a instância na qual o método é chamado. Isso torna os métodos inteiramente iguais às funções e deixa o nome real para você (embora selfseja a convenção, e as pessoas geralmente o encaram quando você usa outra coisa).self Não é especial para o código, é apenas outro objeto .

O Python poderia ter feito outra coisa para distinguir nomes normais de atributos - sintaxe especial como Ruby, ou exigindo declarações como C ++ e Java, ou talvez algo ainda mais diferente - mas não o fez. O Python é tudo para tornar as coisas explícitas, tornando óbvio o que é o quê e, embora não faça isso totalmente em todos os lugares, ele faz isso por exemplo, atributos. É por isso que atribuir a um atributo de instância precisa saber a qual instância atribuir e é por isso que ele precisa self..

Vamos dar uma classe vetorial simples:

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

Queremos ter um método que calcule o comprimento. Como seria se quiséssemos defini-lo dentro da classe?

    def length(self):
        return math.sqrt(self.x ** 2 + self.y ** 2)

Como deveria ser quando deveríamos defini-lo como um método / função global?

def length_global(vector):
    return math.sqrt(vector.x ** 2 + vector.y ** 2)

Portanto, toda a estrutura permanece a mesma. Como posso fazer uso disso? Se assumirmos por um momento que não escrevemos um lengthmétodo para nossa Vectorclasse, poderíamos fazer o seguinte:

Vector.length_new = length_global
v = Vector(3, 4)
print(v.length_new()) # 5.0

Isso funciona porque o primeiro parâmetro de length_global, pode ser reutilizado como o selfparâmetro em length_new. Isso não seria possível sem um explícito self.

Outra maneira de entender a necessidade do explícito selfé ver onde o Python adiciona um pouco de açúcar sintático. Quando você se lembra, basicamente, uma ligação como

v_instance.length()

é transformado internamente para

Vector.length(v_instance)

é fácil ver onde eles selfse encaixam. Na verdade, você não escreve métodos de instância no Python; o que você escreve são métodos de classe que devem ter uma instância como primeiro parâmetro. E, portanto, você precisará colocar o parâmetro de instância em algum lugar explicitamente.

Digamos que você tenha uma classe ClassAque contenha um método methodAdefinido como:

def methodA(self, arg1, arg2):
    # do something

e ObjectAé uma instância desta classe.

Agora, quando ObjectA.methodA(arg1, arg2)é chamado, o python o converte internamente para você como:

ClassA.methodA(ObjectA, arg1, arg2)

A selfvariável refere-se ao próprio objeto.

Quando os objetos são instanciados, o próprio objeto é passado para o próprio parâmetro.

Por esse motivo, os dados do objeto são vinculados ao objeto. Abaixo está um exemplo de como você pode visualizar a aparência dos dados de cada objeto. Observe como 'self' é substituído pelo nome do objeto. Não estou dizendo que este diagrama de exemplo abaixo seja totalmente preciso, mas espero que sirva a um propósito na visualização do uso do eu.

O Objeto é passado para o próprio parâmetro para que o objeto possa manter seus próprios dados.

Embora isso possa não ser totalmente preciso, pense no processo de instanciar um objeto como este: Quando um objeto é criado, ele usa a classe como modelo para seus próprios dados e métodos. Sem passar seu próprio nome para o parâmetro self, os atributos e métodos na classe permaneceriam como um modelo geral e não seriam referenciados (pertencerão a) ao objeto. Portanto, ao passar o nome do objeto para o parâmetro self, isso significa que, se 100 objetos forem instanciados a partir de uma classe, todos eles poderão acompanhar seus próprios dados e métodos.

Veja a ilustração abaixo:

Eu gosto deste exemplo:

class A: 
    foo = []
a, b = A(), A()
a.foo.append(5)
b.foo
ans: [5]

class A: 
    def __init__(self): 
        self.foo = []
a, b = A(), A()
a.foo.append(5)
b.foo
ans: []

Vou demonstrar com código que não usa classes :

def state_init(state):
    state['field'] = 'init'

def state_add(state, x):
    state['field'] += x

def state_mult(state, x):
    state['field'] *= x

def state_getField(state):
    return state['field']

myself = {}
state_init(myself)
state_add(myself, 'added')
state_mult(myself, 2)

print( state_getField(myself) )
#--> 'initaddedinitadded'

As aulas são apenas uma maneira de evitar passar esse "estado" o tempo todo (e outras coisas interessantes, como inicialização, composição de classes, as metaclasses raramente necessárias e suporte a métodos personalizados para substituir os operadores).

Agora vamos demonstrar o código acima usando o mecanismo incorporado da classe python, para mostrar como é basicamente a mesma coisa.

class State(object):
    def __init__(self):
        self.field = 'init'
    def add(self, x):
        self.field += x
    def mult(self, x):
        self.field *= x

s = State()
s.add('added')    # self is implicitly passed in
s.mult(2)         # self is implicitly passed in
print( s.field )

[migrou minha resposta da pergunta fechada duplicada]

Os seguintes trechos são da documentação do Python sobre o self :

Como no Modula-3, não há atalhos [no Python] para referenciar os membros do objeto a partir de seus métodos: a função method é declarada com um primeiro argumento explícito que representa o objeto, que é fornecido implicitamente pela chamada.

Freqüentemente, o primeiro argumento de um método é chamado de auto. Isso nada mais é do que uma convenção: o nome self não tem absolutamente nenhum significado especial para o Python. Observe, no entanto, que, ao não seguir a convenção, seu código poderá ser menos legível para outros programadores Python, e também é concebível que um programa de navegador de classe possa ser gravado com base nessa convenção.

Para obter mais informações, consulte o tutorial de documentação do Python sobre classes .

Assim como todos os outros motivos já mencionados, ele facilita o acesso a métodos substituídos; você pode ligar Class.some_method(inst).

Um exemplo de onde é útil:

class C1(object):
    def __init__(self):
         print "C1 init"

class C2(C1):
    def __init__(self): #overrides C1.__init__
        print "C2 init"
        C1.__init__(self) #but we still want C1 to init the class too

>>> C2()
"C2 init"
"C1 init"

Seu uso é semelhante ao uso da thispalavra-chave em Java, ou seja, para fornecer uma referência ao objeto atual.

Python não é uma linguagem criada para programação orientada a objetos, diferente de Java ou C ++.

Ao chamar um método estático em Python, basta escrever um método com argumentos regulares dentro dele.

class Animal():
    def staticMethod():
        print "This is a static method"

No entanto, um método de objeto, que exige que você faça uma variável, que é um Animal, nesse caso, precisa do argumento próprio

class Animal():
    def objectMethod(self):
        print "This is an object method which needs an instance of a class"

O método self também é usado para se referir a um campo variável dentro da classe.

class Animal():
    #animalName made in constructor
    def Animal(self):
        self.animalName = "";


    def getAnimalName(self):
        return self.animalName

Nesse caso, self está se referindo à variável animalName de toda a classe. LEMBRE-SE: Se você tiver uma variável dentro de um método, o self não funcionará. Essa variável é simplesmente existente apenas enquanto esse método está em execução. Para definir campos (as variáveis ​​de toda a classe), é necessário defini-los FORA DOS métodos da classe.

Se você não entende uma única palavra do que estou dizendo, então Google "Programação Orientada a Objetos". Depois de entender isso, você nem precisará fazer essa pergunta :).

Está lá para seguir o zen do Python "explícito é melhor do que implícito". É realmente uma referência ao seu objeto de classe. Em Java e PHP, por exemplo, é chamado this.

Se user_type_nameé um campo no seu modelo, você o acessa self.user_type_name.

Primeiro de tudo, self é um nome convencional, você pode colocar qualquer outra coisa (sendo coerente) em seu lugar.

Refere-se ao objeto em si; portanto, quando você o está usando, declara que .name e .age são propriedades dos objetos Student (nota, não da classe Student) que você criará.

class Student:
    #called each time you create a new Student instance
    def __init__(self,name,age): #special method to initialize
        self.name=name
        self.age=age

    def __str__(self): #special method called for example when you use print
        return "Student %s is %s years old" %(self.name,self.age)

    def call(self, msg): #silly example for custom method
        return ("Hey, %s! "+msg) %self.name

#initializing two instances of the student class
bob=Student("Bob",20)
alice=Student("Alice",19)

#using them
print bob.name
print bob.age
print alice #this one only works if you define the __str__ method
print alice.call("Come here!") #notice you don't put a value for self

#you can modify attributes, like when alice ages
alice.age=20
print alice

O código está aqui

selfé uma referência de objeto ao próprio objeto; portanto, eles são iguais. Os métodos Python não são chamados no contexto do próprio objeto. selfno Python pode ser usado para lidar com modelos de objetos personalizados ou algo assim.

O uso do argumento, convencionalmente chamado, selfnão é tão difícil de entender, como é por que é necessário? Ou por que mencioná-lo explicitamente? Suponho que essa seja uma questão maior para a maioria dos usuários que a pesquisarem, ou, caso contrário, eles certamente terão a mesma pergunta à medida que avançarem no aprendizado de python. Eu os recomendo a ler estes dois blogs:

1: Uso de auto explicado

Observe que não é uma palavra-chave.

O primeiro argumento de todo método de classe, incluindo init, é sempre uma referência à instância atual da classe. Por convenção, esse argumento é sempre chamado de auto. No método init, self refere-se ao objeto recém-criado; em outros métodos de classe, refere-se à instância cujo método foi chamado. Por exemplo, o código abaixo é o mesmo que o código acima.

2: Por que temos dessa maneira e por que não podemos eliminá-lo como argumento, como Java, e ter uma palavra-chave

Outra coisa que gostaria de acrescentar é que um selfargumento opcional me permite declarar métodos estáticos dentro de uma classe, não escrevendo self.

Exemplos de código:

class MyClass():
    def staticMethod():
        print "This is a static method"

    def objectMethod(self):
        print "This is an object method which needs an instance of a class, and that is what self refers to"

PS : Isso funciona apenas no Python 3.x.

Nas versões anteriores, é necessário adicionar explicitamente o @staticmethoddecorador, caso contrário, o selfargumento é obrigatório.

Estou surpreso que ninguém tenha criado Lua. Lua também usa a variável 'self', no entanto, pode ser omitida, mas ainda usada. C ++ faz o mesmo com 'this'. Não vejo nenhuma razão para declarar 'self' em cada função, mas você ainda deve poder usá-lo da mesma forma que pode com lua e C ++. Para uma linguagem que se orgulha de ser breve, é estranho que exija que você declare a variável auto.

Dê uma olhada no exemplo a seguir, que explica claramente o objetivo de self

class Restaurant(object):  
    bankrupt = False

    def open_branch(self):
        if not self.bankrupt:
           print("branch opened")

#create instance1
>>> x = Restaurant()
>>> x.bankrupt
False

#create instance2
>>> y = Restaurant()
>>> y.bankrupt = True   
>>> y.bankrupt
True

>>> x.bankrupt
False  

self é usado / necessário para distinguir entre instâncias.

Fonte: variável auto explicada em python - Pythontips

É porque, pela maneira como o python é projetado, as alternativas dificilmente funcionariam. O Python é projetado para permitir que métodos ou funções sejam definidos em um contexto em que implícitos this(a-la Java / C ++) ou explícitos @(a-la ruby) não funcionariam. Vamos dar um exemplo com a abordagem explícita com convenções python:

def fubar(x):
    self.x = x

class C:
    frob = fubar

Agora, a fubarfunção não funcionaria, pois assumiria que selfé uma variável global (e frobtambém). A alternativa seria executar métodos com um escopo global substituído (onde selfestá o objeto).

A abordagem implícita seria

def fubar(x)
    myX = x

class C:
    frob = fubar

Isso significaria que myXseria interpretado como uma variável local em fubar(e frobtambém). A alternativa aqui seria executar métodos com um escopo local substituído, que é retido entre as chamadas, mas isso removeria a possibilidade de variáveis ​​locais do método.

No entanto, a situação atual funciona bem:

 def fubar(self, x)
     self.x = x

 class C:
     frob = fubar

aqui, quando chamado como método frob, receberá o objeto no qual é chamado via selfparâmetro e fubarainda pode ser chamado com um objeto como parâmetro e funcionará da mesma forma ( é o mesmo que C.frobeu acho).

No __init__método, self refere-se ao objeto recém-criado; em outros métodos de classe, refere-se à instância cujo método foi chamado.

self, como nome, é apenas uma convenção , chame como quiser! mas ao usá-lo, por exemplo, para excluir o objeto, você deve usar o mesmo nome:, __del__(var)onde varfoi usado no__init__(var,[...])

Você deve dar uma olhada clstambém, para ter uma visão maior . Esta publicação pode ser útil.

self está agindo como o nome do objeto atual ou a instância da classe.

# Self explanation.


 class classname(object):

    def __init__(self,name):

        self.name=name
        # Self is acting as a replacement of object name.
        #self.name=object1.name

   def display(self):
      print("Name of the person is :",self.name)
      print("object name:",object1.name)


 object1=classname("Bucky")
 object2=classname("ford")

 object1.display()
 object2.display()

###### Output 
Name of the person is : Bucky
object name: Bucky
Name of the person is : ford
object name: Bucky

self é inevitável.

Havia apenas uma pergunta que deveria selfestar implícita ou explícita. Guido van Rossumresolveu esta pergunta dizendo que selftem que ficar .

Então, onde selfmora?

Se nos atermos à programação funcional, não precisaríamos self. Uma vez que entramos no Python OOP , encontramos selflá.

Aqui está o caso de uso típico class Ccom o métodom1

class C:
    def m1(self, arg):
        print(self, ' inside')
        pass

ci =C()
print(ci, ' outside')
ci.m1(None)
print(hex(id(ci))) # hex memory address

Este programa produzirá:

<__main__.C object at 0x000002B9D79C6CC0>  outside
<__main__.C object at 0x000002B9D79C6CC0>  inside
0x2b9d79c6cc0

Portanto, selfmantém o endereço de memória da instância da classe. O objetivo de selfmanter a referência, por exemplo, métodos e ter acesso explícito a essa referência.

_{Observe que existem três tipos diferentes de métodos de classe:}

• _{métodos estáticos (leia-se: funções),}
• _{métodos de classe,}
• _{métodos de instância (mencionados).}

dos documentos ,

a coisa especial sobre métodos é que o objeto de instância é passado como o primeiro argumento da função. No nosso exemplo, a chamada x.f()é exatamente equivalente a MyClass.f(x). Em geral, chamar um método com uma lista de n argumentos é equivalente a chamar a função correspondente com uma lista de argumentos criada ao inserir o objeto de instância do método antes do primeiro argumento.

precedendo esse trecho relacionado,

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

x = MyClass()

é uma referência explícita ao objeto de instância de classe.