Jaki jest cel słowa „ja”?

Jaki jest cel tego selfsłowa w Pythonie? Rozumiem, że odnosi się do konkretnego obiektu utworzonego z tej klasy, ale nie rozumiem, dlaczego musi być jawnie dodawany do każdej funkcji jako parametr. Aby to zilustrować, w Ruby mogę to zrobić:

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

Rozumiem to dość łatwo. Jednak w Pythonie muszę dołączyć self:

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

Czy ktoś może mi to powiedzieć? To nie jest coś, z czym się spotkałem (co prawda ograniczone) doświadczenie.

Powód, dla którego musisz użyć self. jest to, że Python nie używa @składni do odwoływania się do atrybutów instancji. Python postanowił wykonać metody w taki sposób, że instancja, do której należy metoda, jest przekazywana automatycznie, ale nie odbierana automatycznie: pierwszym parametrem metod jest instancja, w której metoda jest wywoływana. To sprawia, że ​​metody są całkowicie takie same, jak funkcje, i pozostawia do wyboru nazwę użytkownika (chociaż selfjest to konwencja, a ludzie zwykle będą się na ciebie krzywo, gdy użyjesz czegoś innego). selfNie jest wyjątkowy dla kodu, to tylko kolejny obiekt .

Python mógł zrobić coś innego, aby odróżnić normalne nazwy od atrybutów - specjalną składnię, taką jak Ruby, lub wymagającą deklaracji takich jak C ++ i Java, a może coś jeszcze bardziej odmiennego - ale tak nie było. Python służy do tego, aby wyrażać rzeczy jasno, co jest oczywiste, i chociaż nie robi tego całkowicie wszędzie, robi to na przykład z atrybutami. Dlatego przypisanie do atrybutu instancji musi wiedzieć, do której instancji należy przypisać, i właśnie dlatego musi self..

Weźmy prostą klasę wektorów:

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

Chcemy mieć metodę obliczającą długość. Jak by to wyglądało, gdybyśmy chcieli zdefiniować to w klasie?

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

Jak powinien on wyglądać, gdy mieliśmy zdefiniować go jako globalną metodę / funkcję?

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

Cała struktura pozostaje taka sama. Jak mogę z tego skorzystać? Jeśli przez chwilę założymy, że nie napisaliśmy lengthmetody dla naszej Vectorklasy, moglibyśmy to zrobić:

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

Działa to, ponieważ pierwszy parametr length_global, może być ponownie użyty jako selfparametr w length_new. Nie byłoby to możliwe bez wyraźnego self.

Innym sposobem zrozumienia potrzeby wyrażenia jawnego selfjest sprawdzenie, gdzie Python dodaje cukier syntaktyczny. Kiedy pamiętasz, to w zasadzie połączenie takie jak

v_instance.length()

został wewnętrznie przekształcony w

Vector.length(v_instance)

łatwo jest sprawdzić, gdzie selfpasuje. W rzeczywistości nie piszesz metod instancji w Pythonie; piszesz metody klas, które muszą wziąć instancję jako pierwszy parametr. Dlatego musisz umieścić parametr instancji gdzieś wyraźnie.

Załóżmy, że masz klasę, ClassAktóra zawiera metodę methodAzdefiniowaną jako:

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

i ObjectAjest instancją tej klasy.

Teraz, gdy ObjectA.methodA(arg1, arg2)jest wywoływany, Python wewnętrznie konwertuje go dla Ciebie jako:

ClassA.methodA(ObjectA, arg1, arg2)

selfZmienna odnosi się do samego obiektu.

Podczas tworzenia instancji obiektów sam obiekt jest przekazywany do parametru własnego.

Z tego powodu dane obiektu są powiązane z obiektem. Poniżej znajduje się przykład wizualizacji wyglądu danych każdego obiektu. Zauważ, jak „jaźń” jest zastępowana nazwą obiektu. Nie twierdzę, że poniższy przykładowy diagram jest całkowicie dokładny, ale mam nadzieję, że służy celowi wizualizacji użycia jaźni.

Obiekt jest przekazywany do parametru własnego, dzięki czemu obiekt może przechowywać własne dane.

Chociaż może to nie być w pełni dokładne, pomyśl o procesie tworzenia instancji obiektu w ten sposób: Kiedy obiekt jest tworzony, wykorzystuje klasę jako szablon dla własnych danych i metod. Bez przekazania własnej nazwy do parametru własnego atrybuty i metody w klasie pozostałyby jako ogólny szablon i nie byłyby przywoływane (należały) do obiektu. Zatem przekazanie nazwy obiektu do parametru własnego oznacza, że ​​jeśli utworzonych zostanie 100 obiektów z jednej klasy, wszystkie one mogą śledzić własne dane i metody.

Zobacz ilustrację poniżej:

