python基础之面向对象高级编程

面向对象基本知识：

• 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
• 类 是一个模板，模板中包装了多个“函数”供使用（能够讲多函数中公用的变量封装到对象中）
• 对象，根据模板建立的实例（即：对象），实例用于调用被包装在类中的函数
• 面向对象三大特性：封装、继承和多态

 本篇将详细介绍Python 类的成员、成员修饰符、类的特殊成员。

类的成员

类的成员能够分为三大类：字段、方法和属性

注：全部成员中，只有普通字段的内容保存对象中，即：根据此类建立了多少对象，在内存中就有多少个普通字段。而其余的成员，则都是保存在类中，即：不管对象的多少，在内存中只建立一份。

1、字段

字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不一样

 

• 普通字段属于对象
• 静态字段属于类

 

 

字段的定义和使用

 

class Province:

    # 静态字段
    country ＝ '中国'

    def __init__(self, name):

        # 普通字段
        self.name = name


# 直接访问普通字段
obj = Province('河北省')
print obj.name

# 直接访问静态字段
Province.country

字段的定义和使用

 

由上述代码能够看出【普通字段须要经过对象来访问】【静态字段经过类访问】，在使用上能够看出普通字段和静态字段的归属是不一样的。其在内容的存储方式相似以下图：

由上图但是：

• 静态字段在内存中只保存一份
• 普通字段在每一个对象中都要保存一份

应用场景： 经过类建立对象时，若是每一个对象都具备相同的字段，那么就使用静态字段

2、方法

方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不一样。

 

• 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
• 静态方法：由类调用；无默认参数；

 

方法的定义和使用

 

class Foo:

    def __init__(self, name):
        self.name = name

    def ord_func(self):
        """ 定义普通方法，至少有一个self参数 """

        # print self.name
        print '普通方法'

    @classmethod
    def class_func(cls):
        """ 定义类方法，至少有一个cls参数 """

        print '类方法'

    @staticmethod
    def static_func():
        """ 定义静态方法 ，无默认参数"""

        print '静态方法'


# 调用普通方法
f = Foo()
f.ord_func()

# 调用类方法
Foo.class_func()

# 调用静态方法
Foo.static_func()

方法的定义和使用

 

相同点：对于全部的方法而言，均属于类（非对象）中，因此，在内存中也只保存一份。

不一样点：方法调用者不一样、调用方法时自动传入的参数不一样。

3、属性　　

若是你已经了解Python类中的方法，那么属性就很是简单了，由于Python中的属性实际上是普通方法的变种。

 

对于属性，有如下三个知识点：

 

• 属性的基本使用
• 属性的两种定义方式

 

一、属性的基本使用

 

# ############### 定义 ###############
class Foo:

    def func(self):
        pass

    # 定义属性
    @property
    def prop(self):
        pass
# ############### 调用 ###############
foo_obj = Foo()

foo_obj.func()
foo_obj.prop   #调用属性

属性的定义和使用

 

由属性的定义和调用要注意一下几点：

• 定义时，在普通方法的基础上添加 @property 装饰器；
• 定义时，属性仅有一个self参数
• 调用时，无需括号
             方法：foo_obj.func()
             属性：foo_obj.prop

注意：属性存在乎义是：访问属性时能够制造出和访问字段彻底相同的假象

        属性由方法变种而来，若是Python中没有属性，方法彻底能够代替其功能。

实例：对于主机列表页面，每次请求不可能把数据库中的全部内容都显示到页面上，而是经过分页的功能局部显示，因此在向数据库中请求数据时就要显示的指定获取从第m条到第n条的全部数据（即：limit m,n），这个分页的功能包括：

 

• 根据用户请求的当前页和总数据条数计算出 m 和 n
• 根据m 和 n 去数据库中请求数据
  

 

实例：

 

# ############### 定义 ###############
class Pager:
    
    def __init__(self, current_page):
        # 用户当前请求的页码（第一页、第二页...）
        self.current_page = current_page
        # 每页默认显示10条数据
        self.per_items = 10 


    @property
    def start(self):
        val = (self.current_page - 1) * self.per_items
        return val

    @property
    def end(self):
        val = self.current_page * self.per_items
        return val

# ############### 调用 ###############

p = Pager(1)
p.start 就是起始值，即：m
p.end   就是结束值，即：n

 

 

从上述可见，Python的属性的功能是：属性内部进行一系列的逻辑计算，最终将计算结果返回。

二、属性的两种定义方式

属性的定义有两种方式：

• 装饰器 即：在方法上应用装饰器
• 静态字段 即：在类中定义值为property对象的静态字段

 

注：经典类中的属性只有一种访问方式，其对应被 @property 修饰的方法
      新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法

因为新式类中具备三种访问方式，咱们能够根据他们几个属性的访问特色，分别将三个方法定义为对同一个属性：获取、修改、删除

实例：

 

class Goods(object):

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deltter
    def price(self, value):
        del self.original_price

obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
del obj.price     # 删除商品原价

实例

 

 

静态字段方式，建立值为property对象的静态字段

当使用静态字段的方式建立属性时，经典类和新式类无区别

 

class Foo:

    def get_bar(self):
        return 'wupeiqi'

    BAR = property(get_bar)

obj = Foo()
reuslt = obj.BAR        # 自动调用get_bar方法，并获取方法的返回值
print reuslt

 

property的构造方法中有个四个参数

• 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
• 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
• 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
• 第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息

 

class Foo：

    def get_bar(self):
        return 'wupeiqi'

    # *必须两个参数
    def set_bar(self, value): 
        return return 'set value' + value

    def del_bar(self):
        return 'wupeiqi'

    BAR ＝ property(get_bar, set_bar, del_bar, 'description...')

