Яке призначення слова "Я"?

Яке призначення selfслова в Python? Я розумію, це стосується конкретного об'єкта, створеного з цього класу, але я не можу зрозуміти, чому його явно потрібно додавати до кожної функції в якості параметра. Для ілюстрації, в Ruby я можу це зробити:

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

Що я розумію, досить легко. Однак у Python мені потрібно включити self:

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

Хтось може поговорити зі мною через це? Це не те, що я зіткнувся зі своїм (правда, обмеженим) досвідом.

Причина, яку потрібно використовувати, self.полягає в тому, що Python не використовує @синтаксис для позначення атрибутів екземпляра. Python вирішив зробити методи таким чином, щоб примірник, до якого належить метод, передається автоматично, але не отримується автоматично: перший параметр методів - це екземпляр, на який викликається метод. Це робить методи абсолютно такими ж, як і функції, і залишає власне ім’я використовувати для вас (хоча selfце умова, і люди, як правило, нахмуриться на вас, коли ви використовуєте щось інше.) selfКод не є спеціальним, це просто інший об'єкт .

Python міг би зробити щось інше, щоб відрізнити звичайні імена від атрибутів - спеціальний синтаксис, як у Ruby, або вимагаючи декларацій, таких як C ++ та Java, або, можливо, ще щось інше - але це не так. Python - все для того, щоб зробити речі чіткими, зробити очевидним, що саме робити, і хоча це робить не цілком скрізь, він робить це, наприклад, атрибутами. Ось чому при призначенні атрибуту екземпляра потрібно знати, якому екземпляру призначити, і саме тому він потрібен self..

Візьмемо простий векторний клас:

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

Ми хочемо мати метод, який обчислює довжину. Як це виглядатиме, якби ми хотіли визначити це всередині класу?

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

Як він повинен виглядати, коли ми мали б визначити це як глобальний метод / функцію?

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

Отже вся структура залишається однаковою. Як я можу цим скористатися? Якщо припустити на мить, що ми не написали lengthметод для нашого Vectorкласу, ми могли б зробити це:

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

Це працює, тому що перший параметр length_global, може бути використаний повторно як selfпараметр в length_new. Це було б неможливо без явного self.

Інший спосіб зрозуміти необхідність явного self- бачити, куди Python додає синтаксичний цукор. Коли ви пам’ятаєте, що це, в основному, дзвінок на кшталт

v_instance.length()

внутрішньо трансформується в

Vector.length(v_instance)

легко зрозуміти, куди selfпідходить. Ви фактично не пишете методи екземпляра в Python; що ви пишете - це методи класу, які повинні приймати екземпляр як перший параметр. Отже, вам доведеться розмістити параметр екземпляра десь явно.

Скажімо, у вас клас, ClassAякий містить метод, methodAвизначений як:

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

і ObjectA є екземпляром цього класу.

Тепер, коли ObjectA.methodA(arg1, arg2)викликається, python внутрішньо перетворює його для вас як:

ClassA.methodA(ObjectA, arg1, arg2)

selfМінлива відноситься до самого об'єкта.

Коли об'єкти інстанціюються, сам об'єкт передається в параметр self.

Через це дані об'єкта прив’язані до об'єкта. Нижче наведено приклад того, як ви могли б хотіти візуалізувати, як можуть виглядати дані кожного об’єкта. Зверніть увагу, як "self" замінено на ім'я об'єктів. Я не кажу, що наведена нижче схема прикладу є абсолютно точною, але, сподіваємось, вона служить цілі у візуалізації використання себе.

Об'єкт передається в параметр self, щоб об'єкт міг зберігати власні дані.

Хоча це може бути не зовсім точно, подумайте про процес інстанції об'єкта таким чином: Коли об’єкт зроблений, він використовує клас як шаблон для власних даних та методів. Без передачі власного імені в параметр self, атрибути та методи у класі залишатимуться як загальний шаблон і не посилаються на (належать) об'єкту. Таким чином, передаючи ім'я об'єкта в параметр self, це означає, що якщо 100 об'єктів примірники з одного класу, всі вони можуть відслідковувати власні дані та методи.

