Зачем мне нужно self перед атрибутом объекта класса в Python? [Дубликат]

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

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; то, что вы пишете, это методы класса, которые должны принимать экземпляр в качестве первого параметра. И поэтому вам нужно будет явно указать параметр экземпляра.

Взгляните на следующий пример, в котором четко объясняется, что цель 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 о self :

Как и в Modula-3, для ссылки на элементы объекта нет сокращений [в Python] из его методов: функция метода объявляется с явным первым аргументом, представляющим объект, который предоставляется неявно вызовом.

Часто первый аргумент метода называется self. Это не что иное, как соглашение: имя «я» совершенно не имеет особого значения для Python. Обратите внимание, однако, что, не соблюдая соглашение, ваш код может быть менее читаемым для других программистов на Python, и также возможно, что программа браузера классов может быть написана, которая опирается на такое соглашение.

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

self является объектной ссылкой на сам объект, поэтому они одинаковы. Методы Python не вызывается в контексте самого объекта. self в Python может использоваться для обработки пользовательских объектных моделей или чего-то еще.

Я продемонстрирую код, который не использует классы:

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 )

[мигрировал мой ответ из дублированного закрытого вопроса]

'self' используется для ссылки на вновь созданный объект.

, например, если вы объявляете метод в классе по умолчанию, он автоматически принимает экземпляр как первый аргумент.

По соглашению мы называем это «я» в файле python.it просто сильное соглашение. Вы можете назвать это другим именем.

Если вы хотите использовать метод, который не нуждается в доступе к себе, используйте staticmethod:

class TestClass():
   @staticmethod
   def staticMethod(other_arg):
        print "This is a static method"

    def instanceMethod(self,other_arg): #This is instance method
        print "self is instance"

    ##If you want access to the class, but not to the instance, use classmethod:

    @classmethod
    def my_class_method(cls, other_arg):
        print "this is a class method"

Он должен следовать за Python zen «явный лучше, чем неявный». Это действительно ссылка на ваш объект класса. Например, в Java и PHP он называется this.

Если user_type_name является полем вашей модели, вы получаете доступ к нему через self.user_type_name.

это явная ссылка на объект экземпляра класса.

Это потому, что, кстати, дизайн python вряд ли сработает. 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, я думаю).