Python __init__和自己做什么？

我正在学习Python编程语言，我遇到了一些我不完全理解的东西。

在像这样的方法中：

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

self做什么？ 这是什么意思？ 这是强制性的吗？

__init__方法做了什么？ 为什么有必要？ （等等。）

我认为他们可能是面向对象的构造，但是我不太了解。

Answer 1

在这个代码中：

 class A(object): def __init__(self): self.x = 'Hello' def method_a(self, foo): print self.x + ' ' + foo 

selfvariables表示对象本身的实例。 大多数面向对象的语言将其作为隐藏parameter passing给对象上定义的方法; Python不。 你必须明确地声明。 当你创build一个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为你创build一个对象，并将它作为第一个parameter passing给__init__方法。 任何额外的参数（例如， A(24, 'Hello') ）也将作为parameter passing – 在这种情况下会引发exception，因为构造函数不期望它们。

Answer 2

是的，你是对的，这些都是oop结构。

__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参数将存储在堆栈中的variables中，当init方法超出范围时将被丢弃。 将这些variables设置为self._x和self._y这些variables设置为Point对象的成员（可在对象的整个生命周期中访问）。

Answer 3

一个简短的例子

希望这可能会有所帮助，下面是一个简单的例子，我用它来理解在类中声明的variables和在__init__函数中声明的variables之间的区别。

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

Answer 4

简而言之：

1. 就像它所暗示的那样， self是指自己 – 称为方法的对象。 也就是说，如果你有N个对象调用这个方法，那么self.a将为这N个对象中的每一个引用一个单独的variables实例。 设想每个对象的variablesa N个拷贝
2. __init__是其他OOP语言（如C ++ / Java）中的构造函数。 其基本思想是它是一个特殊的方法，当该类的一个对象被创build时被自动调用

Answer 5

__init__行为像一个构造函数。 如果您希望它们performance为非静态方法，则需要将“self”作为第一个parameter passing给任何类函数。 “self”是你的类的实例variables。

Answer 6

试试这个代码。 希望它能帮助像我这样的许多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

Answer 7

自己有麻烦了。 即使在阅读这里的答案后。

为了正确理解__init__方法，你需要了解自己。

自我参数

__init__方法接受的参数是：

 def __init__(self, arg1, arg2): 

但是我们实际上只传递了两个参数：

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

额外的论据来自哪里？

当我们访问对象的属性时，我们通过名称（或引用）来完成它。 这里的实例是对我们新对象的引用。 我们使用instance.printargs访问实例对象的printargs方法。

为了从__init__方法中访问对象属性，我们需要对该对象的引用。

每当调用一个方法时，对主对象的引用就作为第一个parameter passing。 按照惯例，你总是把这个第一个参数称为你自己的方法。

这意味着在__init__方法中我们可以做到：

 self.arg1 = arg1 self.arg2 = arg2 

在这里我们正在设置对象的属性。 您可以通过执行以下操作来validation这一点：

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

像这样的值被称为对象属性。 这里__init__方法设置实例的arg1和arg2属性。

来源： http ： //www.voidspace.org.uk/python/articles/OOP.shtml#the-init-method

Answer 8

注意self可以是任何有效的Python标识符。 例如，我们可以从Chris B的例子中轻松地写出：

 class A(object): def __init__(foo): foo.x = 'Hello' def method_a(bar, foo): print bar.x + ' ' + foo 

它的工作原理是一样的。 但是，build议使用自己的，因为其他pythoners会更容易识别它。

Answer 9

基本上，在同一个类中的多个函数中使用variables时，您需要使用“self”关键字。 至于init ，它被用来设置默认值，因为在该类中没有其他的函数被调用。

Answer 10

“self”是对类实例的引用

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

现在我们可以创build一个foo的实例并调用它的方法，在这种情况下，Python自身的参数被添加：

 f = foo() f.bar() 

但是，如果方法调用不在类的实例的上下文中，它也可以被传递，下面的代码也是一样的

 f = foo() foo.bar(f) 

有趣的是，variables名“self”只是一个约定。 下面的定义是完全一样的。虽然说这是一个非常强大的惯例 ，应该总是遵循，但是它确实说了一些关于语言的灵活性的东西

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

Answer 11

1. __init__基本上是一个函数，它将初始化 / 激活特定对象的类的属性，一旦创build并匹配到相应的类。
2. self表示将inheritance这些属性的对象。

Answer 12

你会是正确的，他们是面向对象的构造。 基本上， self是一个引用（有点像一个指针，但是self是一个你不能指定的特殊引用），而__init__是一个被调用来初始化对象的函数 – 也就是设置variables等 – 内存分配后。

Answer 13

在这个代码中：

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

Answer 14

 # 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() 

Answer 15

在这里，这个家伙写得很好，很简单： 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 def（self，amount）时，我们说：“这里是如何从Customer对象（我们称之为self）和一个美元数字（我们称之为amount）中提取资金。 （100.0）只是Customer.withdraw（jeff，100.0）的简写，这是完全有效的（如果不经常看到的话）码。

init可能对其他方法有意义，但init呢？ 当我们调用init时 ，我们正在创build一个对象，那么如何能有一个自我？ 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是一个完全初始化的对象。

Answer 16

自我做什么？ 这是什么意思 ？ 这是强制性的吗？

每个类方法（包括init）的第一个参数始终是对当前实例的引用 。 按照惯例，这个参数总是命名为self。在init方法中，self指的是新创build的对象; 在其他类方法中，它指的是调用方法的实例。

Python 不会强迫你使用 “ self ”。 你可以给它任何你想要的名字。 但请记住，方法定义中的第一个参数是对该对象的引用.Python将自身参数添加到列表中， 在调用方法时，不需要包含它。 如果你没有在init方法中提供自我，那么你将会得到一个错误

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

init方法是做什么的？ 为什么有必要？ （等等。）

init初始化的简称。 它是一个构造函数，当你创build类的实例时被调用， 这是没有必要的 。 但通常我们的做法是编写init方法来设置对象的默认状态。 如果你不愿意设置对象的任何状态，那么你不需要写这个方法。

Answer 17

Python __init__和self做什么？

self做什么？ 这是什么意思？ 这是强制性的吗？

__init__方法做了什么？ 为什么有必要？ （等等。）

给出的例子是不正确的，所以让我来创build一个正确的例子：

 class SomeObject(object): def __init__(self, blah): self.blah = blah def method(self): return self.blah 

当我们创build对象的实例时，调用__init__来创build对象后自定义。 也就是说，当我们用下面的'blah'调用SomeObject （可能是任何东西）时，它会作为parameter passing给__init__函数， blah ：

 an_object = SomeObject('blah') 

self参数是将被分配给an_object的SomeObject的实例。

稍后，我们可能想调用这个对象的一个​​方法：

 an_object.method() 

做虚线查找，即an_object.method ，将实例绑定到函数的一个实例，并且方法（如上所述）现在是一个“绑定”方法 – 这意味着我们不需要显式地将实例传递给方法调用。

方法调用获取实例，因为它被绑定在点状查找上，当被调用时，然后执行它编程执行的任何代码。

隐式传递的self论证被称为self约定。 我们可以使用任何其他合法的Python名称，但如果您将其更改为其他名称，则可能会被其他Python程序员所忽略。

__init__是一个特殊的方法， 在Python数据模型文档中有logging 。 在创build实例后立即调用它（通常通过__new__ – 尽pipe除非您__new__了不可变的数据types，否则不需要__new__ ）。