Podoba mi się ten przykład:

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: []

Pokażę za pomocą kodu, który nie korzysta z klas :

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'

Klasy są tylko sposobem na uniknięcie ciągłego przechodzenia w tę „stanową” rzecz (i inne fajne rzeczy, takie jak inicjowanie, składanie klas, rzadko potrzebne metaklasy i wspieranie niestandardowych metod zastępowania operatorów).

Teraz pokażmy powyższy kod za pomocą wbudowanego mechanizmu klasy python, aby pokazać, jak to właściwie jest to samo.

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 )

[migrowałem moją odpowiedź z duplikatu pytania zamkniętego]

Poniższe fragmenty pochodzą z dokumentacji Pythona na temat siebie :

Podobnie jak w Modula-3, nie ma skrótów [w Pythonie] do odwoływania się do elementów obiektu z jego metod: funkcja metody jest zadeklarowana z wyraźnym pierwszym argumentem reprezentującym obiekt, który jest niejawnie wywołany przez wywołanie.

Często pierwszy argument metody nazywa się self. To nic innego jak konwencja: nazwa self nie ma absolutnie żadnego specjalnego znaczenia dla Pythona. Zauważ jednak, że nieprzestrzeganie konwencji może spowodować, że kod będzie mniej czytelny dla innych programistów Pythona, i możliwe jest również napisanie programu do przeglądania klas, który opiera się na takiej konwencji.

Aby uzyskać więcej informacji, zobacz samouczek dokumentacji klas Python .

Jak również wszystkie inne wymienione już powody, umożliwia łatwiejszy dostęp do zastąpionych metod; możesz zadzwonić Class.some_method(inst).

Przykład przydatności:

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"

Jego użycie jest podobne do użycia thissłowa kluczowego w Javie, tj. Do odniesienia do bieżącego obiektu.

Python nie jest językiem zbudowanym dla programowania obiektowego w przeciwieństwie do Java lub C ++.

Podczas wywoływania metody statycznej w Pythonie wystarczy napisać metodę z regularnymi argumentami.

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

Jednak metoda obiektowa, która wymaga utworzenia zmiennej, jaką jest zwierzę, w tym przypadku wymaga argumentu własnego

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

Metoda własna jest również używana w odniesieniu do pola zmiennego w klasie.

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


    def getAnimalName(self):
        return self.animalName

W tym przypadku self odnosi się do zmiennej animalName całej klasy. PAMIĘTAJ: Jeśli masz zmienną w metodzie, self nie będzie działać. Ta zmienna istnieje po prostu tylko podczas działania tej metody. Aby zdefiniować pola (zmienne całej klasy), musisz zdefiniować je POZA metodami klasowymi.

Jeśli nie rozumiesz ani jednego słowa tego, co mówię, to Google „Programowanie obiektowe”. Kiedy to zrozumiesz, nie będziesz musiał nawet zadawać tego pytania :).

Ma podążać za zenem Pythona „wyraźne jest lepsze niż niejawne”. To rzeczywiście odniesienie do twojego obiektu klasy. Na przykład w Javie i PHP nazywa się to this.

Jeśli user_type_namew twoim modelu jest pole, masz do niego dostęp self.user_type_name.

Przede wszystkim „ja” to konwencjonalne imię, w którym można umieścić wszystko inne (spójne).

Odnosi się do samego obiektu, więc kiedy go używasz, deklarujesz, że .name i .age są właściwościami obiektów Student (uwaga, nie klasy Student), które zamierzasz utworzyć.

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

Kod jest tutaj

selfjest odwołaniem do obiektu do samego obiektu, dlatego są takie same. Metody w języku Python nie są wywoływane w kontekście samego obiektu. selfw Pythonie może być używany do obsługi niestandardowych modeli obiektów lub czegoś takiego.

Zastosowanie argumentu, zwanego konwencjonalnie self nie jest tak trudne do zrozumienia, jak to jest konieczne? Lub dlaczego wprost to wymienia? To, jak sądzę, jest większe pytanie dla większości użytkowników, którzy szukają tego pytania, a jeśli nie, to na pewno będą mieli to samo pytanie, gdy przejdą do następnego etapu nauki pytona. Polecam im przeczytanie tych kilku blogów:

1: Korzystanie z wyjaśnienia

Pamiętaj, że to nie jest słowo kluczowe.

Pierwszy argument każdej metody klasy, w tym init, jest zawsze odniesieniem do bieżącej instancji klasy. Zgodnie z konwencją ten argument zawsze nosi nazwę „ja”. W metodzie init self odnosi się do nowo utworzonego obiektu; w innych metodach klasowych odnosi się do instancji, której metoda została wywołana. Na przykład poniższy kod jest taki sam jak powyższy kod.