Дивіться ілюстрацію нижче:

Мені подобається цей приклад:

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

Я продемонструю за допомогою коду, що який не використовує класи :

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'

Класи - це лише спосіб уникнути переходу в цю "стан" річ весь час (та інші приємні речі, такі як ініціалізація, склад класу, рідко потрібні метакласи та підтримка користувальницьких методів для переосмислення операторів).

Тепер давайте продемонструємо наведений вище код за допомогою вбудованої машини класу python, щоб показати, як це в основному те саме.

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 )

[мігрував мою відповідь із дубліката закритого запитання]

Наступні уривки з документації про себе на Python :

Як і в Modula-3, не існує скорочень [у Python] для посилання членів об'єкта з його методами: функція методу оголошується явним першим аргументом, що представляє об'єкт, який надається неявно викликом.

Часто перший аргумент методу називається self. Це не що інше, як умова: сам ім'я абсолютно не має особливого значення для Python. Однак зауважте, що, не дотримуючись конвенції, ваш код може бути менш читабельним для інших програмістів Python, а також можливо, що може бути написана програма браузера класів, яка покладається на таку конвенцію.

Для отримання додаткової інформації дивіться навчальний посібник з документацією Python про класи .

Як і всі інші причини, вже зазначені, це дозволяє полегшити доступ до перекритих методів; можна зателефонуватиClass.some_method(inst) .

Приклад того, де це корисно:

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"

Його використання подібне до використання thisключового слова на Java, тобто для посилання на поточний об'єкт.

Python - це не мова, побудована для об'єктно-орієнтованого програмування на відміну від Java або C ++.

Викликаючи статичний метод у Python, просто записується метод із регулярними аргументами всередині нього.

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

Однак об’єктному методу, який вимагає від вас зробити змінну, яка є твариною, в цьому випадку потрібен аргумент self

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

Метод self використовується також для позначення змінного поля в класі.

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


    def getAnimalName(self):
        return self.animalName

У цьому випадку self посилається на змінну animalName усього класу. ПАМ’ЯТАЙТЕ: Якщо у вас є змінна в межах методу, самодоступ не працюватиме. Ця змінна просто існує лише під час запуску цього методу. Для визначення полів (змінних усього класу) ви повинні визначити їх ВНІШНЯМИ методи класу.

Якщо ви не розумієте жодного слова того, що я говорю, то Google "Об'єктно-орієнтоване програмування". Коли ви це зрозумієте, вам навіть не потрібно буде ставити це питання :).

Тут слід дотримуватися Python zen "явне краще, ніж неявне". Це справді посилання на ваш об’єкт класу. Наприклад, у Java та PHP це називається this.

Якщо user_type_nameце поле на вашій моделі, ви отримуєте доступ до нього self.user_type_name.

Перш за все, self - це звичайна назва, ви можете поставити що-небудь інше (будучи узгодженим) замість нього.

Він посилається на сам об’єкт, тому коли ви його використовуєте, ви заявляєте, що .name та .age є властивостями об'єктів Student (примітка, а не для класу Student), які ви збираєтеся створити.

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

Код тут

selfє посиланням на сам об'єкт, тому вони однакові. Методи Python не викликаються в контексті самого об'єкта. selfв Python може використовуватися для роботи з користувацькими моделями об'єктів або чимось подібним.

Використання аргументу, умовно названого self , не так важко зрозуміти, як це необхідно? Або щодо того, чому це прямо згадують? Це, мабуть, є більшою проблемою для більшості користувачів, які розглядають це питання, або якщо це не так, у них, безумовно, виникне те саме питання, що вони рухаються вперед, вивчаючи пітон. Я рекомендую їм прочитати ці кілька блогів:

1: Використання самостійно поясненого

Зауважте, що це не ключове слово.

Перший аргумент кожного методу класу, включаючи init, завжди є посиланням на поточний екземпляр класу. За умовою, цей аргумент завжди називають «я». У методі init self посилається на новостворений об'єкт; в інших методах класу він посилається на екземпляр, метод якого називався. Наприклад, наведений нижче код такий же, як і вищезгаданий код.

