python中的__init()__方法
详细解读Python中的__init__()方法
- 背景
__init__()方法意义：
-
对象生命周期的初始化：
-
参数值可以有多种形式。
- 隐含的超类--object
在接触init()之前， 简单看下Python中隐含的object类的层次结构。
class X:
pass
>>>X.__class__
<class 'type'>
>>>X.__class__.__base__
<class 'object'>
我们可以看到该类是type类的一个对选哪个，且它的基类为object。
就像在每个方法中看到的那样，我们也看看从object继承的默认行为。在某些情况下，超类特殊方法的行为是我们所想要的。在其他情况下，我们需要覆盖这个特殊方法。
- 基类对象的init()方法
对象生命周期的基础是创建、初始化和销，目前只关注初始化。
所有类的超类object，有一个默认包含pass的init()实现，我们不需要去实现init()。如果不实现它，则在对象创建后就不会创建实例变量。在某些情况下，这种默认行为是可以接受的。
我们总是给对象添加属性，该对象为基类object的子类。思考以下类，需要两个实例变量但不初始化它们：
class Rectangle:
def area(self):
return self.length * self.width
Rectangle类有一个使用两个属性来返回一个值的方法。这些属性没有初始化。这是合法的Python代码。它可以有效的避免专门设置属性，虽然感觉有点奇怪，但是有效。
下面是于Rectangle类的交互：
>>> r = Rectangle()
>>> r.length, r.width = 13, 8
>>> r.area()
显然这是合法的，但也是容易混淆的根源，所以也是我们需要避免的原因。
无论如何，这个设计给予了很大的灵活性，这样有时候我们不用在init()方法中设置所有属性。至此我们走的很顺利。一个可选属性其实就是一个子类，只是没有真正的正式声明为子类。我们创建多态在某种程度上可能会引起混乱以及if语句的不恰当使用所造成的盘绕。虽然未初始化的属性可能是有用的，但很有可能是糟糕设计的前兆。
《Python之禅》中的建议：
"显式比隐式更好。"
一个init()方法应该让实例变量显式。
- 可怜的多态
灵活和愚蠢就在一念之间。
当我们觉得需要像下面这样写的时候，我们正从灵活的边缘走向愚蠢：
if 'x' in self.__dict__:
或者
try:
self.x
except AttributeError:
（就是使用隐示变量还要对变量的值进行判断）
是时候重新考虑API并添加一个通用的方法或属性。重构比添加if语句更明智。
- 在超类中实现init()
我们通过实现init()方法来初始化对象。当一个对象被创建，Python首先创建一个空对象，然后为那个新对象调用init()方法。这个方法函数通常用来创建对象的实例变量并执行任何其他一次性处理。
下面是Card类示例定义的层次结构。我们将定义Card超类和三个子类，这三个子类是Card的变种。两个实例变量直接由参数值设置，两个变量通过初始化方法计算：
class Card:
def __init__(self, rank, suit):
self.suit = suit
self.rank = rank
self.hard, self.soft = self._points()
class NumberCard(Card):
def _points(self):
return int(self.rank), int(self.rank)
class AceCard(Card):
def _points(self):
return 1, 11
class FaceCard(Card):
def _points(self):
return 10, 10
在这个示例中，我们提取init()方法到超类，这样在Card超类中的通用初始化可以适用于三个子类NumberCard、AceCard和FaceCard。
这是一种常见的多态设计。每一个子类都提供一个唯一的_points()方法实现。所有子类都有相同的签名：有相同的方法和属性。这三个子类的对象在一个应用程序中可以交替使用。
如果我们为花色使用简单的字符，我们可以创建Card实例，如下所示：
cards = [AceCard('A', '?'), NumberCard('2','?'), NumberCard('3','?'),]
我们在列表中枚举出一些牌的类、牌值和花色。从长远来说，我们需要更智能的工厂函数来创建Card实例；用这个方法枚举52张牌无聊且容易出错。在我们接触工厂函数之前，我们看一些其他问题。
- 使用init()创建显式常量
可以给牌定义花色类。在二十一点中，花色无关紧要，简单的字符串就可以。
我们使用花色构造函数作为创建常量对象的示例。
在许多情况下，我们应用中小部分对象可以通过常量集合来定义。
小部分的静态对象可能是实现策略模式或状态模式的一部分。
在某些情况下，我们会有一个在初始化或配置文件中创建的常量对象池，或者我们可以基于命令行参数创建常量对象。
Python没有简单正式的机制来定义一个不可变对象
下面这个类，我们将用于创建两个个显式常量：
class Suit:
def __init__(self, name, symbol):
self.name= name
self.symbol= symbol
下面是通过这个类创建的常量：
Club, Diamond, Heart, Spade = Suit('Club','?'), Suit('Diamond','?'), Suit('Heart','?'), Suit('Spade','?')
现在我们可以通过下面展示的代码片段创建cards：
cards = [AceCard('A', Spade), NumberCard('2', Spade), NumberCard('3', Spade),]
这个小示例，这种方法对于单个特性的花色代码来说并不是一个巨大的进步。
在更复杂的情况下，会有一些策略或状态对象通过这个方式创建。
通过从小的、静态的常量对象中复用可以使策略或状态设计模式更有效率。
我们必须承认，在Python中这些对象并不是技术上一成不变的，它是可变的。进行额外的编码使得这些对象真正不变可能会有一些好处。
无关紧要的不变性
不变性很有吸引力但却容易带来麻烦。有时候被神话般的“恶意程序员”在他们的应用程序中通过修改常量值进行调整。
从设计上考虑，这是非常愚蠢的。这些神话般的、恶意的程序员不会停止这样做，因为已经没有更好的方法去更简洁简单的在Python中编码。
恶意程序员访问到源码并且修改它仅仅是希望尽可能轻松地编写代码来修改一个常数。
__init__方法使用
- 使用demo
初始化 。注意，这个名称的开始和结尾都是双下划线。
使用__init__方法
代码例子
#!/usr/bin/python
# Filename: class_init.py
class Person:
def __init__(self, name):
self.name = name
def sayHi(self):
print Hello, my name is, self.name
p = Person(Swaroop)
p.sayHi()
# This short example can also be written as Person(Swaroop).sayHi()
输出
Hello, my name is Swaroop
它如何工作
这里，我们把__init__方法定义为取一个参数name（以及普通的参数self）。
在这个__init__里，我们只是创建一个新的域，也称为name。
注意它们是两个不同的变量，尽管它们有相同的名字。点号使我们能够区分它们。
最重要的是，我们没有专门调用__init__方法，只是在创建一个类的新实例的时候，把参数包括在圆括号内跟在类名后面，从而传递给__init__方法。这是这种方法的重要之处。
现在，我们能够在我们的方法中使用self.name域。这在sayHi方法中得到了验证。
__init__方法类似于C 、C#和Java中的 constructor
2.注意点
注意:
1、__init__并不相当于C#中的构造函数，执行它的时候，实例已构造出来了。
class A(object):
def __init__(self,name):
self.name=name
def getName(self):
return 'A '+self.name
当我们执行
a=A('hello')
时，可以理解为
a=object.__new__(A)
A.__init__(a,'hello')
即__init__作用是初始化已实例化后的对象。
注意2、子类可以不重写__init__，实例化子类时，会自动调用超类中已定义的__init__
复制代码
class B(A):
def getName(self):
return 'B '+self.name
if name=='main':
b=B('hello')
print b.getName()
复制代码
但如果重写了__init__，实例化子类时，则不会隐式的再去调用超类中已定义的__init__
class C(A):
def __init__(self):
pass
def getName(self):
return 'C'+self.name
if __name__=='__main__':
c=C()
print c.getName()
则会报"AttributeError: 'C' object has no attribute 'name'”错误，
所以如果重写了__init__，为了能使用或扩展超类中的行为，最好显式的调用超类的__init__方法
class C(A):
def __init__(self,name):
super(C,self).__init__(name)
def getName(self):
return 'C
'+self.name
if __name__=='__main__':
c=C('hello')
print c.getName()
1.使用demo
初始化 。注意，这个名称的开始和结尾都是双下划线。
使用__init__方法
代码例子
class Person:
def __init__(self, name):
self.name = name
def sayHi(self):
print Hello, my name is, self.name
p = Person(Swaroop)
p.sayHi()
# This short example can also be written as Person(Swaroop).sayHi()
输出
Hello, my name is Swaroop
它如何工作
这里，我们把__init__方法定义为取一个参数name（以及普通的参数self）。
在这个__init__里，我们只是创建一个新的域，也称为name。注意它们是两个不同的变量，尽管它们有相同的名字。点号使我们能够区分它们。
最重要的是，我们没有专门调用__init__方法，只是在创建一个类的新实例的时候，把参数包括在圆括号内跟在类名后面，从而传递给__init__方法。这是这种方法的重要之处。
现在，我们能够在我们的方法中使用self.name域。这在sayHi方法中得到了验证。
__init__方法类似于C 、C#和Java中的 constructor
2.注意点
注意1、__init__并不相当于C#中的构造函数，执行它的时候，实例已构造出来了。
class A(object):
def __init__(self,name):
self.name=name
def getName(self):
return 'A'+self.name
当我们执行
a=A('hello')
时，可以理解为
a=object.__new__(A)
A.__init__(a,'hello')
即__init__作用是初始化已实例化后的对象。
注意2、子类可以不重写__init__，实例化子类时，会自动调用超类中已定义的__init__
class B(A):
def getName(self):
return 'B'+self.name
if __name__=='__main__':
b=B('hello')
print b.getName()
但如果重写了__init__，实例化子类时，则不会隐式的再去调用超类中已定义的__init__
class C(A):
def __init__(self):
pass
def getName(self):
return 'C'+self.name
if __name__=='__main__':
c=C()
print c.getName()
则会报"AttributeError: 'C' object has no attribute 'name'”错误，所以如果重写了__init__，为了能使用或扩展超类中的行为，最好显式的调用超类的__init__方法
class C(A):
def __init__(self,name):
super(C,self).__init__(name)
def getName(self):
return 'C'+self.name
if __name__=='__main__':
c=C('hello')
print c.getName()