obj = Foo()

obj.BAR              # 自动调用第一个参数中定义的方法：get_bar
obj.BAR = "alex"     # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”看成参数传入
del Foo.BAR          # 自动调用第三个参数中定义的方法：del_bar方法
obj.BAE.__doc__      # 自动获取第四个参数中设置的值：description...

  因为静态字段方式建立属性具备三种访问方式，咱们能够根据他们几个属性的访问特色，分别将三个方法定义为对同一个属性：获取、修改、删除

class Goods(object):

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    def get_price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    def set_price(self, value):
        self.original_price = value

    def del_price(self, value):
        del self.original_price

    PRICE = property(get_price, set_price, del_price, '价格属性描述...')

obj = Goods()
obj.PRICE         # 获取商品价格
obj.PRICE = 200   # 修改商品原价
del obj.PRICE     # 删除商品原价

实例

 

 

 

咱们知道Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。（ 若是类继object，那么该类是新式类 ）
经典类，具备一种@property装饰器（如上一步实例）

因此，定义属性共有两种方式，分别是【装饰器】和【静态字段】，而【装饰器】方式针对经典类和新式类又有所不一样。

类成员的修饰符

类的全部成员在上一步骤中已经作了详细的介绍，对于每个类的成员而言都有两种形式：

• 公有成员，在任何地方都能访问
• 私有成员，只有在类的内部才能方法

私有成员和公有成员的定义不一样：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）

 

• 公有静态字段：类能够访问；类内部能够访问；派生类中能够访问
• 私有静态字段：仅类内部能够访问；

 

公有静态字段

 

class C:

    name = "公有静态字段"

    def func(self):
        print C.name

class D(C):

    def show(self):
        print C.name


C.name         # 类访问

obj = C()
obj.func()     # 类内部能够访问

obj_son = D()
obj_son.show() # 派生类中能够访问

公有静态字段

 

 

 

私有静态字段

 

class C:

    __name = "公有静态字段"

    def func(self):
        print C.__name

class D(C):

    def show(self):
        print C.__name


C.__name       # 类访问            ==> 错误

obj = C()
obj.func()     # 类内部能够访问     ==> 正确

obj_son = D()
obj_son.show() # 派生类中能够访问   ==> 错误

私有静态字段

 

 

普通字段

• 公有普通字段：对象能够访问；类内部能够访问；派生类中能够访问
• 私有普通字段：仅类内部能够访问；

ps：若是想要强制访问私有字段，能够经过 【对象._类名__私有字段明 】访问（如：obj._C__foo），不建议强制访问私有成员。

公有字段

 

class C:
    
    def __init__(self):
        self.foo = "公有字段"

    def func(self):
        print self.foo 　#　类内部访问

class D(C):
    
    def show(self):
        print self.foo　＃　派生类中访问

obj = C()

obj.foo     # 经过对象访问
obj.func()  # 类内部访问

obj_son = D();
obj_son.show()  # 派生类中访问

公有字段

 

 

 

私有字段

 

 

class C:
    
    def __init__(self):
        self.__foo = "私有字段"

    def func(self):
        print self.foo 　#　类内部访问

class D(C):
    
    def show(self):
        print self.foo　＃　派生类中访问

obj = C()

obj.__foo     # 经过对象访问    ==> 错误
obj.func()  # 类内部访问        ==> 正确

obj_son = D();
obj_son.show()  # 派生类中访问  ==> 错误

私有字段

 

方法、属性的访问于上述方式类似，即：私有成员只能在类内部使用

ps：非要访问私有属性的话，能够经过 对象._类__属性名

类的特殊成员

上文介绍了Python的类成员以及成员修饰符，从而了解到类中有字段、方法和属性三大类成员，而且成员名前若是有两个下划线，则表示该成员是私有成员，私有成员只能由类内部调用。不管人或事物每每都有不按套路出牌的状况，Python的类成员也是如此，存在着一些具备特殊含义的成员，详情以下：

1. __doc__

　　表示类的描述信息

 

class Foo:
    """ 描述类信息，这是用于看片的神奇 """

    def func(self):
        pass

print Foo.__doc__
#输出：类的描述信息

 

 

2. __module__ 和  __class__ 

　　__module__ 表示当前操做的对象在那个模块

　　__class__     表示当前操做的对象的类是什么

 

#!/usr/bin/env python
# -*- coding:utf-8 -*-

class C:

    def __init__(self):
        self.name = 'wupeiqi'

lib/aa.py

 

 

from lib.aa import C

obj = C()
print obj.__module__  # 输出 lib.aa，即：输出模块
print obj.__class__      # 输出 lib.aa.C，即：输出类

 

3. __init__

　　构造方法，经过类建立对象时，自动触发执行。

 

class Foo:

    def __init__(self, name):
        self.name = name
        self.age = 18


obj = Foo('wupeiqi') # 自动执行类中的 __init__ 方法

 

 

4. __del__

　　析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法通常无须定义，由于Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，由于此工做都是交给Python解释器来执行，因此，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

 

class Foo:

    def __del__(self):
        pass

 

 

5. __call__

　　对象后面加括号，触发执行。

注：构造方法的执行是由建立对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

 

class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print '__call__'


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

 

6. __dict__

　　类或对象中的全部成员

上文中咱们知道：类的普通字段属于对象；类中的静态字段和方法等属于类，即：

 

class Province:

    country = 'China'

    def __init__(self, name, count):
        self.name = name
        self.count = count

    def func(self, *args, **kwargs):
        print 'func'