2: Чому у нас це так і чому ми не можемо усунути це як аргумент, як Java, і натомість мати ключове слово

Ще одне, що я хотів би додати, це те, що необов’язковий selfаргумент дозволяє мені оголошувати статичні методи всередині класу, не пишучи self.

Приклади коду:

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 : Це працює лише в Python 3.x.

У попередніх версіях ви повинні явно додати @staticmethodдекоратор, інакше selfаргумент обов'язковий.

Я здивований, що Луа ніхто не виховував. Lua також використовує змінну "self", однак її можна опустити, але все ще використовувати. C ++ робить те ж саме, що і "це". Я не бачу жодної причини заявляти про "власну" у кожній функції, але ви все одно можете використовувати її так само, як ви можете з Lua та C ++. Для мови, яка пишається тим, що вона є короткою, дивно, що вона вимагає від вас оголосити змінну self.

Погляньте на наступний приклад, який чітко пояснює мету 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 використовується / потрібна для розмежування між примірниками.

Джерело: сама змінна в поясненому python - Pythontips

Це тому, що, наскільки розроблений пітон, альтернативи навряд чи спрацюють. Python розроблений для того, щоб дозволяти визначати методи або функції в контексті, коли ні неявна this(a-la Java / C ++), ні явна @(a-la ruby) не працюватиме. Наведемо приклад з явним підходом з умовами python:

def fubar(x):
    self.x = x

class C:
    frob = fubar

Тепер fubarфункція не буде працювати, оскільки передбачається, що selfце глобальна змінна (і в frobтому числі). Альтернативою було б виконання методів із заміненою глобальною областю (де selfоб'єкт).

Явний підхід був би

def fubar(x)
    myX = x

class C:
    frob = fubar

Це означатиме, що myXінтерпретується як локальна змінна в fubar(і frobтакож). Альтернативою тут було б виконання методів із заміненою локальною областю, яка зберігається між викликами, але це видалило б можливість локальних змінних методу.

Однак нинішня ситуація добре працює:

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

 class C:
     frob = fubar

тут при виклику як метод frobотримає об'єкт , на якому він викликається через selfпараметр, і fubarвсе ще може бути викликаний з об'єктом в якості параметра і працювати так само (він є таким же , як C.frobя думаю).

У __init__методі «self» посилається на новостворений об’єкт; в інших методах класу він посилається на екземпляр, метод якого називався.

Я, як ім'я, - це лише умова , називайте його як хочете! але, використовуючи його, наприклад, для видалення об'єкта, ви повинні використовувати те саме ім'я:, __del__(var)де varбуло використано в__init__(var,[...])

Ви також повинні поглянути на clsце, щоб мати більшу картину . Ця публікація може бути корисною.

self діє так, як поточне ім'я об'єкта або екземпляр класу.

# 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 неминуче.

Було просто питання, яке має selfбути неявним або явним. Guido van Rossumвирішивши це питання, сказавши, що selfвін повинен залишатися .

То де selfжити?

Якби ми просто дотримувались функціонального програмування, нам це б не потрібно self. Як тільки ми входимо в Python OOP ми знаходимоself там.

Ось типовий випадок class Cвикористання методу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

Ця програма виведе:

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

Так selfзберігається адреса пам'яті екземпляра класу. Мета в selfтому, щоб містити посилання на методи екземпляра і для нас , щоб мати явний доступ до цим посиланням.

_{Зауважте, що існує три різних типи методів класу:}

• _{статичні методи (читання: функції),}
• _{методи класу,}
• _{екземплярні методи (згадані).}

від документів ,

особливість у методах полягає в тому, що об'єкт екземпляра передається як перший аргумент функції. У нашому прикладі виклик x.f()точно рівносильний MyClass.f(x). Взагалі, виклик методу зі списком n аргументів еквівалентний виклику відповідної функції зі списком аргументів, який створюється вставкою об'єкта екземпляра методу перед першим аргументом.

перед цим пов'язаний фрагмент,

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

    def f(self):
        return 'hello world'

x = MyClass()

це явна посилання на об'єкт екземпляра класу.