[英]What do __init__ and self do in Python?
我正在学习 Python 编程语言，但遇到了一些我不完全理解的东西。
在这样的方法中：
def method(self, blah):
def __init__(?):
....
....
self做什么？ 它是什么意思？ 它是强制性的吗？
__init__方法有什么作用？ 为什么有必要？ （ETC。）
我认为它们可能是 OOP 构造，但我不太了解。
在这段代码中：
class A(object):
def __init__(self):
self.x = 'Hello'
def method_a(self, foo):
print self.x + ' ' + foo
... self变量表示 object 本身的实例。 大多数面向对象的语言将此作为隐藏参数传递给 object 上定义的方法； Python 没有。 您必须明确声明它。 当您创建A class 的实例并调用其方法时，它将自动传递，如...
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 时，会为您创建一个 object，并将其作为第一个参数传递给__init__方法。 任何附加参数（例如， A(24, 'Hello') ）也将作为参数传递——在这种情况下会引发异常，因为构造函数并不期望它们。
是的，你是对的，这些是 oop 结构。
__init__是 class 的构造函数。 self参数指的是 object 的实例（在 C++ 中就像this ）。
class Point:
def __init__(self, x, y):
self._x = x
self._y = y
__init__方法在 memory 之后被调用，因为 object 被分配：
x = Point(1,2)
如果您想通过 object 持久化值，则在对象的方法中使用self参数很重要。 例如，如果您像这样实现__init__方法：
class Point:
def __init__(self, x, y):
_x = x
_y = y
您的x和y参数将存储在堆栈上的变量中，并在 init 方法超出 scope 时被丢弃。 将这些变量设置为self._x和self._y将这些变量设置为Point object 的成员（在对象的生命周期内可访问）。
注意在此答案中对“构造函数”一词的使用进行了一些澄清。 从技术上讲，“构造函数”的职责在 Python 中分为两种方法。 这些方法是__new__ （负责分配内存）和__init__ （如这里所讨论的，负责初始化新创建的实例）。
希望它可能会有所帮助，这里有一个简单的例子，我用来理解在 class 中声明的变量和在__init__ function 中声明的变量之间的区别：
class MyClass(object):
i = 123
def __init__(self):
self.i = 345
a = MyClass()
print(a.i)
print(MyClass.i)
Output：
345
123
简而言之：
self正如它所暗示的那样，指的是它自己- 调用该方法的 object。 也就是说，如果您有 N 个对象调用该方法，那么self.a将为 N 个对象中的每一个引用一个单独的变量实例。 想象一下每个 object 的变量a的 N 个副本__init__在其他 OOP 语言（如 C++/Java）中称为构造函数。 基本思想是，它是一个特殊的方法，在创建 Class 的 object 时自动调用属性引用使用用于 Python 中所有属性引用的标准语法：obj.name。 有效的属性名称是在创建 class object 时类名称空间中的所有名称。 因此，如果 class 定义如下所示：
class MyClass:
"""A simple example class"""
i = 12345
def f(self):
return 'hello world'
那么MyClass.i和MyClass.f是有效的属性引用，分别返回 integer 和 function object。 Class 属性也可以赋值给，所以你可以通过赋值来改变MyClass.i的值。 __doc__也是一个有效属性，返回属于 class 的文档字符串：“A simple example class”。
Class 实例化使用 function 表示法。 假设 class object 是一个无参数的 function ，它返回一个新的 ZA2F2ED4F8EBC4AB61D 实例。 例如：
x = MyClass()
实例化操作（“调用”一个 class 对象）创建一个空的 object。 许多类喜欢创建具有自定义为特定初始 state 的实例的对象。 因此 class 可以定义一个名为__init__()的特殊方法，如下所示：
def __init__(self):
self.data = []
当 class 定义__init__()方法时，class 实例化会自动为新创建的 class 实例调用__init__() 。 所以在这个例子中，一个新的、初始化的实例可以通过以下方式获得：
x = MyClass()
当然，__init __init__()方法可能有 arguments 以获得更大的灵活性。 在这种情况下，给 class 实例化运算符的 arguments 将传递给__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 :)")
当您创建 class Bill 的实例时：
purchase = Bill(5,6,7)
你得到：
> Buy 5 apples 6 figs and 7 dates. Total fruitty bill is 18 pieces of
> fruit :)
__init__确实像一个构造函数。 如果您希望它们表现为非静态方法，则需要将“self”作为第一个参数传递给任何 class 函数。 “self”是 class 的实例变量。
试试这个代码。 希望它可以帮助许多像我这样的 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__
Output：
Jay
Sum = 5
Doc - Inside Class
Doc - __init__ Constructor
Doc - Inside Show
Destructor Deleting object - Jay
我自己也很难理解这一点。 即使在阅读了这里的答案之后。
要正确理解__init__方法，您需要了解 self.
自我参数
__init__方法接受的 arguments 是：
def __init__(self, arg1, arg2):
但我们实际上只传递了两个 arguments：
instance = OurClass('arg1', 'arg2')
额外的论点从何而来？
当我们访问 object 的属性时，我们按名称（或按引用）进行。 这里的实例是对我们新的 object 的引用。 我们使用 instance.printargs 访问实例 object 的 printargs 方法。
为了从__init__方法中访问 object 属性，我们需要对 object 的引用。
每当调用方法时，对主 object 的引用作为第一个参数传递。 按照惯例，您总是将第一个参数称为您的方法 self。
这意味着在__init__方法中我们可以这样做：
self.arg1 = arg1
self.arg2 = arg2
这里我们在 object 上设置属性。 您可以通过执行以下操作来验证这一点：
instance = OurClass('arg1', 'arg2')
print instance.arg1
arg1
像这样的值称为 object 属性。 这里__init__方法设置实例的 arg1 和 arg2 属性。
来源： http://www.voidspace.org.uk/python/articles/OOP.shtml#the-init-method
请注意， self实际上可以是任何有效的 python 标识符。 例如，我们可以从 Chris B 的示例中轻松编写：
class A(object):
def __init__(foo):
foo.x = 'Hello'
def method_a(bar, foo):
print bar.x + ' ' + foo
它的工作原理完全相同。 但是建议使用 self ，因为其他 pythoner 会更容易识别它。
自我做什么？ 它是什么意思？ 是强制性的吗？
每个 class 方法（包括 init）的第一个参数始终是对 class 的当前实例的引用。 按照惯例，这个参数总是命名为self 。 在init方法中， self指的是新创建的object； 在其他 class 方法中，它指的是调用其方法的实例。
Python不会强迫您使用“自我”。 你可以给它任何你想要的名字。 但请记住，方法定义中的第一个参数是对 object 的引用。 Python 为您将self参数添加到列表中； 调用方法时不需要包含它。 如果你没有在 init 方法中提供 self 那么你会得到一个错误
TypeError: __init___() takes no arguments (1 given)
init方法有什么作用？ 为什么有必要？ （ETC。）
init是初始化的缩写。 它是一个构造函数，当您创建 class 的实例时会调用它，这不是必需的。 但通常我们的做法是编写初始化方法来设置 object 的默认 state。 如果您最初不愿意设置 object 的任何 state 则不需要编写此方法。
__init__ is basically a function which will "initialize" / "activate" the properties of the class for a specific object, once created and matched to the corresponding class..self表示将继承这些属性的 object。基本上，在同一个 class 内的多个函数中使用变量时，您需要使用“self”关键字。 至于init ，它用于设置默认值，以防 class 中没有其他函数被调用。
只是这个问题的演示。
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
'self' 是对 class 实例的引用
class foo:
def bar(self):
print "hi"
现在我们可以创建一个 foo 的实例并调用它的方法，在这种情况下，self 参数是由 Python 添加的：
f = foo()
f.bar()
但如果方法调用不在 class 实例的上下文中，它也可以传入，下面的代码做同样的事情
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__充当 class 的构造函数，当实例化 object 时，将调用此 function。 self表示实例化的 object。
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 方法的 self 参数是什么？ 它是什么？ 为什么，它是实例，当然， 换一种说法。 像withdraw这样的方法定义了从某个抽象客户的账户中取钱的指令。 调用 jeff.withdraw(100.0) 会将这些指令用于 jeff 实例。因此，当我们说 def withdraw(self, amount): 时，我们是在说，“这就是你如何从客户 object（我们称之为 self）和一个美元数字（我们称之为 amount）中提取资金的方式。self是正在调用撤回的客户的实例。这也不是我在做类比。jeff.withdraw(100.0) 只是 Customer.withdraw(jeff, 100.0) 的简写，这是完全有效的（如果不经常看到的话）代码。
init self 可能对其他方法有意义，但是init呢？ 当我们调用init时，我们正在创建一个 object，那么怎么可能已经有一个 self 呢？ Python 允许我们将 self 模式扩展到构造对象时，即使它并不完全适合。 想象一下 jeff = Customer('Jeff Knupp', 1000.0) 与调用 jeff = Customer(jeff, 'Jeff Knupp', 1000.0); 是一样的。 传入的 jeff 也是结果。
这就是为什么当我们调用init时，我们通过说 self.name = name 来初始化对象。 请记住，由于 self 是实例，这相当于说 jeff.name = name，这与 jeff.name = 'Jeff Knupp 相同。 同样，self.balance = balance 与 jeff.balance = 1000.0 相同。 在这两行之后，我们认为客户 object “已初始化”并可以使用。
小心你的
__init__init完成后，调用者可以正确地假设 object 已准备好使用。 即在 jeff = Customer('Jeff Knupp', 1000.0) 之后，我们可以开始对 jeff 进行存款和取款调用； jeff 是一个完全初始化的 object。
Python
__init__和self他们在做什么？
self做什么？ 它是什么意思？ 它是强制性的吗？
__init__方法有什么作用？ 为什么有必要？ （ETC。）
给出的示例不正确，所以让我根据它创建一个正确的示例：
class SomeObject(object):
def __init__(self, blah):
self.blah = blah
def method(self):
return self.blah
当我们创建 object 的实例时，会调用__init__来自定义 object。 也就是说，当我们使用下面'blah' （可以是任何东西）调用SomeObject时，它会作为参数传递给__init__ function， blah ：
an_object = SomeObject('blah')
self参数是将分配给an_object的SomeObject的实例。
稍后，我们可能想在这个 object 上调用一个方法：
an_object.method()
进行虚线查找，即an_object.method ，将实例绑定到 function 的实例，并且该方法（如上所述）现在是“绑定”方法 - 这意味着我们不需要显式地将实例传递给方法调用。
方法调用获取实例，因为它绑定在点分查找上，并且在被调用时，然后执行它被编程执行的任何代码。
按照惯例，隐式传递的self参数称为self 。 我们可以使用任何其他合法的 Python 名称，但如果您将其更改为其他名称，您可能会被其他 Python 程序员涂上焦油和羽毛。
__init__是一种特殊方法， 记录在 Python 数据模型文档中。 它在实例创建后立即调用（通常通过__new__ - 尽管__new__不是必需的，除非您将子类化为不可变数据类型）。
__init__ 中的 self.function 对 function 有什么作用？
[英]What does self.function in __init__ do to a function?
Python 中的“超级”有什么作用？ - super().__init__() 和显式超类 __init__() 之间的区别
[英]What does 'super' do in Python? - difference between super().__init__() and explicit superclass __init__()
如何确定python类中__init__函数内的内容？
[英]How do I determine what to put inside the __init__ function in a python class?
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.