# 获取类的成员，即：静态字段、方法、
print Province.__dict__
# 输出：{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}

obj1 = Province('HeBei',10000)
print obj1.__dict__
# 获取 对象obj1 的成员
# 输出：{'count': 10000, 'name': 'HeBei'}

obj2 = Province('HeNan', 3888)
print obj2.__dict__
# 获取 对象obj1 的成员
# 输出：{'count': 3888, 'name': 'HeNan'}

 7. __str__

　　若是一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

 

class Foo:

    def __str__(self):
        return 'wupeiqi'


obj = Foo()
print obj
# 输出：wupeiqi

 

 

八、__getitem__、__setitem__、__delitem__

用于索引操做，如字典。以上分别表示获取、设置、删除数据

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
class Foo(object):
 
    def __getitem__(self, key):
        print '__getitem__',key
 
    def __setitem__(self, key, value):
        print '__setitem__',key,value
 
    def __delitem__(self, key):
        print '__delitem__',key
 
 
obj = Foo()
 
result = obj['k1']      # 自动触发执行 __getitem__
obj['k2'] = 'wupeiqi'   # 自动触发执行 __setitem__
del obj['k1']           # 自动触发执行 __delitem__

 

九、__getslice__、__setslice__、__delslice__

 该三个方法用于分片操做，如：列表

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
class Foo(object):
 
    def __getslice__(self, i, j):
        print '__getslice__',i,j
 
    def __setslice__(self, i, j, sequence):
        print '__setslice__',i,j
 
    def __delslice__(self, i, j):
        print '__delslice__',i,j
 
obj = Foo()
 
obj[-1:1]                   # 自动触发执行 __getslice__
obj[0:1] = [11,22,33,44]    # 自动触发执行 __setslice__
del obj[0:2]                # 自动触发执行 __delslice__

 

10. __iter__ 

用于迭代器，之因此列表、字典、元组能够进行for循环，是由于类型内部定义了 __iter__

第一步

class Foo(object):
    pass


obj = Foo()

for i in obj:
    print i
    
# 报错：TypeError: 'Foo' object is not iterable

第一步

 

第二步

#!/usr/bin/env python
# -*- coding:utf-8 -*-

class Foo(object):
    
    def __iter__(self):
        pass

obj = Foo()

for i in obj:
    print i

# 报错：TypeError: iter() returned non-iterator of type 'NoneType'

第二步

 

第三步

#!/usr/bin/env python
# -*- coding:utf-8 -*-

class Foo(object):

    def __init__(self, sq):
        self.sq = sq

    def __iter__(self):
        return iter(self.sq)

obj = Foo([11,22,33,44])

for i in obj:
    print i

第三步

 以上步骤能够看出，for循环迭代的实际上是  iter([11,22,33,44]) ，因此执行流程能够变动为：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
obj = iter([11,22,33,44])
 
for i in obj:
    print i

 for循环语法内部

#!/usr/bin/env python
# -*- coding:utf-8 -*-

obj = iter([11,22,33,44])

while True:
    val = obj.next()
    print val

For循环语法内部

 

11. __new__ 和 __metaclass__

阅读如下代码：

 

class Foo(object):
 
    def __init__(self):
        pass
 
obj = Foo()   # obj是经过Foo类实例化的对象

 

 

上述代码中，obj 是经过 Foo 类实例化的对象，其实，不只 obj 是一个对象，Foo类自己也是一个对象，由于在Python中一切事物都是对象。

若是按照一切事物都是对象的理论：obj对象是经过执行Foo类的构造方法建立，那么Foo类对象应该也是经过执行某个类的 构造方法 建立。

1 2	print type (obj) # 输出：<class '__main__.Foo'>     表示，obj 对象由Foo类建立 print type (Foo) # 输出：<type 'type'>              表示，Foo类对象由 type 类建立

因此，obj对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是经过type类的构造方法建立。

那么，建立类就能够有两种方式：

a). 普通方式

1 2 3 4

class Foo( object ):        def func( self ):          print 'hello wupeiqi'

b).特殊方式（type类的构造函数）

1 2 3 4 5 6 7

def func( self ):      print 'hello wupeiqi'   Foo = type ( 'Foo' ,( object ,), { 'func' : func}) #type第一个参数：类名 #type第二个参数：当前类的基类 #type第三个参数：类的成员

＝＝》 类 是由 type 类实例化产生

那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的建立类？类又是如何建立对象？

答：类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化建立，因此，咱们能够为 __metaclass__ 设置一个type类的派生类，从而查看 类 建立的过程。

实例：

class MyType(type):

    def __init__(self, what, bases=None, dict=None):
        super(MyType, self).__init__(what, bases, dict)

    def __call__(self, *args, **kwargs):
        obj = self.__new__(self, *args, **kwargs)

        self.__init__(obj)

class Foo(object):

    __metaclass__ = MyType

    def __init__(self, name):
        self.name = name

    def __new__(cls, *args, **kwargs):
        return object.__new__(cls, *args, **kwargs)

# 第一阶段：解释器从上到下执行代码建立Foo类
# 第二阶段：经过Foo类建立obj对象
obj = Foo()

 

使用__slots__

正常状况下，当咱们定义了一个class，建立了一个class的实例后，咱们能够给该实例绑定任何属性和方法，这就是动态语言的灵活性。先定义class：

class Student(object): pass 

而后，尝试给实例绑定一个属性：

>>> s = Student() >>> s.name = 'Michael' # 动态给实例绑定一个属性 >>> print(s.name) Michael 

还能够尝试给实例绑定一个方法：

