6.面向对象高级编程

在Python中，面向对象有很多高级特性，允许我们写出非常强大的功能。包括多重继承、定制类、元类等概念。

__slots__属性使用

正常情况下，当定义了一个class并创建了一个class的实例后，可以给该实例绑定任何属性和方法，这就是动态语言的灵活性。动态绑定允许在程序运行的过程中动态给实例或class加上功能
Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性

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

使用__slots__要注意，slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的
除非在子类中也定义__slots，这样，子类实例允许定义的属性就是自身的__slots__加上父类的__slots__

@property

为了封装属性并引入参数有效性检查，推荐在class内进行getter和setter的设置，但调用方法略显复杂，没有直接用属性来得直接简单。
Python内置的@property装饰器负责把一个方法变成属性调用
把一个getter方法变成属性，只需要加上@property就可以了
@property本身可创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值
应用@property后，属性的调用和设置就可以直接进行，但底层又是getter和setter的逻辑，实现了简单调用且不失封装性的效果

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

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

只定义getter方法，不定义setter方法就是一个只读属性。

class Student(object):
# birth是可读写属性，age是只读属性
    @property
    def birth(self):
        return self._birth

    @birth.setter
    def birth(self, value):
        self._birth = value

    @property
    def age(self):
        return 2015 - self._birth

要特别注意：属性的方法名不要和实例变量重名，否则会造成无限递归，最终导致栈溢出报错RecursionError。
@property广泛应用在类的定义中，可以让调用者写出简短的代码，同时保证对参数进行必要的检查，程序运行时减少了出错的可能性。

练习

请利用@property给一个Screen对象加上width和height属性，以及一个只读属性resolution

# -*- coding: utf-8 -*-
class Screen(object):
        
    @property
    def width(self):
        return self._width

    @width.setter
    def width(self, value):
        self._width = value
    
    @property
    def height(self):
        return self._height

    @height.setter
    def height(self, value):
        self._height = value
    
    @property
    def resolution(self):
        return self._width * self._height

多重继承

Python允许使用多重继承，因此，MixIn就是一种常见的设计

class Dog(Mammal, Runnable):
    pass

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

利用特殊函数定制类

Python的class允许定义许多定制方法，可以让我们非常方便地生成特定的类。

__str__方法

定义好__str__()方法可以规定返回类对象实例的信息，打印出来的实例，不但好看，而且容易看出实例内部重要的数据
直接显示变量调用的不是__str__()，而是__repr__()，两者的区别是__str__()返回用户看到的字符串，而__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__ 
...
>>> print(Student('Michael'))
Student object (name: Michael)

>>> s = Student('Michael')
>>> s
Student object (name: Michael)

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

__getitem__方法

要表现得像list那样按照下标取出元素，需要实现__getitem__()方法
以斐波那契数列为例，写一个Fib类，可以同时用索引和切片形式获取值

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

但是与list相比，Fib切片没有对step参数做处理，也没有考虑负数，所以要正确实现一个__getitem__()还是有很多工作要做的。此外，如果把对象看成dict，那么__getitem__()的参数也可能是一个可以作key的object，例如str。
与__getitem__()对应的是__setitem__()方法，把对象视作list或dict来对集合赋值。最后，还有一个__delitem__()方法，用于删除某个元素。
通过上述方法，自定义的类可以表现得和Python自带的list、tuple、dict没什么区别，这完全归功于动态语言的“鸭子类型”，不需要强制继承某个接口。

__getattr__方法

写一个__getattr__()方法，动态返回一个属性
当调用不存在的属性时，Python解释器会试图调用__getattr__(self, ‘score’)来尝试获得属性
只有在没有找到属性的情况下，才调用__getattr__，已有的属性，比如name，不会在__getattr__中查找
__getattr__默认返回是None。要让class只响应特定的几个属性，我们就要按照约定，抛出AttributeError的错误
实际上可以把一个类的所有属性和方法调用全部动态化处理。这种完全动态调用的特性作用就是可以针对完全动态的情况作调用。例如：实现一个动态生成地址的类

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__方法

任何类，只需要定义一个__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()
My name is Michael.

此外__call__()还可以定义参数。对实例进行直接调用与对一个函数进行调用一样，完全可以把对象看成函数，把函数看成对象，因为这两者之间本来就没啥根本的区别，即python的万物皆对象理念。
如果把对象看成函数，那么函数本身其实也可以在运行期动态创建出来，因为类的实例都是运行期创建出来的。
如何判断一个变量是对象还是函数呢？更多的时候，需要判断一个对象是否能被调用，能被调用的对象就是一个Callable对象，通过callable()函数可以判断一个对象是否是“可调用”对象

枚举类

当需要定义常量时，可以为这样的枚举类型定义一个class类型，然后，每个常量都是class的一个唯一实例。Python提供了Enum类来实现这个功能
Enum可以把一组相关常量定义在一个class中，且class不可变，而且成员可以直接比较

from enum import Enum

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

# 直接使用Month.Jan来引用一个常量
# value属性是自动赋给成员的int常量，默认从1开始计数
for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)

...
Jan => Month.Jan , 1
Feb => Month.Feb , 2
Mar => Month.Mar , 3
Apr => Month.Apr , 4
May => Month.May , 5
Jun => Month.Jun , 6
Jul => Month.Jul , 7
Aug => Month.Aug , 8
Sep => Month.Sep , 9
Oct => Month.Oct , 10
Nov => Month.Nov , 11
Dec => Month.Dec , 12

如果需要更精确地控制枚举类型，可以从Enum派生出自定义类：

from enum import Enum, unique

@unique # @unique装饰器可以帮助检查保证没有重复值
class Weekday(Enum):
    Sun = 0 # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

# 访问：既可以用成员名称引用枚举常量
# 又可以直接根据value的值获得枚举常量
Weekday.Mon
Weekday(1) # 也是Weekday.Mon
Weekday.Tue
Weekday['Tue'] # 也是Weekday.Tue

练习

把Student的gender属性改造为枚举类型，可以避免使用字符串：

# -*- coding: utf-8 -*-
from enum import Enum, unique

class Gender(Enum):
    Male = 0
    Female = 1

class Student(object):
    def __init__(self, name, gender):
        self.name = name
        if (gender in (Gender.Male, Gender.Female)):
            self.gender = gender
        else:
            self.gender = None

元类

使用type()动态创建类

type()函数可以查看一个类型或变量的类型，一个class的类型就是“type”，一个实例的类型是“class 类名”。
class的定义是运行时动态创建的，创建class的方法就是使用type()函数
type()函数既可以返回一个对象的类型，又可以创建出新的类型
要创建一个class对象，type()函数依次传入3个参数：

1. class的名称；
2. 继承的父类集合，注意Python支持多重继承，如果只有一个父类，需传入tuple的单元素写法；
3. class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上

通过type()函数创建的类和直接写class完全一样，因为Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，然后调用type()函数创建出class。
正常情况下，都用class Xxx…来定义类，但是，type()函数也允许动态创建出类，也就是说，动态语言本身支持运行期动态创建类

metaclass

控制类的创建行为还可以使用metaclass，直译为元类
metaclass允许创建类或者修改类。可以把类看成是metaclass创建出来的“实例”。
metaclass是Python中非常具有魔术性的对象，它可以改变类创建时的行为。一般不会涉及到使用metaclass