Jaki jest cel słowa "Ja"?

Załóżmy, że masz klasę ClassA, która zawiera metodę methodA zdefiniowaną jako:

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

I ObjectA jest instancją tej klasy.

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

ClassA.methodA(ObjectA, arg1, arg2)

Zmienna self odnosi się do samego obiektu.

Weźmy prostą klasę wektorową:

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

Chcemy mieć metodę, która oblicza długość. Jak by to wyglądało, gdybyśmy chcieli zdefiniować to wewnątrz klasy?

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

Jak powinna ona wyglądać, gdy mamy ją zdefiniować jako globalną metodę / funkcję?

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

Więc cała struktura pozostaje taka sama. Jak mogę z tego skorzystać? Jeśli założymy przez chwilę, że nie napisaliśmy metody length dla naszej klasy Vector, możemy zrobić to:

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

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

Innym sposobem zrozumienia potrzeby jawnego self jest sprawdzenie, gdzie Python dodaje trochę cukru składniowego. Kiedy masz na uwadze, że w zasadzie, połączenie jak

v_instance.length()

Jest wewnętrznie przekształcane do

Vector.length(v_instance)

Łatwo zobaczyć, gdzie self pasuje. Nie piszesz metody instancji w Pythonie; to, co piszesz, to metody klas, które muszą przyjmować instancję jako pierwszy parametr. W związku z tym, będziesz musiał umieścić parametr instancji gdzieś jawnie.

Gdy obiekty są utworzone, sam obiekt jest przekazywany do parametru self.

Z tego powodu DANE obiektu są powiązane z obiektem. Poniżej znajduje się przykład wizualizacji danych każdego obiektu. Zauważ, jak 'self' jest zastępowany nazwą obiektów. Nie mówię, że poniższy przykładowy diagram jest całkowicie dokładny, ale mam nadzieję, że służy celowi w wizualizacji użycia siebie.

Obiekt jest przekazywane do parametru self tak, że obiekt może przechowywać własne dane.

Chociaż może to nie być do końca dokładne, pomyśl o procesie tworzenia instancji obiektu w taki sposób: gdy obiekt jest tworzony, używa klasy jako szablonu dla własnych danych i metod. Bez przeniesienia własnej nazwy do parametru self, atrybuty i metody w klasie pozostaną ogólnym szablonem i nie będą odwoływane do obiektu (należą do niego). Więc podając nazwę obiektu do parametru self oznacza to, że jeżeli z jednej klasy zostanie utworzonych 100 obiektów, wszystkie 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: []

Zademonstruję kodem, że nie używa 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ą po prostu sposobem na uniknięcie przechodzenia przez ten" stan " cały czas (i inne miłe rzeczy, takie jak inicjalizacja, skład klas, rzadko potrzebne metaklasy i wspieranie niestandardowych metod do nadpisywania operatorów).

Teraz zademonstrujmy powyższy kod przy użyciu wbudowanej maszyny klasy python, aby pokazać, że jest to zasadniczo 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 )

[Przenieś moją odpowiedź z duplicate pytanie zamknięte]

Poniższe fragmenty pochodzą z dokumentacji Pythona O self:

Podobnie jak w Modula-3, nie ma skrótów [w Pythonie] do odwoływania się do członków obiektu z jego metod: funkcja metody jest deklarowana z jawnym pierwszym argumentem reprezentującym obiekt, który jest dostarczany domyślnie przez wywołanie.

Często pierwszy argument metody nazywa się self. To nic innego jak Konwencja: nazwa jaźń nie ma absolutnie żadnego szczególnego znaczenia dla Python. Zauważ jednak, że nie przestrzegając konwencji Twój kod może być mniej czytelny dla innych programistów Pythona, i jest również możliwe, że napisany zostanie program do przeglądania klas, który opiera się na takiej konwencji.

Więcej informacji można znaleźć w samouczku dokumentacji Pythona na temat klas .

Jak również wszystkie inne powody już podane, pozwala na łatwiejszy dostęp do nadpisanych metod; można wywołać Class.some_method(inst).

Przykład, gdzie jest przydatny:

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 słowa kluczowego this w Javie, tzn. do podania odniesienia do bieżącego obiektu.

Python nie jest językiem zbudowanym do programowania obiektowego w przeciwieństwie do Javy czy C++.

Podczas wywoływania statycznej metody w Pythonie, po prostu pisze się metodę z regularnymi argumentami wewnątrz niej.

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