>>> def set_age(self, age): # 定义一个函数做为实例方法 ... self.age = age ... >>> from types import MethodType >>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法 >>> s.set_age(25) # 调用实例方法 >>> s.age # 测试结果 25 

可是，给一个实例绑定的方法，对另外一个实例是不起做用的：

>>> s2 = Student() # 建立新的实例
>>> s2.set_age(25) # 尝试调用方法
Traceback (most recent call last):
  File "<stdin>", line 1, in <module> AttributeError: 'Student' object has no attribute 'set_age' 

为了给全部实例都绑定方法，能够给class绑定方法：

>>> def set_score(self, score): ... self.score = score ... >>> Student.set_score = set_score 

给class绑定方法后，全部实例都可调用：

>>> s.set_score(100) >>> s.score 100 >>> s2.set_score(99) >>> s2.score 99 

一般状况下，上面的set_score方法能够直接定义在class中，但动态绑定容许咱们在程序运行的过程当中动态给class加上功能，这在静态语言中很难实现。

使用__slots__

可是，若是咱们想要限制实例的属性怎么办？好比，只容许对Student实例添加name和age属性。

为了达到限制的目的，Python容许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性：

class Student(object): __slots__ = ('name', 'age') # 用tuple定义容许绑定的属性名称 

而后，咱们试试：

>>> s = Student() # 建立新的实例 >>> s.name = 'Michael' # 绑定属性'name' >>> s.age = 25 # 绑定属性'age' >>> s.score = 99 # 绑定属性'score' Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'Student' object has no attribute 'score' 

因为'score'没有被放到__slots__中，因此不能绑定score属性，试图绑定score将获得AttributeError的错误。

使用__slots__要注意，__slots__定义的属性仅对当前类实例起做用，对继承的子类是不起做用的：

>>> class GraduateStudent(Student): ... pass ... >>> g = GraduateStudent() >>> g.score = 9999 

除非在子类中也定义__slots__，这样，子类实例容许定义的属性就是自身的__slots__加上父类的__slots__。

使用@property

在绑定属性时，若是咱们直接把属性暴露出去，虽然写起来很简单，可是，没办法检查参数，致使能够把成绩随便改：

s = Student()
s.score = 9999

这显然不合逻辑。为了限制score的范围，能够经过一个set_score()方法来设置成绩，再经过一个get_score()来获取成绩，这样，在set_score()方法里，就能够检查参数：

class Student(object): def get_score(self): return self._score def set_score(self, value): if not isinstance(value, int): raise ValueError('score must be an integer!') if value < 0 or value > 100: raise ValueError('score must between 0 ~ 100!') self._score = value 

如今，对任意的Student实例进行操做，就不能为所欲为地设置score了：

>>> s = Student() >>> s.set_score(60) # ok! >>> s.get_score() 60 >>> s.set_score(9999) Traceback (most recent call last): ... ValueError: score must between 0 ~ 100! 

可是，上面的调用方法又略显复杂，没有直接用属性这么直接简单。

有没有既能检查参数，又能够用相似属性这样简单的方式来访问类的变量呢？对于追求完美的Python程序员来讲，这是必需要作到的！

还记得装饰器（decorator）能够给函数动态加上功能吗？对于类的方法，装饰器同样起做用。Python内置的@property装饰器就是负责把一个方法变成属性调用的：

class Student(object): @property def score(self): return self._score @score.setter def score(self, value): if not isinstance(value, int): raise ValueError('score must be an integer!') if value < 0 or value > 100: raise ValueError('score must between 0 ~ 100!') self._score = value 

@property的实现比较复杂，咱们先考察如何使用。把一个getter方法变成属性，只须要加上@property就能够了，此时，@property自己又建立了另外一个装饰器@score.setter，负责把一个setter方法变成属性赋值，因而，咱们就拥有一个可控的属性操做：

>>> s = Student() >>> s.score = 60 # OK，实际转化为s.set_score(60) >>> s.score # OK，实际转化为s.get_score() 60 >>> s.score = 9999 Traceback (most recent call last): ... ValueError: score must between 0 ~ 100! 

注意到这个神奇的@property，咱们在对实例属性操做的时候，就知道该属性极可能不是直接暴露的，而是经过getter和setter方法来实现的。

还能够定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性：

class Student(object): @property def birth(self): return self._birth @birth.setter def birth(self, value): self._birth = value @property def age(self): return 2015 - self._birth 

上面的birth是可读写属性，而age就是一个只读属性，由于age能够根据birth和当前时间计算出来。

小结

@property普遍应用在类的定义中，可让调用者写出简短的代码，同时保证对参数进行必要的检查，这样，程序运行时就减小了出错的可能性。

多重继承

继承是面向对象编程的一个重要的方式，由于经过继承，子类就能够扩展父类的功能。

回忆一下Animal类层次的设计，假设咱们要实现如下4种动物：

• Dog - 狗狗；
• Bat - 蝙蝠；
• Parrot - 鹦鹉；
• Ostrich - 鸵鸟。

若是按照哺乳动物和鸟类归类，咱们能够设计出这样的类的层次：

可是若是按照“能跑”和“能飞”来归类，咱们就应该设计出这样的类的层次：

若是要把上面的两种分类都包含进来，咱们就得设计更多的层次：

• 哺乳类：能跑的哺乳类，能飞的哺乳类；
• 鸟类：能跑的鸟类，能飞的鸟类。

这么一来，类的层次就复杂了：

若是要再增长“宠物类”和“非宠物类”，这么搞下去，类的数量会呈指数增加，很明显这样设计是不行的。

正确的作法是采用多重继承。首先，主要的类层次仍按照哺乳类和鸟类设计：

