1. 类的声明和创建
对于 Python 函数来说,声明与定义类没什么区别,因为他们是同时进行的,定义(类体)紧跟在声明(含 class
关键字的头行[header line])和可选(但总是推荐使用)的文档字符串后面。同时,所有的方法也必须同时被定义。
请注意 Python 并不支持纯虚函数(像 C++)或者抽象方法(如在 JAVA 中),这些都强制程序员在子类中定义方法。作为替代方法,你可以简单地在基类方法中引发 NotImplementedError
异常,这样可以获得类似的效果。
2. 有关类的属性
(1)查看类的属性
要知道一个类有哪些属性,有两种方法。最简单的是使用 dir()
内建函数(也可以查看实例属性)。另外是通过访问类的字典属性__dict__
,这是所有类都具备的特殊属性之一。
python
>>> class HaHa:
"""Haha to you!"""
variable1 = "Good"
variable2 = "Nice"
def change(self):
self.variable1 = "Bad"
>>> dir(HaHa)
['__doc__', '__module__', 'change', 'variable1', 'variable2']
>>> HaHa.__dict__
{'variable1': 'Good', '__module__': '__main__', 'variable2': 'Nice', '__doc__': 'Haha to you!', 'change': <function change at 0x02A9A930>}
dir()
返回的仅是对象的属性的一个名字列表, 而__dict__
返回的是一个字典,它的键(keys)是属性名,键值(values)是相应的属性对象的数据值。
(2)类的特殊属性
C.__name__ 类C的名字(字符串)
C.__doc__ 类C的文档字符串
C.__bases__ 类C的所有父类构成的元组
C.__dict__ 类C的属性
C.__module__ 类C定义所在的模块(1.5 版本新增)
C.__class__ 实例C对应的类(仅新式类中)
3. 对象
(1)Understanding __new__
and __init__
Understanding __new__
and __init__
(2)__del__()
方法
有一个相应的特殊解构器(destructor)方法名为__del__()
。然而,由于 Python 具有垃圾对象回收机制(靠引用计数),这个函数要直到该实例对象所有的引用都被清除掉后才会执行。
Python 中的解构器是在实例释放前提供特殊处理功能的方法,它们通常没有被实现,因为实例很少被显式释放。
要注意,解构器只能被调用一次,一旦引用计数为 0,则对象就被清除了。
总结:
- 不要忘记首先调用父类的
__del__()
。 - 调用
del x
不表示调用了x.__del__()
—–它仅仅是减少x
的引用计数。 - 如果你有一个循环引用或其它的原因,让一个实例的引用逗留不去, 该对象的
__del__()
可能永远不会被执行。 __del__()
未捕获的异常会被忽略掉 (因为一些在__del__()
用到的变量或许已经被删除了)。
不要在__del__()
中干与实例没任何关系的事情。- 除非你知道你正在干什么,否则不要去实现
__del__()
。 - 如果你定义了
__del__()
,并且实例是某个循环的一部分,垃圾回收器将不会终止这个循环——你需要自已显式调用del
。
(3)跟踪对象
Python 没有提供任何内部机制来跟踪一个类有多少个实例被创建了,或者记录这些实例是些什么东西。如果需要这些功能,你可以显式加入一些代码到类定义或者__init__()
和__del__()
中去。最好的方式是使用一个静态成员来记录实例的个数。 靠保存它们的引用来跟踪实例对象是很危险的,因为你必须合理管理这些引用,不然,你的引用可能没办法释放(因为还有其它的引用)!
class InstCt(object):
count = 0 # count is class attr
def __init__(self): # increment count
InstCt.count += 1
def __del__(self): # decrement count
InstCt.count -= 1
def howMany(self): # return count
return InstCt.count
>>> a = InstTrack()
>>> b = InstTrack()
>>> b.howMany()
2
>>> a.howMany()
2
>>> del b
>>> a.howMany()
1
>>> del a
>>> InstTrack.count
0
(4)类、实例的其它内建函数
issubclass()
布尔函数判断一个类是另一个类的子类或子孙类。它有如下语法:issubclass(sub, sup)
isinstance()
布尔函数在判定一个对象是否是另一个给定类的实例时,非常有用。它有如下语法:isinstance(obj1, obj2)
hasattr()
,getattr()
,setattr()
,delattr()
这些函数顾名思义,不做解释。
4. 静态方法和类方法
有两种方式声明静态方法和类方法:
使用
staticmethod()
和classmethod()
内建函数class TestStaticMethod: def foo(): print 'calling static method foo()' foo = staticmethod(foo) class TestClassMethod: def foo(cls): print 'calling class method foo()' print 'foo() is part of class:', cls.__name__ foo = classmethod(foo)
使用装饰器
class TestStaticMethod: @staticmethod def foo(): print 'calling static method foo()' class TestClassMethod: @classmethod def foo(cls): print 'calling class method foo()' print 'foo() is part of class:', cls.__name__
静态方法和类方法的区别:
静态方法没有cls
参数,所以它既不能访问实例变量,也不能访问类变量。
5. 继承
(1)__bases__
类属性
我们可以通过此属性获得父类的信息。语法:ClassName.__bases__
(2)方法覆盖(overriding)
Code example :
>>> class Parent(object):
def foo(self):
print 'Parent foo'
>>> class Son(Parent):
def foo(self): # 父类的foo方法被覆盖
print 'Son foo'
>>> son = Son()
>>> son.foo()
Son foo
被覆盖了的父类方法可以通过super()
函数在子类中调用.
Code Example :
>>> class NewSon(Parent):
def foo(self):
super(NewSon, self).foo()
>>> new_son = NewSon()
>>> new_son.foo()
Parent foo
注意:
子类覆盖父类的__init__()
方法后,如果你想调用父类的此方法,你必须显示调用!Python默认不会帮我们做这件事。
(3)多重继承
方法解释顺序(MRO)
经典类采用的是深度优先算法(python2.2之前),而新式类采用的是广度优先算法。因为在新式类中使用深度优先,会出现菱形效应。
假设我们有如下继承结构的类:
左边为经典类情况下,右边为新式类情况下。在新式类下B
,C
都继承自object
类。
在新式类(右边继承结构)中采用旧的深度优先算法,假设在D
的实例d
中调用foo()
方法,对于此方法的搜索顺序是D->B->A->C
;采用广度优先算法,搜索顺序为D->B->C-A
。因为D
继承了B
、C
,多数情况下我们更希望首先搜索的是C
而不是A
,因为假设A
、C
中都有foo()
方法时,你可能觉得A
中的foo()
方法太过通用了。很典型的就是__init__()
方法。
(4)从标准类派生
比如你想从float
类派生出一个子类,这都是很常见的需求。下面看两个例子:
继承float类
>>> class RoundFloat(float):
... def __new__(cls, val):
... return super(RoundFloat, cls).__new__(cls, round(val, 2))
...
>>> RoundFloat(1.5955)
1.6
我们派生了一个可以自动四舍五入到两位小数的RoundFloat
类。
继承dict
类
>>> class SortedKeyDict(dict):
... def keys(self):
... return sorted(super(SortedKeyDict, self).keys())
...
>>> dict1 = SortedKeyDict((('wang', 1), ('jiang', 2), ('guo', 3), ('han', 4)))
>>> dict1.keys() # 排序了
['guo', 'han', 'jiang', 'wang']
>>> [key for key in dict1] # 散列顺序
['guo', 'jiang', 'wang', 'han']
6. 特殊方法定制类
Python中有很多特殊方法,它们是以__
开头和结尾的。使用它们可以实现:
- 模拟标准类型
- 重载操作符
7. 私有化
Python 为类元素(属性和方法)的私有性提供初步的形式。由双下划线开始的属性在运行时被“混淆”(mixin),所以直接访问是不允许的。
混淆会在名字前面加下划线和类名。比如,以例NumStr
类中的 self.__num
属性为例,被“混淆”后,用于访问这个数据值的标识就变成了self._NumStr__num
。把类名加上后形成的新的“混淆”结果将可以防止在祖先类或子孙类中的同名冲突。
8. 包装和授权
(1)包装(wrapping)
定义:
对一个已存在的对象进行包装,不管它是数据类型,还是一段代码,可以是对一个已存在的对象,增加新的,删除不要的,或者修改其它已存在的功能。你可以包装任何类型作为一个类的核心成员,以使新对象的行为模仿你想要的数据类型中已存在的行为,并且去掉你不希望存在的行为。
包装类:
你可以包装类,但是实际上没有必要。因为你完全可以通过派生实现相同的效果。
(2)授权
简介:
授权是包装的一个特性,采用已存在的功能以达到最大限度的代码重用。包装一个类型通常是对已存在的类型的一些定制。授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给已存在的对象的默认属性。
实现授权:
实现授权的关键点就是覆盖__getattr__()
方法,在代码中包含一个对 getattr()
内建函数的调用。特别地,调用 getattr()以得到默认对象属性(数据属性或者方法)并返回它以便访问或调用。特殊方法__getattr__()
的工作方式是, 当搜索一个属性时, 任何局部对象首先被找到 (定制的对象)。如果搜索失败了,则__getattr__()
会被调用,然后调用 getattr()
得到一个对象的默认行为。
我们来实现一个包装文件对象的例子:
>>> class UpperFile(object):
... def __init__(self, fn, mode='r', buf=-1):
... self.file = open(fn, mode, buf)
... def __str__(self):
... return str(self.file)
... def __repr__(self):
... return '%s' % self.file
... def write(self, line):
... self.file.write(line.upper())
... def __getattr__(self, attr):
... return getattr(self.file, attr)
...
>>> f = UpperFile(r'C:\test.txt', 'w')
>>> f.write('abcde')
>>> f.close()
>>> f
<open file 'C:\\test.txt', mode 'w' at 0x029F1D88>
我们包装了open()
函数返回的文件对象。改写了write()
方法。当使用包装后的类实例化的对象调用write()
方法时,使用的是修改的方法;当调用close()
方法时,因为我们并没有改动此方法,则授权给原始文件对象,调用它的close()
方法。
9. 新式类的高级特性
(1)工厂函数
在python中,所有的内建转换函数都是工厂函数。当这些函数被调用时,实际上是对相应的类型实例化。
类型测试:
使用
isinstance(obj, int)
也可以使用
isinstance(obj, (int, bool))
检测obj
是否是int
或者bool
类型。
但要注意:尽管 isinstance()
很灵活,但它没有执行“严格匹配”比较—-如果 obj
是一个给定类型的实例或其子类的实例,也会返回 True
。但如果想进行严格匹配,你仍然需要使用 is
操作符:
type(obj) is int
(2)__slots__
类属性
__dict__
属性跟踪所有实例属性,以字典格式存储(属性名为key,属性值为value)。字典会占据大量内存,如果你有一个属性数量很少的类,但有很多实例,那么正好是这种情况。为内存上的考虑,用户现在可以使用__slots__
属性来替代__dict__
。
__slots__
是一个类变量,由一序列型对象组成,由所有合法标识构成的实例属性的集合来表示。它可以是一个列表,元组或可迭代对象。也可以是标识实例能拥有的唯一的属性的简单字符串。任何试图创建一个其名不在__slots__
中的名字的实例属性都将导致 AttributeError
异常
Code Example :
>>> class SlottedClass(object):
... __slots__ = ('foo', 'bar')
...
>>> c = SlottedClass()
>>> c.foo = 12
>>> c.xx = 12
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'SlottedClass' object has no attribute 'xx'
这种特性的主要目的是节约内存。其副作用是某种类型的”安全”,它能防止用户随心所欲的动态增加实例属性。带__slots__
属性的类定义不会存在__dict__
了。
(3)特殊方法__getattribute__()
请注意,这个方法不是上面我们在授权中提到的__getattr__()
方法。
当有属性被访问时,不管这个属性会不会被找到,__getattribute__()
函数都会被调用。
如果类同时定义了__getattribute__()
及__getattr__()
方法,除非明确从__getattribute__()
调用,或__getattribute__()
引发了 AttributeError
异常,否则后者不会被调用。
如果你将要在__getattribute__()
中访问这个类或其祖先类的属性,请务必小心。因为其实你是在__getattribute__()
中调用__getattribute__()
,你将会进入无穷递归。
(4)描述符
关于描述符,请移步这里:Python描述符
(5)元类:Metaclasses
和__metaclass__
在python中,类其实也是对象,它由元类创建。典型的应用场景是:ORM。这里不详细展开,你可以参见:
深刻理解Python中的元类(metaclass)
使用元类 - 廖雪峰的官方网站
Ref
《Python核心编程》