Что __init__ и self делают в Python?

В этом коде:

class A(object):
    def __init__(self):
        self.x = 'Hello'

    def method_a(self, foo):
        print self.x + ' ' + foo

... переменная self представляет экземпляр самого объекта. Большинство объектно-ориентированных языков передают это как скрытый параметр методам, определенным для объекта; Python - нет. Вы должны заявить об этом явно. Когда вы создаете экземпляр класса A и вызываете его методы, он будет передан автоматически, как в ...

a = A()               # We do not pass any argument to the __init__ method
a.method_a('Sailor!') # We only pass a single argument

Метод __init__ - это примерно то, что представляет собой конструктор в Python. Когда вы вызываете A(), Python создает для вас объект и передает его в качестве первого параметра методу __init__. Любые дополнительные параметры (например, A(24, 'Hello')) также будут переданы как аргументы - в этом случае вызывается исключение, поскольку конструктор их не ожидает.

Да, вы правы, это конструкции oop.

__init__ - конструктор класса. Параметр self относится к экземпляру объекта (например, this в C ++).

class Point:
    def __init__(self, x, y):
        self._x = x
        self._y = y

Метод __init__ вызывается после выделения памяти для объекта:

x = Point(1,2)

Важно использовать параметр self внутри метода объекта, если вы хотите сохранить значение с объектом. Если, например, вы реализуете метод __init__ следующим образом:

class Point:
    def __init__(self, x, y):
        _x = x
        _y = y

Ваши параметры x и y будут храниться в переменных в стеке и будут отброшены, когда метод init выходит за пределы области видимости. Установка этих переменных как self._x и self._y устанавливает эти переменные как члены объекта Point (доступные в течение всего времени существования объекта).

Примечание. Некоторое разъяснение использования слова конструктор в этом ответе. Технически обязанности конструктора в Python разделены на два метода. Эти методы __new__ (отвечают за выделение памяти) и __init__ (как обсуждается здесь, отвечают за инициализацию вновь созданного экземпляра).

Краткий наглядный пример

В надежде, что это может немного помочь, вот простой пример, который я использовал, чтобы понять разницу между переменной, объявленной внутри класса, и переменной, объявленной внутри функции __init__:

class MyClass(object):
    i = 123
    def __init__(self):
        self.i = 345
     
a = MyClass()
print(a.i)
print(MyClass.i)

Выход:

345
123

Суммируя:

1. self, как предполагается, относится к самому - объекту, который вызвал метод. То есть, если у вас есть N объектов, вызывающих метод, тогда self.a будет ссылаться на отдельный экземпляр переменной для каждого из N объектов. Представьте N копий переменной a для каждого объекта.
2. __init__ - это то, что называется конструктором в других языках ООП, таких как C ++ / Java. Основная идея заключается в том, что это специальный метод, который автоматически вызывается при создании объекта этого класса.

Объекты класса поддерживают два типа операций: ссылки на атрибуты и создание экземпляров.

Ссылки на атрибуты используют стандартный синтаксис, используемый для всех ссылок на атрибуты в Python: obj.name. Допустимые имена атрибутов - это все имена, которые были в пространстве имен класса при создании объекта класса. Итак, если определение класса выглядело так:

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

    def f(self):
        return 'hello world'

тогда MyClass.i и MyClass.f - допустимые ссылки на атрибуты, возвращающие целое число и объект функции соответственно. Атрибуты класса также могут быть присвоены, поэтому вы можете изменить значение MyClass.i путем присвоения. __doc__ также является допустимым атрибутом, возвращающим строку документации, принадлежащую классу: «Простой пример класса».

Создание экземпляра класса использует обозначение функций. Просто представьте, что объект класса - это функция без параметров, которая возвращает новый экземпляр класса. Например:

x = MyClass()

Операция создания экземпляра («вызов» объекта класса) создает пустой объект. Многие классы любят создавать объекты с экземплярами, настроенными для определенного начального состояния. Поэтому класс может определять специальный метод с именем __init__(), например:

def __init__(self):
    self.data = []

Когда класс определяет метод __init__(), создание экземпляра класса автоматически вызывает __init__() для вновь созданного экземпляра класса. Итак, в этом примере новый инициализированный экземпляр может быть получен следующим образом:

x = MyClass()

Конечно, у метода __init__() могут быть аргументы в пользу большей гибкости. В этом случае аргументы, данные оператору создания экземпляра класса, передаются __init__(). Например,

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart

x = Complex(3.0, -4.5)
x.r, x.i

Взято из официальной документации, которая в итоге мне очень помогла.

Вот мой пример