class Animal(object): pass # 大类: class Mammal(Animal): pass class Bird(Animal): pass # 各类动物: class Dog(Mammal): pass class Bat(Mammal): pass class Parrot(Bird): pass class Ostrich(Bird): pass 

如今，咱们要给动物再加上Runnable和Flyable的功能，只须要先定义好Runnable和Flyable的类：

class Runnable(object): def run(self): print('Running...') class Flyable(object): def fly(self): print('Flying...') 

对于须要Runnable功能的动物，就多继承一个Runnable，例如Dog：

class Dog(Mammal, Runnable): pass 

对于须要Flyable功能的动物，就多继承一个Flyable，例如Bat：

class Bat(Mammal, Flyable): pass 

经过多重继承，一个子类就能够同时得到多个父类的全部功能。

MixIn

在设计类的继承关系时，一般，主线都是单一继承下来的，例如，Ostrich继承自Bird。可是，若是须要“混入”额外的功能，经过多重继承就能够实现，好比，让Ostrich除了继承自Bird外，再同时继承Runnable。这种设计一般称之为MixIn。

为了更好地看出继承关系，咱们把Runnable和Flyable改成RunnableMixIn和FlyableMixIn。相似的，你还能够定义出肉食动物CarnivorousMixIn和植食动物HerbivoresMixIn，让某个动物同时拥有好几个MixIn：

class Dog(Mammal, RunnableMixIn, CarnivorousMixIn): pass 

MixIn的目的就是给一个类增长多个功能，这样，在设计类的时候，咱们优先考虑经过多重继承来组合多个MixIn的功能，而不是设计多层次的复杂的继承关系。

Python自带的不少库也使用了MixIn。举个例子，Python自带了TCPServer和UDPServer这两类网络服务，而要同时服务多个用户就必须使用多进程或多线程模型，这两种模型由ForkingMixIn和ThreadingMixIn提供。经过组合，咱们就能够创造出合适的服务来。

好比，编写一个多进程模式的TCP服务，定义以下：

class MyTCPServer(TCPServer, ForkingMixIn): pass 

编写一个多线程模式的UDP服务，定义以下：

class MyUDPServer(UDPServer, ThreadingMixIn): pass 

若是你打算搞一个更先进的协程模型，能够编写一个CoroutineMixIn：

class MyTCPServer(TCPServer, CoroutineMixIn): pass 

这样一来，咱们不须要复杂而庞大的继承链，只要选择组合不一样的类的功能，就能够快速构造出所需的子类。

小结

因为Python容许使用多重继承，所以，MixIn就是一种常见的设计。

只容许单一继承的语言（如Java）不能使用MixIn的设计。

定制类

看到相似 __slots__这种形如 __xxx__的变量或者函数名就要注意，这些在Python中是有特殊用途的。

__slots__咱们已经知道怎么用了，__len__()方法咱们也知道是为了能让class做用于len()函数。

除此以外，Python的class中还有许多这样有特殊用途的函数，能够帮助咱们定制类。

__str__

咱们先定义一个Student类，打印一个实例：

>>> class Student(object): ... def __init__(self, name): ... self.name = name ... >>> print(Student('Michael')) <__main__.Student object at 0x109afb190> 

打印出一堆<__main__.Student object at 0x109afb190>，很差看。

怎么才能打印得好看呢？只须要定义好__str__()方法，返回一个好看的字符串就能够了：

>>> class Student(object): ... def __init__(self, name): ... self.name = name ... def __str__(self): ... return 'Student object (name: %s)' % self.name ... >>> print(Student('Michael')) Student object (name: Michael) 

这样打印出来的实例，不但好看，并且容易看出实例内部重要的数据。

可是细心的朋友会发现直接敲变量不用print，打印出来的实例仍是很差看：

>>> s = Student('Michael')
>>> s
<__main__.Student object at 0x109afb310> 

这是由于直接显示变量调用的不是__str__()，而是__repr__()，二者的区别是__str__()返回用户看到的字符串，而__repr__()返回程序开发者看到的字符串，也就是说，__repr__()是为调试服务的。

解决办法是再定义一个__repr__()。可是一般__str__()和__repr__()代码都是同样的，因此，有个偷懒的写法：

class Student(object): def __init__(self, name): self.name = name def __str__(self): return 'Student object (name=%s)' % self.name __repr__ = __str__ 

__iter__

若是一个类想被用于for ... in循环，相似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，而后，Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环。

咱们以斐波那契数列为例，写一个Fib类，能够做用于for循环：

class Fib(object): def __init__(self): self.a, self.b = 0, 1 # 初始化两个计数器a，b def __iter__(self): return self # 实例自己就是迭代对象，故返回本身 def __next__(self): self.a, self.b = self.b, self.a + self.b # 计算下一个值 if self.a > 100000: # 退出循环的条件 raise StopIteration(); return self.a # 返回下一个值 

如今，试试把Fib实例做用于for循环：

>>> for n in Fib(): ... print(n) ... 1 1 2 3 5 ... 46368 75025 

__getitem__

Fib实例虽然能做用于for循环，看起来和list有点像，可是，把它当成list来使用仍是不行，好比，取第5个元素：

