Python类及面向对象编程
类是用来创建数据结构和新类型对象的主要机制.本章的主题就是类,面向对象编程和设计不是本章的重点。本章假定你具有数据结构的背景知识及一定的面向对象的编程经验(其它面向对象的语言，比如java,c++).(参见第三章,类型和对象 了解对象这个术语及其内部实现的附加信息)
WeiZhong补充： 这本书出版于2001年，虽然Python有极佳的向下兼容性，但我们应该学习最新的知识。本章很多地方已经明显过时，为了保证大家学到新的知识并维持这本书的完整性，我会在必要的地方说明哪些地方已经过时，哪些地方新增了功能。 Python从2.2起引入了new-style对象模型，以逐步替代已经使用多年的classic对象模型。 由于 classic class 已经行将废止，所以我对本章的例子均作为了适当的修改以支持 new-style对象模型。
参考文档:《Python In a Nutshell》中的一节Python中的新型类及其实例
class语句
一个类定义了一系列与其实例对象密切关联的属性.典型的属性包括变量(也被称为类变量)和函数(又被称为方法).
class语句用来定义一个类.类的主体中语句在类定义同时执行.(如 Listing 7.1)
Listing 7.1 类
1 class Account(object): 2 "一个简单的类" 3 account_type = "Basic" 4 def __init__(self,name,balance): 5 "初始化一个新 Account 实例" 6 self.name = name 7 self.balance = balance 8 def deposit(self,amt): 9 "存款" 10 self.balance = self.balance + amt 11 def withdraw(self,amt): 12 "取款" 13 self.balance = self.balance - amt 14 def inquiry(self): 15 "返回当前余额" 16 return self.balance
访问类属性
类对象作为一个名字空间，存放在类定义语句运行时创建的对象.例如,Account里的内容可以这样访问:
Account.account_type Account.__init__ Account.deposit Account.withdraw Account.inquiry
需要注意的是, class语句并不创建类的实例(例如上边的例子,并没有创建任何帐户).它用来定义所有实例都应该有的属性.
在类中定义的常规方法的第一个参数总是该类的实例,通常这个参数记为self。你也可能用其它任何合法的变量名，不过为了符合惯例，你最好还是用self. 类中定义的变量,即类变量，如account_type, 它被所有该类的实例共享. 虽然类定义了一个名字空间,但这个名字空间并不是为类主体中的代码服务的.因此在类中引用一个类的属性必须使用类的全名:
1 class Foo(object): 2 def bar(self): 3 print "bar!" 4 def spam(self): 5 bar(self) # 错误,引发NameError 6 Foo.bar(self) # 合法的
最后，你不能定义一个不操作实例的方法:
1 class Foo(object): 2 def add(x,y): 3 return x+y 4 a = Foo.add(3,4) # TypeError. 需要一个类实例作为第一个参数
=======================================================================================
以下为WeiZhong增补部分： 静态方法和类方法(Python2.2以上)
- 静态方法: 可以直接被类或类实例调用。它没有常规方法那样的特殊行为（绑定、非绑定、默认的第一个参数规则等等）。你完全可以将静态方法当成一个用属性引用方式调用的普通函数。任何时候定义静态方法都不是必须的（静态方法能实现的功能都可以通过定义一个普通函数来实现）. 有些程序员认为，当有一堆函数仅仅为某一特定类编写时，将这些函数包装成静态这种方式可以提供使用上的一致性。
根据python2.4最新提供的新语法，你可以用下面的方式创建一个静态方法：
class AClass(object): @staticmethod #静态方法修饰符，表示下面的方法是一个静态方法 def astatic( ): print 'a static method' anInstance = AClass( ) AClass.astatic( ) # prints: a static method anInstance.astatic( ) # prints: a static method
注:staticmethod是一个内建函数,用来将一个方法包装成静态方法,在2.4以前版本,只能用下面这种方式定义一个静态方法(不再推荐使用):
class AClass(object): def astatic( ): print 'a static method' astatic=staticmethod(astatic)
这种方法在函数定义本身比较长时经常会忘记后面这一行.
- 类方法 一个类方法就可以通过类或它的实例来调用的方法, 不管你是用类来调用这个方法还是类实例调用这个方法,该方法的第一个参数总是定义该方法的类对象。 记住:方法的第一个参数都是类对象而不是实例对象. 按照惯例,类方法的第一个形参被命名为 cls. 任何时候定义类方法都不是必须的（类方法能实现的功能都可以通过定义一个普通函数来实现,只要这个函数接受一个类对象做为参数就可以了）. 你可以象下面这样来生成一个类方法:
class ABase(object): @classmethod #类方法修饰符 def aclassmet(cls): print 'a class method for', cls.__name__ class ADeriv(ABase): pass bInstance = ABase( ) dInstance = ADeriv( ) ABase.aclassmet( ) # prints: a class method for ABase bInstance.aclassmet( ) # prints: a class method for ABase ADeriv.aclassmet( ) # prints: a class method for ADeriv dInstance.aclassmet( ) # prints: a class method for ADeriv
注:classmethod是一个内建函数,用来将一个方法封装成类方法,在2.4以前版本,你只能用下面的方式定义一个类方法:
class AClass(object): def aclassmethod(cls): print 'a class method' aclassmethod=classmethod(aclassmethod)
并没有人要求必须封装后的方法名字必须与封装前一致,但建议你总是这样做(如果你使用python2.4版本以下时). 这种方法在函数定义本身比较长时经常会忘记后面这一行.
=======================================================================================
增补部分至此结束
类实例
像调用函数一样调用类，可以得到类的实例。生成实例的过程会自动调用类的__init__方法（如果你的类定义了这个方法的话）。
1 # 创建一些帐户 2 a = Account("Guido", 1000.00) # 调用 Account.__init__(a,"Guido",1000.00) 3 b = Account("Bill", 100000000000L)
实例创建之后,就可以使用点(.)操作符来访问它的属性和方法:
1 a.deposit(100.00) # 调用 Account.deposit(a,100.00) 2 b.withdraw(sys.maxint) # 调用 Account.withdraw(b,sys.maxint) 3 name = a.name # 得到帐户名称 4 print a.account_type # 显示帐户类型
在系统内部,每个类实例都拥有一个字典(即实例的 __dict__ 属性,在第三章中有介绍).这个字典包含每个实例的信息.例如:
>>> print a.__dict__ {'balance': 1100.0, 'name': 'Guido'} >>> print b.__dict__ {'balance': 97852516353L, 'name': 'Bill'}
若一个实例的属性被修改,这个字典也随之改变.上例中，属性通过Account类中定义的方法__init()__, deposit(),以及withdraw()中对self变量赋值被改变. 不过对于类实例可以随时添加私有属性。
a.number = 123456 # 把 'number' 加入到 a.__dict__
属性的赋值总是发生在实例字典中,而属性访问则比属性赋值复杂一些。当访问一个属性的时候,解释器首先在实例的字典中搜索，若找不到则去创建这个实例的类的字典中搜索，若还找不到就到类的基类中搜索(在后边 '继承' 一节中会讲到)，如果还找不到最后会尝试调用类的__getattr__方法来获取属性值(若类中定义了该方法的话).如果这个过程也失败,则引发AttributeError异常
引用记数与实例销毁
所有实例都是引用记数的.若一个实例引用记数变成零,该实例就被销毁.当实例将被销毁前,解释器会搜索该对象的 __del__方法并调用它。但在实际应用中,极少有需要给一个类定义__del__方法, 除非这个对象在销毁前需要执行一些清除操作(如关闭文件,断开网络,或者释放其他系统资源).即使是在这种情况下,依赖__del__()来执行清除和关闭操作也是危险的，因为不能保证在解释器关闭时会自动调用这个方法.更好的选择是定义一个close()方法,在需要时显式的调用这个方法来执行这个过程. 最后注意一点, 如果一个实例拥有__del__方法，则它永远不会被Python的垃圾收集器回收(这也是不推荐定义 __del__()的理由).关于垃圾回收请参阅附录A中的gc模块。
有时会使用del语句来删除对象的引用，如果这导致该对象引用记数变为零,就会自动调用__del__(). del语句并不直接调用__del__().
继承
继承(Inheritance)是创建新类的机制之一,它通过一个已有类进行修改和扩充来生成新类。这个原始的类被称为基类(base class)或超类(superclass).新生成的类称为该类的派生类(derived class)或子类(subclass).当通过继承创建一个类时,它会自动'继承'在基类中定义的属性。一个子类也可以重新定义父类中已有的属性或定义新的属性.
Python支持多继承，如果一个类有多个父类，在class语句中就使用逗号来分隔这个父类列表。例如:
1 class D(oject): pass #D继承自object 2 class B(D): #B是D的子类 3 varB = 42 4 def method1(self): 5 print "Class B : method1" 6 class C(D): #C也是D的子类 7 varC = 37 8 def method1(self): 9 print "Class C : method1" 10 def method2(self): 11 print "Class C : method2" 12 class A(B,C): #A是B和C的子类 13 varA = 3.3 14 def method3(self): 15 print "Class A : method3"
当搜索在基类中定义的某个属性时，Python采用深度优先的原则、按照子类定义中的基类顺序进行搜索。**注意**（new-style类已经改变了这种行为）。上边例子中，如果访问 A.varB ,就会按照A-B-D-C-D这个顺序进行搜索，只要找到就停止搜索.若有多个基类定义同一属性的情况,则只使用第一个被找到属性值:
1 a = A() # 创建 'A' 的实例 2 a.method3() # 调用 A.method3(a) 3 a.method1() # 调用 B.method1(c) 4 a.varB # 得到 B.varB
重要提示：新旧对象模型的差异:
注意：Python 中现在有两种对象模型均在使用中即classic对象模型和new-style对象模型，也有两种类：classic class 及 new-style class 在classic对象模型中,方法和属性按 从左至右 深度优先 的顺序查找（上文中已经提到）.显然,当多个父类继承自同一个基类时,这会产生我们不想要的结果. 就上例来说,D是一个new-style类（继承自object），B和C是D的子类, 而A是B和C的子类,如果按classic对象模型(原文中的提到的对象模型)的属性查找规则是搜索顺序是 A-B-D-C-D. 由于Python先查找D后查找C,即使C对D中的属性进行了重定义,也只能使用D中定义的版本.这是classic数据模型的固有问题,在实际应用中会造成一些麻烦.为了解决这个及其它一些问题，Python从2.2版本开始引入new-style对象模型。 在new-style对象模型中,所有内建类型均是object的直接或间接子类. new-style对象模型改变了传统对象模型中的解析顺序,上面的例子我已经改写为new-style类,因此,这个例子实际的搜索顺序是 A-B-C-D. 每个内建类型及new-style类均内建有一个特殊的只读属性 __mro__,这是一个tuple,它保存着方法解析类型. 只能通过类来引用 __mro__(通过实例无法访问). --WeiZhong Added@20060210
如果一个子类定义了一个和基类具有相同名称的属性,则子类的实例将使用子类中定义的属性.如果需要访问原来的属性,则必须使用全名来限制访问区域:
1 class D(A): 2 def method1(self): 3 print "Class D : method1" 4 A.method1(self) # 调用基类属性
需要注意的一点是子类实例的初始化.当一个子类实例被创建时, 基类的 __init__()方法并不会被自动调用.也就是子类必须自力更生来解决实例的初始化.例如:
1 class D(A): 2 def __init__(self, args1): 3 # 初始化基类 4 A.__init__(self) 5 # 初始化自己 6 ...
__del__() 与 __init__() 类似.
多态
Python通过上文中提到的属性查询规则来实现多态.当使用obj.method() 来访问一个方法时,方法的搜索顺序为:实例的 __dict__ 属性,实例的类定义,基类. 第一个被找到的方法被执行。
数据隐藏
默认情况下,所有的属性都是'公开'的.这意味着一个类的所有属性均可不受任何限制的访问.这也意味着基类中定义的所有内容都能被子类继承。 在面向对象编程实践中，这种行为是我们不希望的。因为它不但暴露了对象的内部实现，而且容易在派生类对象及基类对象之间产生名字空间冲突。
要解决这个问题,只需要在类中将需要隐藏的属性名字以两个下划线开头,例如 __Foo。这样系统会自动实时生成一个新的名字 _Classname__Foo 并用于内部使用。这样在某种程度上就提供了私有属性(其实这个 _Classname__Foo 仍然是不受限制访问的嘿嘿),也解决了名字空间冲突的问题.例如:
1 class A: 2 def __init__(self): 3 self.__X = 3 # self._A__X 4 5 class B(A): 6 def __init__(self): 7 A.__init__(self) 8 self.__X = 37 # self._B__X
这是一个小技巧,并没有真正阻止访问一个类的*私有*属性.如果已知一个类的名称和它某个私有属性的名称,我们还是可以使用_Classname__Foo 来访问到这个属性.(这不是bug,因为在某些特定的场合这非常有用,比如调试时,所以系统一直保留这个所谓的*问题*)
操作符重载
用户自定义对象可以通过在类中实现特殊方法(第三章中已介绍)来重载Python内建操作符.例如 Listing 7.2 中的类,它使用标准的数学运算符实现了复数的运算及类型转换.
Listing 7.2 数学运算及类型转换
1 class Complex(object): 2 def __init__(self,real,imag=0): 3 self.real = float(real) 4 self.imag = float(imag) 5 def __repr__(self): 6 return "Complex(%s,%s)" % (self.real, self.imag) 7 def __str__(self): 8 return "(%g+%gj)" % (self.real, self.imag) 9 # self + other 10 def __add__(self,other): 11 return Complex(self.real + other.real, self.imag + other.imag) 12 # self - other 13 def __sub__(self,other): 14 return Complex(self.real - other.real, self.imag - other.imag) 15 # -self 16 def __neg__(self): 17 return Complex(-self.real, -self.imag) 18 # other + self 19 def __radd__(self,other): 20 return Complex.__add__(other,self) 21 # other - self 22 def __rsub__(self,other): 23 return Complex.__sub__(other,self) 24 # 将其他数值类型转换为复数 25 def __coerce__(self,other): 26 if isinstance(other,Complex): 27 return self,other 28 try: # 检测是否可以被转换为浮点数 29 return self, Complex(float(other)) 30 except ValueError: 31 pass
在这个例子中,有一些值得研究的地方:
- 首先__repr__() 用于返回对象的表达式字符串表示,这个返回字符串可以用于再次得到该对象.在本例中,会创建一个类似"Complex(r,i)"的字符串.另外__str__()方法创建一个字符串用于较美观的输出。(通常用于print语句)
然后,要处理复数在运算符左边或右边这两种情况,必须同时提供 __op__()和 __rop__()方法.
最后, __ceorco__ 方法用于处理混合类型运算.在本例中,其他的数值类型均被转换为复数,这样才可以继续进行复数的运算.
类,类型,和成员检测
目前,类型和类是分开的.内建类型,如列表和字典是不能被继承的,类也不能定义一个新类型.事实上,所有的类定义都属于ClassType类型,同样地,类的实例属于InstanceType类型.所以,下面这个表达式对于两个类永远为真(即使这两个实例是由不同的类创建的): type(a) == type(b)
Python 2.4 已经支持内建类型的继承，类与类型还有差别，但越来越微妙了。 对 new-style 类来说，类的实例并不是 InstanceType 类型。它的类型与类的名字有关。也因此，对new-style类来说，上面的等式只有同一个类的两个不同实例才为真。 --WeiZhong
内建函数isinstance(obj ,cname)用来测试obj对象是否是cname的实例。.如果是,函数就返回True.例如:
1 class A(object): pass 2 class B(A): pass 3 class C(object): pass 4 5 a = A() # 'A'的实例 6 b = B() # 'B'的实例 7 c = C() # 'C'的实例 8 9 isinstance(a,A) # 返回 True 10 isinstance(b,A) # 返回 True, B 源自 A 11 isinstance(b,C) # 返回 False, C 与 A 没有派生关系
同样地,内建函数issubclass(A ,B)用来测试类A是否是类B的子类:
issubclass(B,A) # 返回 True issubclass(C,A) # 返回 False issubclass(A,A) # 永远返回True
isinstance()函数也可以用于检查任意内建类型:
1 import types 2 isinstance(3, types.IntType) # 返回 True 3 isinstance(3, types.FloatType) # 返回 False
这是一个被推荐的类型检查方法,这样类型和类的差别就可以忽略.
from：http://wiki.woodpecker.org.cn/moin/PythonEssentialRef7
欢迎加群互相学习，共同进步。QQ群：iOS: 58099570 | Android: 330987132 | Go：217696290 | Python：336880185 | 做人要厚道，转载请注明出处！http://www.cnblogs.com/sunshine-anycall/archive/2012/06/18/2554156.html