Я изучаю язык программирования Python, и я наткнулся на то, что я не совсем понимаю.
В методе типа:
def method(self, blah):
def __init__(?):
....
....
Что делает self? Что это значит? Обязательно?
Что делает метод __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')) также передаются в качестве аргументов - в этом случае вызывают исключение, поскольку конструктор не ожидает их.
Да, вы правы, это конструкции oop.
__init__ является конструктором для класса. Параметр self относится к экземпляру объекта (например, this в С++).
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(a.i)
print(MyClass.i)
Выход:
345
123
Короче:
self, как он предполагает, ссылается на себя - объект, который вызвал метод. То есть, если у вас есть N объектов, вызывающих метод, то self.a будет ссылаться на отдельный экземпляр переменной для каждого из N объектов. Представьте N копий переменной a для каждого объекта__init__ - это то, что называется конструктором в других языках ООП, таких как С++/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
Ссылки на атрибуты используют стандартный синтаксис, используемый для всех ссылок на атрибуты в Python: obj.name. Допустимыми именами атрибутов являются все имена, которые были в пространстве имен classs при создании объекта класса. Итак, если определение класса выглядело так:
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 :)
обратите внимание, что self действительно может быть любым допустимым идентификатором python. Например, мы могли бы так же легко написать, например, из примера Chris B:
class A(object):
def __init__(foo):
foo.x = 'Hello'
def method_a(bar, foo):
print bar.x + ' ' + foo
и он будет работать точно так же. Однако рекомендуется использовать "я", потому что другие питоны будут легче распознавать его.
В принципе, вам нужно использовать ключевое слово "self" при использовании переменной в нескольких функциях внутри одного класса. Что касается init, он использовал для установки значений по умолчанию, если другие функции из этого класса не вызываются.
__init__ - это в основном функция, которая будет "инициализировать" / "активировать" свойства класса для определенного объекта, после создания и сопоставления с соответствующим классом.self представляет объект, который наследует эти свойства."Я" - это ссылка на экземпляр класса
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"
Вы были бы правы, они объектно-ориентированные конструкции. В основном 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 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()
Что делает сам? Что это значит? Это обязательно?
Первый аргумент каждого метода класса, включая init, всегда является ссылкой на текущий экземпляр класса. По соглашению этот аргумент всегда называется " self. В методе init self ссылается на вновь созданный объект; в других методах класса он ссылается на экземпляр, метод которого был вызван.
Python не заставляет вас использовать " себя ". Вы можете дать ему любое имя. Но помните, что первый аргумент в определении метода - это ссылка на объект. Python добавляет аргумент self в список для вас; вам не нужно включать его при вызове методов. если вы не указали self в методе init, вы получите ошибку
TypeError: __init___() takes no arguments (1 given)
Что делает метод init? Зачем это нужно? (так далее.)
init является коротким для инициализации. Это конструктор, который вызывается, когда вы создаете экземпляр класса, и в этом нет необходимости. Но обычно мы пишем метод init для установки состояния объекта по умолчанию. Если вы не желаете изначально устанавливать какое-либо состояние объекта, вам не нужно писать этот метод.
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, привязывает экземпляр к экземпляру функции, а метод (как было an_object.method выше) теперь является "связанным" методом - это означает, что нам не нужно явно передавать экземпляр в вызов метода.
Вызов метода получает экземпляр, потому что он был связан с точечным поиском, а при вызове выполняет любой код, который был запрограммирован для выполнения.
Неявно передается self рассуждение называется self по соглашению. Мы могли бы использовать любое другое допустимое имя Python, но другие программисты Python, скорее всего, получат смолу и перья, если вы измените его на что-то другое.
__init__ - это специальный метод, описанный в документации по модели данных Python. Он вызывается сразу после создания экземпляра (обычно через __new__ - хотя __new__ не требуется, если вы не __new__ неизменяемый тип данных).
Раздел 9.3 в этот учебник по Python дает краткое введение в основные элементы класса Python: переменные класса, методы класса и роли __init__ и __self__.
Здесь парень написал довольно хорошо и просто: https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/
Прочтите ссылку выше в качестве ссылки на это:
self? Итак, что с этим параметром для всех клиентов методы? Что это? Конечно, это пример! Положите другое метод, такой как отзыв, определяет инструкции для снятия деньги из какой-то абстрактной учетной записи клиента. призвание jeff.withdraw(100.0) помещает эти инструкции для использования на jeff экземпляр.Итак, когда мы говорим, что def def (self, amount):, мы говорим: "вот как вы снимаете деньги с объекта Customer (который мы будем называть самим) и долларовой цифрой (которую мы будем называть суммой). Я - это пример Клиент, который снимает, вызывается. Это не меня аналогий. jeff.withdraw(100.0) является просто сокращением для Customer.withdraw(jeff, 100.0), что совершенно верно (если не часто видел) код.
init сам может иметь смысл для других методов, но как насчет init? Когда мы вызываем init, мы находимся в процессе создания объекта, так как может быть уже само? Python позволяет нам расширять сам шаблон, когда объекты также построены, хотя он не совсем подходит. Только представьте, что jeff = Customer ('Jeff Knupp ', 1000.0) совпадает с вызовом jeff = Customer (jeff,' Jeff Knupp ', 1000,0); в результате получился также jeff.
Вот почему, когда мы вызываем init, мы инициализируем объекты, говоря: такие вещи, как self.name = name. Помните, что, поскольку я - это экземпляр, это эквивалентно выражению jeff.name = name, которое является таким же, как jeff.name = 'Джефф Кнупп. Аналогично, self.balance = баланс одинаковый как jeff.balance = 1000.0. После этих двух строк мы рассмотрим Объект клиента" инициализирован "и готов к использованию.
Будьте осторожны, что вы
__init__После завершения init, вызывающий может по праву предположить, что объект готов к использованию. То есть, после jeff = Customer (" Jeff Knupp", 1000.0), мы можем начать делать депозиты и отзывать звонки в jeff; jeff - полностью инициализированный объект.