Python __init__ и сам, что они делают?

Я изучаю язык программирования Python, и я наткнулся на то, что я не совсем понимаю.

В способе, например:

def method(self, blah): def __init__(?): .... .... 

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

Что делает метод __init__ ? Почему это необходимо? (и т.д.)

Я думаю, что они могут быть конструкциями ООП, но я не очень-то знаю.

15 Solutions collect form web for “Python __init__ и сам, что они делают?”

В этом коде:

 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') ) также передаются в качестве аргументов – в этом случае вызывают исключение, поскольку конструктор их не ожидает.

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

__init__ является конструктором для класса. Параметр self относится к экземпляру объекта (например, на 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 (доступные для жизни объекта).

Краткий иллюстративный пример

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

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

Вкратце:

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

__init__ действует как конструктор. Вам нужно передать «я» любым функциям класса в качестве первого аргумента, если вы хотите, чтобы они вели себя как нестатические методы. «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') 

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

Когда мы обращаемся к атрибутам объекта, мы делаем это по имени (или по ссылке). Здесь экземпляр является ссылкой на наш новый объект. Мы обращаемся к методу 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 , он используется для установки значений по умолчанию, если никакие другие функции из этого класса не вызываются.

«Я» – это ссылка на экземпляр класса

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

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

 f = foo() f.bar() 

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

 f = foo() foo.bar(f) 

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

 class foo: def bar(s): print "hi" 
  1. __init__ – это в основном функция, которая «инициализирует» / «активирует» свойства класса для определенного объекта, создавая и сопоставляя соответствующий класс.
  2. self представляет этот объект, который наследует эти свойства.

Вы были бы правы, они объектно-ориентированные конструкции. В основном self – это ссылка (вроде как указатель, но self – специальная ссылка, которую вы не можете назначить) объекту, а __init__ – это функция, которая вызывается для инициализации объекта, то есть задает значения переменные и т. д. – сразу после выделения памяти.

В этом коде:

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

 # Source: Class and Instance Variables # https://docs.python.org/2/tutorial/classes.html#class-and-instance-variables class MyClass(object): # class variable my_CLS_var = 10 # sets "init'ial" state to objects/instances, use self argument def __init__(self): # self usage => instance variable (per object) self.my_OBJ_var = 15 # also possible, class name is used => init class variable MyClass.my_CLS_var = 20 def run_example_func(): # PRINTS 10 (class variable) print MyClass.my_CLS_var # executes __init__ for obj1 instance # NOTE: __init__ changes class variable above obj1 = MyClass() # PRINTS 15 (instance variable) print obj1.my_OBJ_var # PRINTS 20 (class variable, changed value) print MyClass.my_CLS_var run_example_func() 

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

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

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

Поэтому, когда мы говорим, что def take (self, amount) :, мы говорим: «Вот как вы снимаете деньги с объекта Customer (который мы будем называть« я ») и цифры в долларах (которые мы будем называть суммой). это экземпляр клиента, на который вызывается вызов. Это не я тоже делаю аналогию. 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__

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

  • Какова цель внутренних классов питона?
  • Проблемы с пониманием передачи значений и ссылок в Python
  • Мне нужно узнать об объектах, или я могу сэкономить время и просто изучить словари?
  • Переопределение переменных класса в python
  • Является ли хорошей идеей использовать класс в качестве пространства имен в Python
  • Являются ли интерфейсы просто «синтаксическим сахаром»?
  • Как объявить значения по умолчанию для переменных экземпляра в Python?
  • Перегрузка метода для разных типов аргументов в python
  • Сравнение возможностей Python и Smalltalk - Metaprogramming
  • Наследование класса в python
  • Инициализировать все классы в модуле в безымянные объекты в списке
  • Python - лучший язык программирования в мире.