>>> Fib()[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module> TypeError: 'Fib' object does not support indexing 

要表现得像list那样按照下标取出元素，须要实现__getitem__()方法：

class Fib(object): def __getitem__(self, n): a, b = 1, 1 for x in range(n): a, b = b, a + b return a 

如今，就能够按下标访问数列的任意一项了：

>>> f = Fib() >>> f[0] 1 >>> f[1] 1 >>> f[2] 2 >>> f[3] 3 >>> f[10] 89 >>> f[100] 573147844013817084101 

可是list有个神奇的切片方法：

>>> list(range(100))[5:10] [5, 6, 7, 8, 9] 

对于Fib却报错。缘由是__getitem__()传入的参数多是一个int，也多是一个切片对象slice，因此要作判断：

class Fib(object): def __getitem__(self, n): if isinstance(n, int): # n是索引 a, b = 1, 1 for x in range(n): a, b = b, a + b return a if isinstance(n, slice): # n是切片 start = n.start stop = n.stop if start is None: start = 0 a, b = 1, 1 L = [] for x in range(stop): if x >= start: L.append(a) a, b = b, a + b return L 

如今试试Fib的切片：

>>> f = Fib() >>> f[0:5] [1, 1, 2, 3, 5] >>> f[:10] [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] 

可是没有对step参数做处理：

>>> f[:10:2] [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] 

也没有对负数做处理，因此，要正确实现一个__getitem__()仍是有不少工做要作的。

此外，若是把对象当作dict，__getitem__()的参数也多是一个能够做key的object，例如str。

与之对应的是__setitem__()方法，把对象视做list或dict来对集合赋值。最后，还有一个__delitem__()方法，用于删除某个元素。

总之，经过上面的方法，咱们本身定义的类表现得和Python自带的list、tuple、dict没什么区别，这彻底归功于动态语言的“鸭子类型”，不须要强制继承某个接口。

__getattr__

正常状况下，当咱们调用类的方法或属性时，若是不存在，就会报错。好比定义Student类：

class Student(object): def __init__(self): self.name = 'Michael' 

调用name属性，没问题，可是，调用不存在的score属性，就有问题了：

>>> s = Student() >>> print(s.name) Michael >>> print(s.score) Traceback (most recent call last): ... AttributeError: 'Student' object has no attribute 'score' 

错误信息很清楚地告诉咱们，没有找到score这个attribute。

要避免这个错误，除了能够加上一个score属性外，Python还有另外一个机制，那就是写一个__getattr__()方法，动态返回一个属性。修改以下：

class Student(object): def __init__(self): self.name = 'Michael' def __getattr__(self, attr): if attr=='score': return 99 

当调用不存在的属性时，好比score，Python解释器会试图调用__getattr__(self, 'score')来尝试得到属性，这样，咱们就有机会返回score的值：

>>> s = Student() >>> s.name 'Michael' >>> s.score 99 

返回函数也是彻底能够的：

class Student(object): def __getattr__(self, attr): if attr=='age': return lambda: 25 

只是调用方式要变为：

>>> s.age() 25 

注意，只有在没有找到属性的状况下，才调用__getattr__，已有的属性，好比name，不会在__getattr__中查找。

此外，注意到任意调用如s.abc都会返回None，这是由于咱们定义的__getattr__默认返回就是None。要让class只响应特定的几个属性，咱们就要按照约定，抛出AttributeError的错误：

class Student(object): def __getattr__(self, attr): if attr=='age': return lambda: 25 raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr) 

这实际上能够把一个类的全部属性和方法调用所有动态化处理了，不须要任何特殊手段。

这种彻底动态调用的特性有什么实际做用呢？做用就是，能够针对彻底动态的状况做调用。

举个例子：

如今不少网站都搞REST API，好比新浪微博、豆瓣啥的，调用API的URL相似：

• http://api.server/user/friends
• http://api.server/user/timeline/list

若是要写SDK，给每一个URL对应的API都写一个方法，那得累死，并且，API一旦改动，SDK也要改。

利用彻底动态的__getattr__，咱们能够写出一个链式调用：

class Chain(object): def __init__(self, path=''): self._path = path def __getattr__(self, path): return Chain('%s/%s' % (self._path, path)) def __str__(self): return self._path __repr__ = __str__ 

试试：

>>> Chain().status.user.timeline.list '/status/user/timeline/list' 

这样，不管API怎么变，SDK均可以根据URL实现彻底动态的调用，并且，不随API的增长而改变！

还有些REST API会把参数放到URL中，好比GitHub的API：

GET /users/:user/repos 

调用时，须要把:user替换为实际用户名。若是咱们能写出这样的链式调用：

Chain().users('michael').repos

就能够很是方便地调用API了。有兴趣的童鞋能够试试写出来。

__call__

一个对象实例能够有本身的属性和方法，当咱们调用实例方法时，咱们用instance.method()来调用。能不能直接在实例自己上调用呢？在Python中，答案是确定的。

任何类，只须要定义一个__call__()方法，就能够直接对实例进行调用。请看示例：

class Student(object): def __init__(self, name): self.name = name def __call__(self): print('My name is %s.' % self.name) 

调用方式以下：

>>> s = Student('Michael') >>> s() # self参数不要传入 My name is Michael. 

__call__()还能够定义参数。对实例进行直接调用就比如对一个函数进行调用同样，因此你彻底能够把对象当作函数，把函数当作对象，由于这二者之间原本就没啥根本的区别。

若是你把对象当作函数，那么函数自己其实也能够在运行期动态建立出来，由于类的实例都是运行期建立出来的，这么一来，咱们就模糊了对象和函数的界限。

那么，怎么判断一个变量是对象仍是函数呢？其实，更多的时候，咱们须要判断一个对象是否能被调用，能被调用的对象就是一个Callable对象，好比函数和咱们上面定义的带有__call__()的类实例：

>>> callable(Student()) True >>> callable(max) True >>> callable([1, 2, 3]) False >>> callable(None) False >>> callable('str') False 

经过callable()函数，咱们就能够判断一个对象是不是“可调用”对象。

小结