Jednak metoda obiektowa, która wymaga utworzenia zmiennej, która jest zwierzęciem, w tym przypadku, wymaga argumentu self

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

Metoda self jest również używana do odwoływania się do pola zmiennej 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 animalName zmienna całej klasy. Pamiętaj: jeśli masz zmienną w metodzie, self nie będzie działać. Ta zmienna istnieje tylko wtedy, gdy ta metoda jest uruchomiona. Do definiowania pól (zmiennych całej klasy) należy zdefiniować je poza metodami klasy.

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

self jest obiektem odniesienia do samego obiektu, dlatego są one takie same. Metody Pythona nie są wywoływane w kontekście samego obiektu. self w Pythonie mogą być używane do obsługi niestandardowych modeli obiektowych lub czegoś takiego.

Jest tam, aby podążać za Pythonowym zen "explicit is better than implicit". To rzeczywiście odniesienie do Twojego obiektu klasowego. Na przykład w Javie i PHP nazywa się this.

Jeśli user_type_name jest polem w twoim modelu, uzyskujesz do niego dostęp przez self.user_type_name.

Po pierwsze, self jest konwencjonalną nazwą, można umieścić w jej miejsce cokolwiek innego (będąc spójnym).

Odnosi się do samego obiektu, więc kiedy go używasz, deklarujesz, że. name i .wiek to właściwości obiektów uczniowskich (uwaga, a nie Klasy uczniowskiej), 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

Dziwię się, że nikt nie wspomniał o Lua. Lua używa również zmiennej' self', jednak można ją pominąć, ale nadal używać. C++ robi to samo z 'this'. Nie widzę powodu, aby deklarować 'self' w każdej funkcji, ale nadal powinieneś być w stanie używać go tak, jak możesz z lua i C++. Dla języka, który szczyci się zwięzłością, dziwne jest to, że wymaga deklaracji zmiennej self.

Użycie argumentu, konwencjonalnie zwanego self nie jest tak trudne do zrozumienia, dlaczego jest to konieczne? Albo dlaczego wyraźnie o tym wspomnieć? To, jak sądzę, jest większe pytanie dla większości użytkowników, którzy szukają tego pytania, a jeśli nie, z pewnością będą mieli to samo pytanie, ponieważ posuwają się do przodu ucząc się Pythona. Polecam im przeczytać te kilka blogów:

1: Użycie self explained

Zauważ, że nie jest to słowo kluczowe.

Pierwszy argument każdej metody klasy, włączając init, jest zawsze odniesieniem do bieżącej instancji klasy. Zgodnie z konwencją argument ten jest zawsze nazywany self. W metodzie INIT self odnosi się do nowo utworzonego obiektu; w innych metodach klasy 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 argument, jak Java, i mieć słowo kluczowe zamiast

Kolejną rzeczą, którą chciałbym dodać jest to, że opcjonalny argument self pozwala mi deklarować statyczne metody wewnątrz klasy, nie pisząc self.

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

W poprzednich wersjach, musisz jawnie dodać @staticmethod dekorator, w przeciwnym razie self argument jest obowiązkowy.

Spójrz na poniższy 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óżniania instancji.

Source: self variable in python explained-Pythontips

To dlatego, że przy okazji python jest zaprojektowany alternatywy raczej nie będą działać. Python został zaprojektowany, aby umożliwić definiowanie metod lub funkcji w kontekście, w którym zarówno implicit this (A-La Java/C++), jak i explicit @ (A-la ruby) nie będą działać. Weźmy przykład z explicit approach z konwencjami Pythona:

def fubar(x):
    self.x = x

class C:
    frob = fubar

Teraz funkcja fubar nie będzie działać, ponieważ zakłada, że self jest zmienną globalną (a także w frob). Alternatywą byłoby wykonanie metoda ma zastąpiony globalny zakres (gdzie {[6] } jest obiektem).

Implicit podejście będzie

def fubar(x)
    myX = x

class C:
    frob = fubar

Oznaczałoby to, że myX będzie interpretowana jako zmienna lokalna w fubar (a także w frob). Alternatywą w tym przypadku byłoby wykonywanie metod z zastąpionym lokalnym zakresem, który jest zachowany między wywołaniami, ale to usunie możliwość zmiennych lokalnych metody.

Jednak obecna sytuacja działa dobrze:

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

 class C:
     frob = fubar