class Bill():
    def __init__(self,apples,figs,dates):
        self.apples = apples
        self.figs = figs
        self.dates = dates
        self.bill = apples + figs + dates
        print ("Buy",self.apples,"apples", self.figs,"figs 
                and",self.dates,"dates. 
                Total fruitty bill is",self.bill," pieces of fruit :)")

Когда вы создаете экземпляр класса Bill:

purchase = Bill(5,6,7)

Ты получаешь:

> Buy 5 apples 6 figs and 7 dates. Total fruitty bill is 18  pieces of
> fruit :)

__init__ действует как конструктор. Вам нужно будет передать «self» любым функциям класса в качестве первого аргумента, если вы хотите, чтобы они вели себя как нестатические методы. «self» - это переменные экземпляра для вашего класса.

Попробуйте этот код. Надеюсь, это поможет многим программистам на C, таким как я, выучить Py.

#! /usr/bin/python2

class Person:

    '''Doc - Inside Class '''

    def __init__(self, name):
        '''Doc - __init__ Constructor'''
        self.n_name = name        

    def show(self, n1, n2):
        '''Doc - Inside Show'''
        print self.n_name
        print 'Sum = ', (n1 + n2)

    def __del__(self):
        print 'Destructor Deleting object - ', self.n_name

p=Person('Jay')
p.show(2, 3)
print p.__doc__
print p.__init__.__doc__
print p.show.__doc__

Выход:

Jay

Sum = 5

Doc - Inside Class

Doc - __init__ Constructor

Doc - Inside Show

Destructor Deleting object - Jay

У меня были проблемы с пониманием этого. Даже прочитав здесь ответы.

Чтобы правильно понять метод __init__, вам нужно понять себя.

Самостоятельный параметр

Аргументы, принимаемые методом __init__:

def __init__(self, arg1, arg2):

Но на самом деле мы передаем ему только два аргумента:

instance = OurClass('arg1', 'arg2')

Откуда появился лишний аргумент?

Когда мы получаем доступ к атрибутам объекта, мы делаем это по имени (или по ссылке). Здесь instance - это ссылка на наш новый объект. Мы получаем доступ к методу printargs объекта экземпляра, используя instance.printargs.

Чтобы получить доступ к атрибутам объекта из метода __init__, нам нужна ссылка на объект.

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

Это означает, что в методе __init__ мы можем:

self.arg1 = arg1
self.arg2 = arg2

Здесь мы устанавливаем атрибуты объекта. Вы можете проверить это, выполнив следующие действия:

instance = OurClass('arg1', 'arg2')
print instance.arg1
arg1

такие значения известны как атрибуты объекта. Здесь метод __init__ устанавливает атрибуты arg1 и arg2 экземпляра.

источник: http://www.voidspace.org.uk/python/articles/OOP.shtml#the-init-method

обратите внимание, что self на самом деле может быть любым допустимым идентификатором Python. Например, мы могли бы так же легко написать из примера Криса Б.

class A(object):
    def __init__(foo):
        foo.x = 'Hello'

    def method_a(bar, foo):
        print bar.x + ' ' + foo

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

Что делает сам? Что это означает? Это обязательно?

Первый аргумент каждого метода класса, включая init, всегда является ссылкой на текущий экземпляр класса. По соглашению этот аргумент всегда называется self. В методе инициализации self относится к вновь созданному объекту; в других методах класса он относится к экземпляру, метод которого был вызван.

Python не заставляет вас использовать "self". Вы можете дать ему любое имя. Но помните, что первый аргумент в определении метода - это ссылка на объект. Python добавляет в список аргумент self; вам не нужно включать его при вызове методов. если вы не указали self в методе инициализации, вы получите сообщение об ошибке

TypeError: __init___() takes no arguments (1 given)

Что делает метод init? Зачем это нужно? (так далее.)

init - это сокращение от инициализации. Это конструктор, который вызывается, когда вы создаете экземпляр класса, и в этом нет необходимости. Но обычно мы пишем метод инициализации для установки состояния объекта по умолчанию. Если вы не хотите изначально устанавливать какое-либо состояние объекта, вам не нужно писать этот метод.

1. __init__ - это, по сути, функция, которая будет "инициализировать" / "активировать" свойства класса для определенного объекта, после создания и сопоставления с соответствующий класс ..
2. self представляет тот объект, который унаследует эти свойства.

По сути, вам нужно использовать ключевое слово self при использовании переменной в нескольких функциях одного класса. Что касается init, он используется для установки значений по умолчанию, если никакие другие функции из этого класса не вызываются.

Просто демонстрация вопроса.

class MyClass:

    def __init__(self):
        print('__init__ is the constructor for a class')

    def __del__(self):
        print('__del__ is the destructor for a class')

    def __enter__(self):
        print('__enter__ is for context manager')
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print('__exit__ is for context manager')

    def greeting(self):
        print('hello python')