Python的class容许定义许多定制方法，可让咱们很是方便地生成特定的类。

使用枚举类

当咱们须要定义常量时，一个办法是用大写变量经过整数来定义，例如月份：

JAN = 1
FEB = 2
MAR = 3
...
NOV = 11
DEC = 12

好处是简单，缺点是类型是int，而且仍然是变量。

更好的方法是为这样的枚举类型定义一个class类型，而后，每一个常量都是class的一个惟一实例。Python提供了Enum类来实现这个功能：

from enum import Enum Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')) 

这样咱们就得到了Month类型的枚举类，能够直接使用Month.Jan来引用一个常量，或者枚举它的全部成员：

for name, member in Month.__members__.items(): print(name, '=>', member, ',', member.value) 

value属性则是自动赋给成员的int常量，默认从1开始计数。

若是须要更精确地控制枚举类型，能够从Enum派生出自定义类：

from enum import Enum, unique @unique class Weekday(Enum): Sun = 0 # Sun的value被设定为0 Mon = 1 Tue = 2 Wed = 3 Thu = 4 Fri = 5 Sat = 6 

@unique装饰器能够帮助咱们检查保证没有重复值。

访问这些枚举类型能够有若干种方法：

>>> day1 = Weekday.Mon >>> print(day1) Weekday.Mon >>> print(Weekday.Tue) Weekday.Tue >>> print(Weekday['Tue']) Weekday.Tue >>> print(Weekday.Tue.value) 2 >>> print(day1 == Weekday.Mon) True >>> print(day1 == Weekday.Tue) False >>> print(Weekday(1)) Weekday.Mon >>> print(day1 == Weekday(1)) True >>> Weekday(7) Traceback (most recent call last): ... ValueError: 7 is not a valid Weekday >>> for name, member in Weekday.__members__.items(): ... print(name, '=>', member) ... Sun => Weekday.Sun Mon => Weekday.Mon Tue => Weekday.Tue Wed => Weekday.Wed Thu => Weekday.Thu Fri => Weekday.Fri Sat => Weekday.Sat 

可见，既能够用成员名称引用枚举常量，又能够直接根据value的值得到枚举常量。

小结

Enum能够把一组相关常量定义在一个class中，且class不可变，并且成员能够直接比较。

使用元类

type()

动态语言和静态语言最大的不一样，就是函数和类的定义，不是编译时定义的，而是运行时动态建立的。

比方说咱们要定义一个Hello的class，就写一个hello.py模块：

class Hello(object): def hello(self, name='world'): print('Hello, %s.' % name) 

当Python解释器载入hello模块时，就会依次执行该模块的全部语句，执行结果就是动态建立出一个Hello的class对象，测试以下：

>>> from hello import Hello >>> h = Hello() >>> h.hello() Hello, world. >>> print(type(Hello)) <class 'type'> >>> print(type(h)) <class 'hello.Hello'> 

type()函数能够查看一个类型或变量的类型，Hello是一个class，它的类型就是type，而h是一个实例，它的类型就是class Hello。

咱们说class的定义是运行时动态建立的，而建立class的方法就是使用type()函数。

type()函数既能够返回一个对象的类型，又能够建立出新的类型，好比，咱们能够经过type()函数建立出Hello类，而无需经过class Hello(object)...的定义：

>>> def fn(self, name='world'): # 先定义函数 ... print('Hello, %s.' % name) ... >>> Hello = type('Hello', (object,), dict(hello=fn)) # 建立Hello class >>> h = Hello() >>> h.hello() Hello, world. >>> print(type(Hello)) <class 'type'> >>> print(type(h)) <class '__main__.Hello'> 

要建立一个class对象，type()函数依次传入3个参数：

1. class的名称；
2. 继承的父类集合，注意Python支持多重继承，若是只有一个父类，别忘了tuple的单元素写法；
3. class的方法名称与函数绑定，这里咱们把函数fn绑定到方法名hello上。

经过type()函数建立的类和直接写class是彻底同样的，由于Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，而后调用type()函数建立出class。

正常状况下，咱们都用class Xxx...来定义类，可是，type()函数也容许咱们动态建立出类来，也就是说，动态语言自己支持运行期动态建立类，这和静态语言有很是大的不一样，要在静态语言运行期建立类，必须构造源代码字符串再调用编译器，或者借助一些工具生成字节码实现，本质上都是动态编译，会很是复杂。

metaclass

除了使用type()动态建立类之外，要控制类的建立行为，还可使用metaclass。

metaclass，直译为元类，简单的解释就是：

当咱们定义了类之后，就能够根据这个类建立出实例，因此：先定义类，而后建立实例。

可是若是咱们想建立出类呢？那就必须根据metaclass建立出类，因此：先定义metaclass，而后建立类。

链接起来就是：先定义metaclass，就能够建立类，最后建立实例。

因此，metaclass容许你建立类或者修改类。换句话说，你能够把类当作是metaclass建立出来的“实例”。

metaclass是Python面向对象里最难理解，也是最难使用的魔术代码。正常状况下，你不会碰到须要使用metaclass的状况，因此，如下内容看不懂也不要紧，由于基本上你不会用到。

咱们先看一个简单的例子，这个metaclass能够给咱们自定义的MyList增长一个add方法：

定义ListMetaclass，按照默认习惯，metaclass的类名老是以Metaclass结尾，以便清楚地表示这是一个metaclass：

# metaclass是类的模板，因此必须从`type`类型派生： class ListMetaclass(type): def __new__(cls, name, bases, attrs): attrs['add'] = lambda self, value: self.append(value) return type.__new__(cls, name, bases, attrs) 