2: Dlaczego mamy to w ten sposób i dlaczego nie możemy go wyeliminować jako argumentu, takiego jak Java, i zamiast tego mieć słowo kluczowe

Chciałbym również dodać, że opcjonalny selfargument pozwala mi deklarować metody statyczne wewnątrz klasy, nie piszącself .

Przykłady kodu:

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 : Działa to tylko w Pythonie 3.x.

W poprzednich wersjach musisz jawnie dodać @staticmethoddekorator, w przeciwnym razie selfargument jest obowiązkowy.

Dziwię się, że nikt nie wychował Lui. Lua używa również zmiennej „self”, jednak można ją pominąć, ale nadal jest używana. C ++ robi to samo z „tym”. Nie widzę żadnego powodu, by zadeklarować „jaźń” w każdej funkcji, ale nadal powinieneś być w stanie używać jej tak, jak możesz to zrobić w przypadku Lua i C ++. W przypadku języka, który szczyci się swoją krótkością, to dziwne, że wymaga zadeklarowania zmiennej własnej.

Spójrz na następujący przykład, który jasno wyjaśnia cel 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 jest używany / potrzebny do rozróżnienia między instancjami.

Źródło: własna zmienna w Pythonie wyjaśniona - Pythontips

Jest tak, ponieważ sposób, w jaki został zaprojektowany Python, alternatywy raczej by nie działały. Python został zaprojektowany tak, aby umożliwić definiowanie metod lub funkcji w kontekście, w którym nie działałyby ani ukryte this(a-la Java / C ++) ani jawne @(a-la ruby). Weźmy przykład z jawnym podejściem z konwencjami Pythona:

def fubar(x):
    self.x = x

class C:
    frob = fubar

Teraz fubarfunkcja nie działałaby, ponieważ zakładałaby, że selfjest to zmienna globalna (i frobrównież). Alternatywą byłoby wykonanie metody z zastąpionym zakresem globalnym (gdzieself jest obiekt).

Podejście niejawne byłoby

def fubar(x)
    myX = x

class C:
    frob = fubar

Oznaczałoby to, że myXbyłby interpretowany jako zmienna lokalna w fubar(i frobrównież w). Alternatywą byłoby tutaj wykonanie metod z zastąpionym zakresem lokalnym, który jest zachowywany między wywołaniami, ale wyeliminowałoby to możliwość lokalnych zmiennych metody.

Jednak obecna sytuacja działa dobrze:

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

 class C:
     frob = fubar

tutaj, gdy zostanie wywołany jako metoda frob, otrzyma obiekt, do którego jest wywoływany za pomocą selfparametru, i fubarnadal może być wywoływany z obiektem jako parametrem i działa tak samo ( jest tak samo jak C.frobmyślę).

W __init__metodzie self odnosi się do nowo utworzonego obiektu; w innych metodach klasowych odnosi się do instancji, której metoda została wywołana.

jaźń, jak sama nazwa, to tylko konwencja , nazywaj ją jak chcesz! ale podczas korzystania z niego, na przykład do usuwania obiektu, musisz użyć tej samej nazwy:, __del__(var)gdzievar został użyty w pliku__init__(var,[...])

Powinieneś też rzucić okiem cls, aby uzyskać większy obraz . Ten post może być pomocny.

self działa jak bieżąca nazwa obiektu lub instancja klasy.

# 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 jest nieuniknione.

Było po prostu kwestia powinna selfbyć bezpośrednia lub pośrednia. Guido van Rossumrozwiązałem to pytanie, mówiąc, że selfmusi zostać .

Więc gdzie selfmieszkasz?

Gdybyśmy tylko trzymali się programowania funkcjonalnego, nie potrzebowalibyśmy self. Po wejściu do OOP Python znajdujemyself tam.

Oto typowy przypadek użycia class Ctej metodym1

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

Ten program wyświetli:

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

selfZawiera więc adres pamięci wystąpienia klasy. Celem of selfbyłoby trzymać odniesienia dla metody instancji i dla nas, aby mieć wyraźny dostęp do tego odniesienia.

_{Uwaga: istnieją trzy różne typy metod klasowych:}

• _{metody statyczne (czytaj: funkcje),}
• _{metody klasowe,}
• _{metody instancji (wspomniane).}

z dokumentów ,

szczególną cechą metod jest to, że obiekt instancji jest przekazywany jako pierwszy argument funkcji. W naszym przykładzie połączenie x.f()jest dokładnie równoważne z MyClass.f(x). Zasadniczo wywołanie metody z listą n argumentów jest równoważne z wywołaniem odpowiedniej funkcji z listą argumentów, która jest tworzona przez wstawienie obiektu instancji metody przed pierwszym argumentem.

poprzedni powiązany fragment kodu,

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

    def f(self):
        return 'hello world'

x = MyClass()

jest to wyraźne odniesienie do obiektu instancji klasy.