if __name__ == '__main__':
    with MyClass() as mycls:
        mycls.greeting()

$ python3 class.objects_instantiation.py
__init__ is the constructor for a class
__enter__ is for context manager
hello python
__exit__ is for context manager
__del__ is the destructor for a class

"Я" - это ссылка на экземпляр класса.

class foo:
    def bar(self):
            print "hi"

Теперь мы можем создать экземпляр foo и вызвать на нем метод, в этом случае Python добавляет параметр self:

f = foo()
f.bar()

Но его также можно передать, если вызов метода не находится в контексте экземпляра класса, код ниже делает то же самое.

f = foo()
foo.bar(f)

Интересно, что имя переменной «self» - это просто соглашение. Приведенное ниже определение будет работать точно так же. Сказав, что это очень строгая конвенция, которой следует придерживаться всегда, но в нем кое-что говорится о гибкости языка.

class foo:
    def bar(s):
            print "hi"

В этом коде:

class Cat:
    def __init__(self, name):
        self.name = name
    def info(self):
        print 'I am a cat and I am called', self.name

Здесь __init__ действует как конструктор для класса, и когда создается экземпляр объекта, вызывается эта функция. self представляет объект, создающий экземпляр.

c = Cat('Kitty')
c.info()

Результат вышеупомянутых утверждений будет следующим:

I am a cat and I am called Kitty

Здесь парень написал довольно хорошо и просто: https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriated-программирование/

Прочтите ссылку выше как ссылку на это:

self? Так что же с этим параметром self для всех методов Customer? Что это? Да это же экземпляр, конечно! Другими словами, такой метод, как снятие, определяет инструкции по снятию денег со счета некоторого абстрактного клиента. Вызов jeff.withdraw (100.0) помещает эти инструкции в экземпляр jeff.

Поэтому, когда мы говорим def removew (self, amount) :, мы говорим: «Вот как вы снимаете деньги с объекта Customer (который мы назовем self) и суммы в долларах (которую мы назовем суммой). Self - это экземпляр клиента, который вызывает вывод средств. Я тоже не собираюсь проводить аналогии. jeff.withdraw (100.0) - это просто сокращение от Customer.withdraw (jeff, 100.0), что совершенно верно (если не часто) код.

init self может иметь смысл для других методов, но как насчет init? Когда мы вызываем init, мы находимся в процессе создания объекта, так как может уже существовать самость? Python позволяет нам расширить собственный шаблон до тех пор, пока не создаются объекты, даже если он не совсем подходит. Только представьте, что jeff = Customer ('Jeff Knupp', 1000.0) - это то же самое, что вызов jeff = Customer (jeff, 'Jeff Knupp', 1000.0); переданный джефф также становится результатом.

Вот почему, когда мы вызываем init, мы инициализируем объекты, говоря такие вещи, как self.name = name. Помните, поскольку экземпляр self - это эквивалент слова jeff.name = name, что совпадает с jeff.name = 'Jeff Knupp. Аналогично, self.balance = balance совпадает с jeff.balance = 1000.0. После этих двух строк мы считаем объект Customer "инициализированным" и готовым к использованию.

Будьте осторожны в своих __init__

После завершения init вызывающий может предположить, что объект готов к использованию. То есть, после того, как jeff = Customer ('Jeff Knupp', 1000.0), мы можем начать делать депозит и снимать звонки на jeff; jeff - полностью инициализированный объект.

Python __init__ и self что они делают?

Что делает self? Что это должно быть? Это обязательно?

Что делает метод __init__? Зачем это нужно? (так далее.)

Приведенный пример неверен, поэтому позвольте мне создать на его основе правильный пример:

class SomeObject(object):

    def __init__(self, blah):
        self.blah = blah

    def method(self):
        return self.blah 

Когда мы создаем экземпляр объекта, вызывается __init__ для настройки объекта после его создания. То есть, когда мы вызываем SomeObject с 'blah' ниже (что может быть любым), он передается в функцию __init__ в качестве аргумента blah:

an_object = SomeObject('blah')

Аргумент self - это экземпляр SomeObject, который будет назначен an_object.

Позже мы можем захотеть вызвать метод для этого объекта:

an_object.method()

Выполнение точечного поиска, то есть an_object.method, привязывает экземпляр к экземпляру функции, и метод (как указано выше) теперь является «связанным» методом - что означает, что нам не нужно явно передавать экземпляр методу. вызов.

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

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

__init__ - это особый метод, задокументированный в документации по модели данных Python. Он вызывается сразу после создания экземпляра (обычно через __new__ - хотя __new__ не требуется, если вы не создаете подкласс неизменяемого типа данных).