有了ListMetaclass，咱们在定义类的时候还要指示使用ListMetaclass来定制类，传入关键字参数metaclass：

class MyList(list, metaclass=ListMetaclass): pass 

当咱们传入关键字参数metaclass时，魔术就生效了，它指示Python解释器在建立MyList时，要经过ListMetaclass.__new__()来建立，在此，咱们能够修改类的定义，好比，加上新的方法，而后，返回修改后的定义。

__new__()方法接收到的参数依次是：

1. 当前准备建立的类的对象；

2. 类的名字；

3. 类继承的父类集合；

4. 类的方法集合。

测试一下MyList是否能够调用add()方法：

>>> L = MyList() >>> L.add(1) >> L [1] 

而普通的list没有add()方法：

>>> L2 = list()
>>> L2.add(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module> AttributeError: 'list' object has no attribute 'add' 

动态修改有什么意义？直接在MyList定义中写上add()方法不是更简单吗？正常状况下，确实应该直接写，经过metaclass修改纯属变态。

可是，总会遇到须要经过metaclass修改类定义的。ORM就是一个典型的例子。

ORM全称“Object Relational Mapping”，即对象-关系映射，就是把关系数据库的一行映射为一个对象，也就是一个类对应一个表，这样，写代码更简单，不用直接操做SQL语句。

要编写一个ORM框架，全部的类都只能动态定义，由于只有使用者才能根据表的结构定义出对应的类来。

让咱们来尝试编写一个ORM框架。

编写底层模块的第一步，就是先把调用接口写出来。好比，使用者若是使用这个ORM框架，想定义一个User类来操做对应的数据库表User，咱们期待他写出这样的代码：

class User(Model): # 定义类的属性到列的映射： id = IntegerField('id') name = StringField('username') email = StringField('email') password = StringField('password') # 建立一个实例： u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd') # 保存到数据库： u.save() 

其中，父类Model和属性类型StringField、IntegerField是由ORM框架提供的，剩下的魔术方法好比save()所有由metaclass自动完成。虽然metaclass的编写会比较复杂，但ORM的使用者用起来却异常简单。

如今，咱们就按上面的接口来实现该ORM。

首先来定义Field类，它负责保存数据库表的字段名和字段类型：

class Field(object): def __init__(self, name, column_type): self.name = name self.column_type = column_type def __str__(self): return '<%s:%s>' % (self.__class__.__name__, self.name) 

在Field的基础上，进一步定义各类类型的Field，好比StringField，IntegerField等等：

class StringField(Field): def __init__(self, name): super(StringField, self).__init__(name, 'varchar(100)') class IntegerField(Field): def __init__(self, name): super(IntegerField, self).__init__(name, 'bigint') 

下一步，就是编写最复杂的ModelMetaclass了：

class ModelMetaclass(type): def __new__(cls, name, bases, attrs): if name=='Model': return type.__new__(cls, name, bases, attrs) print('Found model: %s' % name) mappings = dict() for k, v in attrs.items(): if isinstance(v, Field): print('Found mapping: %s ==> %s' % (k, v)) mappings[k] = v for k in mappings.keys(): attrs.pop(k) attrs['__mappings__'] = mappings # 保存属性和列的映射关系 attrs['__table__'] = name # 假设表名和类名一致 return type.__new__(cls, name, bases, attrs) 

以及基类Model：

class Model(dict, metaclass=ModelMetaclass): def __init__(self, **kw): super(Model, self).__init__(**kw) def __getattr__(self, key): try: return self[key] except KeyError: raise AttributeError(r"'Model' object has no attribute '%s'" % key) def __setattr__(self, key, value): self[key] = value def save(self): fields = [] params = [] args = [] for k, v in self.__mappings__.items(): fields.append(v.name) params.append('?') args.append(getattr(self, k, None)) sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params)) print('SQL: %s' % sql) print('ARGS: %s' % str(args)) 

当用户定义一个class User(Model)时，Python解释器首先在当前类User的定义中查找metaclass，若是没有找到，就继续在父类Model中查找metaclass，找到了，就使用Model中定义的metaclass的ModelMetaclass来建立User类，也就是说，metaclass能够隐式地继承到子类，但子类本身却感受不到。

在ModelMetaclass中，一共作了几件事情：

1. 排除掉对Model类的修改；

2. 在当前类（好比User）中查找定义的类的全部属性，若是找到一个Field属性，就把它保存到一个__mappings__的dict中，同时从类属性中删除该Field属性，不然，容易形成运行时错误（实例的属性会遮盖类的同名属性）；

3. 把表名保存到__table__中，这里简化为表名默认为类名。

在Model类中，就能够定义各类操做数据库的方法，好比save()，delete()，find()，update等等。

咱们实现了save()方法，把一个实例保存到数据库中。由于有表名，属性到字段的映射和属性值的集合，就能够构造出INSERT语句。

编写代码试试：

u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
u.save()

输出以下：

Found model: User
Found mapping: email ==> <StringField:email> Found mapping: password ==> <StringField:password> Found mapping: id ==> <IntegerField:uid> Found mapping: name ==> <StringField:username> SQL: insert into User (password,email,username,id) values (?,?,?,?) ARGS: ['my-pwd', 'test@orm.org', 'Michael', 12345] 

能够看到，save()方法已经打印出了可执行的SQL语句，以及参数列表，只须要真正链接到数据库，执行该SQL语句，就能够完成真正的功能。

不到100行代码，咱们就经过metaclass实现了一个精简的ORM框架。

小结

metaclass是Python中很是具备魔术性的对象，它能够改变类建立时的行为。这种强大的功能使用起来务必当心。