面向对象高级编程

使用slots

Python作为动态语言，允许动态的给类或实例添加属性或方法：

class Student(object):
    pass

s = Student()
s.name = 'Michael'  # 给实例添加属性

def set_age(self, age):
    self.age = age
from types import MethodType  # MethodType()函数可以将函数转换为方法

s.set_age = MethodType(set_age, s)  # 给实例添加方法

给实例绑定的方法及属性只对当前实例有效。

想要给所有实例都绑定方法，可以将方法绑定给类：

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

当需要限制实例属性的添加时，可以使用__slots__变量，指定可以添加的属性名：

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

__slots__变量只限制当前class类，不会被子类继承。
但当子类也定义__slots__变量时，子类允许的属性为自身的__slots__变量加上父类的__slots__变量。

使用@property

关于属性问题：

直接给实例添加属性简单但不安全，无法进行参数检查。
在类中设置私有属性，然后提供set和get方法又过于繁琐。

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!')
        self._score = value

@property装饰器的使用：

在getter方法的定义前加上@property
@property会创建另一个装饰器@score.setter，负责把setter方法变成属性赋值
然后实例就可以像获取属性一样使用setter和getter方法
注意：属性的方法名不能和实例属性重名，一般私有属性使用_修饰

s = Student()
s.score = 60     # 实际转化为s.set_score(60)
s.score          # 实际转化为s.get_score()
s.score = '123'  # ValueError: score must be an integer!

可以只定义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 2022 - self._birth

多继承

多继承则指一个类可以有多个基类，相反则是单继承。通过多继承，一个子类就可以同时获得多个父类的所有功能。
在设计类的继承关系时，通常，主线都是单一继承下来的，多继承的设计称为MixIn。
多继承只用在声明类时传入多个父类即可实现：class Dog(Animal, Runnable): pass

任何面向对象编程语言都支持多重继承，但像java这种只能通过接口实现有限程度的多继承。

定制类

Python的class有许多特殊用途的函数及属性，使用__xxx__修饰，可以用于定制类。如：__slots__、__len__()等。

len()

__len__()方法返回长度。
在Python中，调用len()函数获取对象长度时，实际上，在len()函数内部，会自动去调用该对象的__len__()方法。
所以可以根据需要编写自己的__len__()方法：

class MyDog(object):
    def __len__(self):
        return 100

dog = MyDog()
len(dog)  # 100

str()和repr()

__str__()方法用于定制print(实例)时输出的结果：

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)

但是__str__()方法只修改了调用print()输出的结果，当在交互式窗口中直接访问实例时，输出并未被修改。
这是因为直接显示变量调用的不是__str__()，而是__repr__()

两者的区别：

__str__()返回用户看到的字符串
__repr__()返回开发者看到的字符串

所以想要同时修改时的解决办法：

同时实现两个函数
在类中添加代码 __repr__ = __str__，使__repr__()方法指向__str__()方法

iter()和next()

当想用for...in循环遍历对象时，需要在对象中提供__iter__()方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环。

# 斐波那契数列
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 # 返回下一个值

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

getitem()

通过__iter__()方法和__next__()方法虽然可以实现for...in循环的遍历，但是不能像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

Fib()[0]  # 1
Fib()[1]  # 1
Fib()[2]  # 2

但是以上的__getitem__()方法只实现了最简单的索引，对于切片、步幅、负数索引、key索引等功能并为实现，如果要实现，需要做额外的逻辑判断，如切片：

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()[0:5]   # [1, 1, 2, 3, 5]
Fib()[0:10]  # [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

getattr()

正常情况下，当我们调用类的方法或属性时，如果不存在，就会报错。
除了在类中添加需要的属性外，还可以通过实现Python中的__getattr__()方法。
__getattr__()方法，可以动态返回一个属性或方法。写法如下：

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

    def __getattr__(self, attr):
        if attr=='score':
            return 99
        raise AttributeError("'Student' object has no attribute '%s'" % attr)

Student().score  # 99
Student().age    # Error

当调用不存在的属性或方法，如score时，Python解释器会调用__getattr__(self, 'score')来尝试获得属性或方法。当要获取的方法也不在__getattr__()考虑的范围内时，抛出AttributeError异常。

应用实例：

现在很多网站使用REST API，调用API的URL类似：
http://api.server/user/friends
http://api.server/user/timeline/list
如果要写SDK，给每个URL对应的API都写一个方法，工作量巨大。
要求：

利用完全动态的__getattr__，实现API的链式调用：无论API怎么变，SDK都可以根据URL实现完全动态的调用
有些REST API会把参数放到URL中，比如GitHub的API：GET /users/:user/repos调用时，需要把:user替换为实际用户名。
写出这样的链式调用：Chain().users('michael').repos
返回结果为：/users/michael/repos

实现代码：

import types

class Chain():
    def __init__(self, path=""):
        self._path = path

    def __getattr__(self, path):
        if self._path.split('/')[-1] == 'users':
            return self.change
        else:
            self._path = '%s/%s' % (self._path, path)

        return self

    def change(self, path):
        self._path = '%s/%s' % (self._path, path)
        return self

    def __str__(self):
        return  self._path

    __repr__ = __str__

print(Chain().users.users('michael').repos)  # /users/michael/repos

call()

传统调用实例方法的语法为：实例名.方法名()。
可以通过给实例添加__call__()方法来直接对实例进行调用（不用传入self参数）：

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.

对于一个变量，判断其是否可以被调用，可以使用callable()函数来判断其是否为Callable对象。

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

改善上文应用实例

对比发现要求中调用代码Chain().users('michael').repos与个人实现调用代码Chain().users.users('michael').repos存在差异：多了一次.users

结合学习的__call__()方法，改进代码如下：

class Chain2():
    def __init__(self, path=""):
        self._path = path

    def __getattr__(self, path):
        self._path = '%s/%s' % (self._path, path)
        return self

    def __call__(self, path):
        self._path = '%s/%s' % (self._path, path)
        return self

    def __str__(self):
        return  self._path

    __repr__ = __str__

print(Chain2().users('michael').repos)  # /users/michael/repos

枚举类

对于常量的定义，原有的使用大写变量名定义，如月份：

JAN = 1
FEB = 2
...
DEC = 12

这样定义虽简单，但仍是可以改变的变量，是int类型。

更优的方法是为枚举类型定义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类型的枚举类，访问其成员的方法：

直接通过Month.Jan来引用一个常量

通过for...in循环枚举成员

	for name, member in Month.__members__.items():
	    print(name, '=>', member, ',', member.value)
	# Jan => Month.Jan , 1
	# Feb => Month.Feb , 2

	# Dec => Month.Dec , 12

枚举类的成员会自动被赋予value属性，默认从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装饰器可以检查保证枚举类成员的value中没有重复值。

访问枚举类成员的多种方法：

使用枚举类名.成员名访问成员：Weekday.Sun # Weekday.Sun
使用枚举类名['成员名']访问成员：Weekday['Mon'] # Weekday.Mon
使用枚举类名(value)访问value对应的成员：Weekday(2) # Weekday.Tue
使用枚举类名.成员名.value访问成员的value：Weekday.Wed.value # 3
使用for...in循环遍历枚举类

Python04

面向对象高级编程

使用__slots__

使用@property

多继承

定制类

__len__()

__str__()和__repr__()

__iter__()和__next__()

__getitem__()

__getattr__()