Tutaj, gdy wywołana jako metoda frob otrzyma obiekt, na którym jest wywołana poprzez parametr self, a fubar może być wywołana z obiektem jako parametrem i działa tak samo (to jest tak samo jak C.frob myślę).

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

Ja, jako imię, jest tylko zjazd, nazywaj to jak chcesz ! ale używając go, na przykład do usunięcia obiektu, musisz użyć tej samej nazwy: __del__(var), Gdzie var zostało użyte w __init__(var,[...])

Należy również spojrzeć na cls, aby mieć the bigger picture. To post to może być pomocne.

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

Było tylko pytanie powinno self być niejawne lub wyraźne. Guido van Rossum rozwiązałem to pytanie mówiąc self musi zostać .

więc gdzie mieszkają self?

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

Oto typowy przypadek użycia class C z metodą m1

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

Tak więc self przechowuje adres pamięci instancji klasy. celem self byłoby posiadanie referencji dla metod instancji i dla nas posiadanie jawnego dostępu do tego referencji.

_{zauważ, że istnieją trzy różne typy metod klasowych:}

• _{metody statyczne (Czytaj: funkcje),}
• _{metody klasowe,}
• _{metody instancji (wymienione).}

Jest to jawne odniesienie do obiektu instancji klasy.

Z docs ,

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

Poprzedzające to powiązane snippet,

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

    def f(self):
        return 'hello world'

x = MyClass()

Powiedziałbym, że przynajmniej dla Pythona parametr self może być traktowany jako symbol zastępczy. Spójrz na to:

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

p1 = Person("John", 36)

print(p1.name)
print(p1.age)

Self w tym przypadku i wielu innych zostało użyte jako metoda, aby powiedzieć, że przechowuje wartość nazwy. Jednak po tym, używamy p1, aby przypisać go do klasy, której używamy. Następnie podczas drukowania używamy tego samego słowa kluczowego p1.

Moje Małe 2 centy]}

W tej klasie osoba, zdefiniowaliśmy INIT metoda z self i interesującą rzeczą do zauważenia tutaj jest miejsce pamięci zarówno self i zmienna instancji p jest taka sama <__main__.Person object at 0x106a78fd0>

class Person:

    def __init__(self, name, age):
        self.name = name 
        self.age = age 

    def say_hi(self):
        print("the self is at:", self)
        print((f"hey there, my name is {self.name} and I am {self.age} years old"))

    def say_bye(self):
        print("the self is at:", self)
        print(f"good to see you {self.name}")

p = Person("john", 78)
print("the p is at",p)
p.say_hi()  
p.say_bye() 

Tak jak wyjaśniono powyżej, zarówno zmienna self, jak i instancja są tym samym obiektem.

Słowo kluczowe "self" zawiera odniesienie do klasy i jest do ciebie, jeśli chcesz jej użyć, ale jeśli zauważysz, że za każdym razem, gdy tworzysz nową metodę w Pythonie, python automatycznie zapisze dla Ciebie słowo kluczowe self. Jeśli wykonasz jakieś badania i rozwój, zauważysz, że jeśli stworzysz dwie metody w klasie i spróbujesz wywołać jedną wewnątrz drugiej, nie rozpoznasz metody, chyba że dodasz self (odniesienie do klasy).

class testA:
def __init__(self):
    print('ads')
def m1(self):
    print('method 1')
    self.m2()
def m2(self):
    print('method 2')

Poniżej znajduje się błąd odniesienia.

class testA:
def __init__(self):
    print('ads')
def m1(self):
    print('method 1')
    m2()  #throws unresolvable reference error as class does not know if m2 exist in class scope
def m2(self):
    print('method 2')

Teraz zobaczmy poniżej przykład

class testA:
def __init__(self):
    print('ads')
def m1(self):
    print('method 1')
def m2():
    print('method 2')

Teraz, kiedy tworzysz obiekt klasy testA, możesz wywołać metodę m1() używając obiektu klasy jak ten, ponieważ metoda m1 () zawiera słowo kluczowe self

obj = testA()
obj.m1()

Ale jeśli chcesz wywołać metodę m2(), ponieważ is nie ma referencji własnej, więc możesz wywołać m2() bezpośrednio używając nazwy klasy jak poniżej

testA.m2()

Ale zachowaj w praktyce, aby żyć ze słowem kluczowym self, ponieważ są też inne korzyści, takie jak tworzenie zmiennej globalnej wewnątrz i tak dalej.