python面向对象高级编程

数据封装、继承和多态只是面向对象程序设计中最基础的3个概念

python是动态语言
我们可以在程序运行中，给class绑定任何属性和方法。

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

给实例绑定一个方法

>>> from types import MethodType
>>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法
>>> s.set_age(25) # 调用实例方法

在这里给实例绑定的方法，只对当前实例有效。
给class绑定的属性和方法是对所有实例都有效的，就像是一个静态的。

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

使用__slots__

这是一个特殊的变量，可以用来限制类class只能使用的属性名称

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

只对当前类实例起作用，无法继承，除非子类也定义该变量，就可以继承父类的值了。

使用@property

将一个方法变成属性来调用

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
#这是一个可以验证

在设置属性值的时候，可以添加验证，如：

    def verify(self,value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')

多重继承，MixIn

class Dog(Mammal, RunnableMixIn, CarnivorousMixIn):
    pass

一个子类可以有多个父类，
这样一来，我们不需要复杂而庞大的继承链，只要选择组合不同的类的功能，就可以快速构造出所需的子类。

定制类

class Student(object):
    def __init__(self, name):
        self.name = name
        self.a, self.b = 0, 1 # 初始化两个计数器a，b

设置给用户看到的异常信息：

    def __str__(self):
        return 'Student object (name=%s)' % self.name

设置调试看到的异常信息：

    __repr__ = __str__

将类class返回成一个可迭代对象：

    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 # 返回下一个值

当执行到raise StopIteration()时，循环程序会终止
可循环调用的迭代类，调用结果：

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

实现索引操作：

 def __getitem__(self, n):
        return n+1

切片对象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

如果需要抛出异常 raise AttributeError( )
在一个实例中，如果没有找到属性的时候，使用__getattr__方法：

    def __getattr__(self, attr):
#这是一个函数
        if attr=='age':
            return lambda: 25
#这是一个属性
        if attr=='score':
            return 99

使用__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'

使用__call__方法可以让类调用自己

    def __call__(self):
        print('My self')
>>> s = Student('Michael')
>>> s() # self参数不要传入
My self

我们还可以使用callable( )方法判断一个对象是不是一个可被调用的方法

>>> callable(max)
True
>>> callable([1, 2, 3])
False

使用枚举类

创建一个常量可以使用Enum类 枚举

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
#执行
for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)

创建一个自定义的枚举类，成员值默认从1开始

from enum import Enum, unique

@unique
class Weekday(Enum):
    Sun = 0 # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Sat = 6

#调用结果
>>> print( Weekday.Mon)
Weekday.Mon
>>> print( Weekday['Mon'])
Weekday.Mon
>>> print( Weekday.Mon.value)
1
>>> print( Weekday(6))
Weekday.Sat 

使用元类

在运行过程中动态创建一个类可以使用type( )

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

参数依次：类名，父类，类的内部属性或方法
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)

参数依次：类的对象，类名，父类，类的方法
创建一个metaclass类对象

class MyList(list, metaclass=ListMetaclass):
    pass

成功创建的MyList类就拥有了add方法
可应用于ORM框架中，隐式被拥有一些方法。
我们期待调用时的代码是这样的：

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

就需要定义：

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)

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')

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)

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

至此，一个添加数据的sql语句就生成了。