第四章 深入类和对象
4.1 鸭子类型和多态
class Cat(object):
def say(self):
print("i am a cat")
class Dog(object):
def say(self):
print("i am a fish")
class Duck(object):
def say(self):
print("i am a duck")
animal = Cat
animal().say
上面三个类都有一个函数say()。现在定义一个对象animal，有可能是Cat、Dog或者Duck（多态）。
animal_list = [Cat, Dog, Duck]
for animal in animal_list:
animal().say()
i am a cat
i am a fish
i am a duck
上面分别打印出三个类的say方法。
类只要定义同一个方法（鸭子类型），就可以实现多态。
类中的鸭子类型：只要类里面有同样的方法，在特定功能上就看成同一种类。
a = ["bobby1", "bobby2"]
b = ["bobby2", "bobby"]
name_tuple = ("bobby3", "bobby4")
name_set = set()
name_set.add("bobby5")
name_set.add("bobby6")
a.extend(b)
print(a)
a.extend(name_tuple)
print(a)
a.extend(name_set)
print(a)
['bobby1', 'bobby2', 'bobby2', 'bobby']
['bobby1', 'bobby2', 'bobby2', 'bobby', 'bobby3', 'bobby4']
['bobby1', 'bobby2', 'bobby2', 'bobby', 'bobby3', 'bobby4', 'bobby5', 'bobby6']
extend()有个参数Iterable(可迭代对象)，list、tuple、set都是可迭代对象。可迭代对象也是鸭子类型，里面实现了迭代器（比如__iter__魔法函数，或者是__getitem__），魔法函数充分利用了鸭子类型，只要实现了某种魔法函数，就可以看做某种类型。
python中有很多方法，只要求参数是某种类型，不指定具体是哪种结构。
4.2-4.3 抽象基类(abc模块)
python是动态语言，没有变量类型，变量只是一个符号，可以指向任何类型的对象，因此天然支持多态。由于是动态语言，不需要指定变量类型，因此少了一个编译时检查错误的环境。在python中写错代码，事先是很难知道的，只有在运行时才会发现错误，即无法做类型检查。
python的类不需要继承，只要实现了某些魔法函数，就会拥有某些类型的特性（协议）。
抽象基类的意思是：
- 在基类中设定好一些方法，所以继承基类的类都必须复写这些方法
- 抽象基类无法实例化
为什么会有抽象基类这个概念，Python是基于鸭子类型的，在类中直接实现某些方法不就行了吗？
两种应用场景来说明：
检查某个类是否有某种方法
class Company(object):
"""
检查Company类是否可以计算长度
"""
def __init__(self, employee_list):
self.employee = employee_list
def __len__(self):
return len(self.employee)
com = Company(["bobby1","bobby2"])
print(len(com))
print(hasattr(com, "__len__")) # 在类中，函数也是一种属性
2
True
在某些情况之下判定某个对象的类型
如果没有抽象基类，必须使用hasattr，但isinstance这种用法更好，collections.abc模块中有Sized抽象基类，有抽象方法__len__，com实现了__len__方法。
from collections.abc import Sized
isinstance(com, Sized)
强制某个子类必须实现某些方法
假如实现一个web框架，要集成缓存cache，以后也希望可以用redis、cache、memorychache替换。那么一开始就需要设计一个抽象基类，指定子类必须实现某些方法。
class CacheBase(metaclass=abc.ABCMeta):
# 从缓存中获取数据，必须用户自己实现
@abc.abstractmethod
def get(self, key):
pass
# 添加数据，必须用户自己实现
@abc.abstractmethod
def set(self, key, value):
pass
上面相当于一个缓存组件，用户在使用的时候，可以使用redis、cache、或者memorychache来进行缓存，但是自己写缓存子类的时候，必须实现get、set方法。
模拟一个抽象基类：
class CacheBase():
def get(self, key):
raise NotImplementedError
def set(self, key, value):
raise NotImplementedError
定义一个子类继承抽象基类，不重写方法：
class RedisCache(CacheBase):
pass
redis_cache = RedisCache()
redis_cache.set("key", "value")
Traceback (most recent call last):
File "D:/py_tutrial/AdvancePython-master/chapter04/abc_test.py", line 61, in <module>
redis_cache.set("key", "value")
File "D:/py_tutrial/AdvancePython-master/chapter04/abc_test.py", line 53, in set
raise NotImplementedError
NotImplementedError
会抛出NotImplementedError 异常
模拟的方法会有一个不好的地方，在调用set函数的时候才会抛出异常。我们希望在初始化的时候（实例化的时候）就能够抛出异常，这需要用到abc 模块。
import abc
class CacheBase(metaclass=abc.ABCMeta):
@abc.abstractmethod # 抽象方法，就不用raise异常
def get(self, key):
pass
@abc.abstractmethod
def set(self, key, value):
pass
关于abc的模块，python中有两个地方，一个就是abc（全局），另外一个是collections.abc。
这时候再调用：
class RedisCache(CacheBase):
pass
redis_cache = RedisCache()
redis_cache.set("key", "value")
Traceback (most recent call last):
File "D:/py_tutrial/AdvancePython-master/chapter04/abc_test.py", line 60, in <module>
redis_cache = RedisCache()
TypeError: Can't instantiate abstract class RedisCache with abstract methods get, set
抛出异常，我们必须重新定义get、set方法。
我们重新定义set方法：
class RedisCache(CacheBase):
def set(self, key, value):
pass
redis_cache = RedisCache()
redis_cache.set("key", "value")
Traceback (most recent call last):
File "D:/py_tutrial/AdvancePython-master/chapter04/abc_test.py", line 59, in <module>
redis_cache = RedisCache()
TypeError: Can't instantiate abstract class RedisCache with abstract methods get
异常只告诉我们要重载get，已经没有set的异常了。
采用abc模块后，在实例化的时候就抛出异常了，可以强制子类实现某些方法。
在python中已经实现了通用了抽象基类，放在collections.abc模块中，点进去看：
__all__ = ["Awaitable", "Coroutine",
"AsyncIterable", "AsyncIterator", "AsyncGenerator",
"Hashable", "Iterable", "Iterator", "Generator", "Reversible",
"Sized", "Container", "Callable", "Collection",
"Set", "MutableSet",
"Mapping", "MutableMapping",
"MappingView", "KeysView", "ItemsView", "ValuesView",
"Sequence", "MutableSequence",
"ByteString",
]
列表里的都是抽象基类，点进抽象基类里：
class Awaitable(metaclass=ABCMeta):
__slots__ = ()
@abstractmethod
def __await__(self):
yield
@classmethod
def __subclasshook__(cls, C):
if cls is Awaitable:
return _check_methods(C, "__await__")
return NotImplemented
有个很重要的魔法函数 __subclasshook__
看上面的例子
class Company(object):
def __init__(self, employee_list):
self.employee = employee_list
def __len__(self):
return len(self.employee)
com = Company(["bobby1","bobby2"])
from collections.abc import Sized
print(isinstance(com, Sized))
com并没有继承Sized，但却可以判断出com是Sized类型，为什么能判断出来，点进去看Sized：
class Sized(metaclass=ABCMeta):
__slots__ = ()
@abstractmethod
def __len__(self):
return 0
@classmethod
def __subclasshook__(cls, C):
if cls is Sized:
return _check_methods(C, "__len__")
return NotImplemented
这里面也有个魔法函数 __subclasshook__，这个函数首先判断传递进来的对象C有没有__len__方法，有则返回True。
所以例子里面就是利用了Sized的魔法函数__subclasshook__，如果com有__len__方法，则判断com是Sized类型。
当然isinstance的功能并没有看起来这么简单，它内部会做很多的步骤，比如：
我们实现
class A:
pass
class B(A):
pass
b = B()
print(isinstance(b, A))
True
所以isinstance不只是去找__subclasshook__，还会去找继承链。
综上，抽象基类有两个用途，一是调用isinstance，二是可以做接口的强制规定。
可以看到Python在尽量使用鸭子类型，抽象基类也不推荐使用，抽象基类在设计的时候容易设计过度，反而不容易理解。
4.4 isinstance和type的区别
为什么尽量使用isinstance而少使用type
举个例子说明：
class A:
pass
class B(A):
pass
b = B()
print(isinstance(b, B))
print(isinstance(b, A))
True
True
B是A的子类，所以b也是A类。
使用type时：
print(type(b))
print(type(b) is B)
print(type(b) is A)
<class '__main__.B'>
True
False
可以看到b是B类，type(b)指向B，虽然B继承A，但A和B是两个不同的对象，但是isinstance会找继承链。
这里有个知识点is和==的区别，is在判断两个对象的id是否相同：
print(id(B))
print(id(type(b)))
2158572618624
2158572618624
==是在判断值是否相同
4.5 类变量和实例变量
class A:
aa = 1
def __init__(self, x, y):
self.x = x
self.y = y
a = A(2,3)
print(a.x, a.y, a.aa)
print(A.aa)
print(A.x)
2 3 1
1
print(A.x)
AttributeError: type object 'A' has no attribute 'x'
aa是类变量，__init__中的self是实例，所以self.x，self.y是实例变量。
实例化后(a)，a.aa先在实例变量中查找，没有再向上从类变量中查找。
类没有办法向下查找变量，因为实例变量是绑定在具体实例中的，如果在类变量中没有找到，则抛出异常。
A.aa = 11
print(a.x, a.y, a.aa)
a.aa = 100
print(a.x, a.y, a.aa)
b = A(3,5)
print(b.aa)
2 3 11
2 3 100
11
修改类中的aa变量后，已经实例化的aa变量也会改变（实例aa变量指向类aa变量指向的对象）。
修改实例aa变量后，a.aa指向100，但A.aa仍然指向11，先查找实例中的aa变量，找到不会再向上查找类的aa变量。
4.7 类属性和实例属性以及查找顺序
class A：
name = 'A'
a = A()
print(a.name)
A
实例是有自己的属性的，可以在类里面初始化
class A：
name = 'A'
def __init__(self):
self.name = "obj"
a = A()
print(a.name)
obj
a.name的查找顺序是由下而上的，所以首先查找实例的name，如果查不到再向上查找类的name。
在多继承里，查找循序会变得复杂。
首先看下一种继承关系，python比较早的继承算法：MRO算法
DFS：深度优先搜索
属性查找顺序是A、B、D、C、E，比如A中有个方法，在B中没有，那么则会去D中查找。
这种查找顺序其实是合理的，A从B、C继承，先搜索B的那个继承链。
但如果换一种继承方式，这种逻辑就不合理
A继承于B、C，B、C继承于D（菱形继承），这种情况下使用DFS的逻辑就不合适。如果使用的是C中继承的方法，那么从B、D、C的顺序就不合理，这样相当于C永远无法覆盖D中的方法。
这种情况下改为广度优先算法BFS。
但这种方法又会出现问题
如上图，如果D和C中有同名的方法，那在搜索的时候，在B中没找到，就会去C中找。但此时B继承于D，而C继承于A，此时D、B应该看成一个整体，所以B后应该是D。所以广度优先算法BFS在这种情况下又不合适了。
Python3中的继承算法是C3算法，可以克服上述两个方法的缺点。
来看一下查找的例子：
#新式类
class D:
pass
class E:
pass
class C(E):
pass
class B(D):
pass
class A(B, C):
pass
print(A.__mro__)
(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.E'>, <class 'object'>)
可以看到继承的顺序。
4.6 静态方法、类方法以及实例方法和参数
class Date:
#构造函数
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def __str__(self):
return "{year}/{month}/{day}".format(year=self.year,
month=self.month, day=self.day)
new_day = Date(2018, 12, 10)
print（new_day）
2018/12/10
def __str__(self)是实例方法，普通情况下类中定义的方法都是实例方法
class Date:
#构造函数
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def tomorrow(self):
self.day += 1
def __str__(self):
return "{year}/{month}/{day}".format(year=self.year,
month=self.month, day=self.day)
new_day = Date(2018, 12, 10)
new_day.tomorrow()
print(new_day)
2018/12/11
new_day.tomorrow()，没有传入参数，python解释器会自动变成tomorrow(new_day)。
上面就是实例方法的使用。
接下来讲解静态方法：
class Date:
#构造函数
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def tomorrow(self):
self.day += 1
def __str__(self):
return "{year}/{month}/{day}".format(year=self.year,
month=self.month, day=self.day)
date_str = "2018-12-31"
year, month, day = tuple(date_str.split("-"))
new_day = Date(int(year), int(month), int(day))
print (new_day)
2018/12/10
用.split先对字符串切片，然后实例化Date。这组方法有个缺陷，就是每次对Date实例化时，都需要先对字符串切片。
我们可以把处理date的逻辑拿到类中，就是定义一个静态方法。
class Date:
#构造函数
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def tomorrow(self):
self.day += 1
# 静态方法不需要self参数，也不需要cls对象
@staticmethod
def parse_from_string(date_str):
year, month, day = tuple(date_str.split("-"))
return Date(int(year), int(month), int(day))
date_str = "2018-12-10"
new_day = Date.parse_from_string(date_str)
print(new_day)
2018/12/31
这样我们使用时，代码变精简了，不需要每次都写代码处理一次date。
但是静态方法不好的地方是，在return的时候采用硬编码方式（Date()），如果改一下类名称为MyDate，那么我们也要改掉return的Date为MyDate。
所以有了一个python中常用的方法，@classmethod
class Date:
#构造函数
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def tomorrow(self):
self.day += 1
@staticmethod
def parse_from_string(date_str):
year, month, day = tuple(date_str.split("-"))
return Date(int(year), int(month), int(day))
# 要传递cls，代表类本身
@classmethod
def from_string(cls, date_str):
year, month, day = tuple(date_str.split("-"))
return cls(int(year), int(month), int(day)) # 直接返回cls,不是硬编码
def __str__(self):
return "{year}/{month}/{day}".format(year=self.year,
month=self.month, day=self.day)
date_str = "2018-12-10"
new_day = Date.from_string(date_str)
print(new_day)
2018/12/10
@classmethod方法里不是采用硬编码，传递cls参数。
classmethod貌似可以完全替代staticmethod，那么staticmethod的作用是什么？
假设在另外一种场景，要判断字符串是不是合法的：
class Date:
#构造函数
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def tomorrow(self):
self.day += 1
@staticmethod
def parse_from_string(date_str):
year, month, day = tuple(date_str.split("-"))
return Date(int(year), int(month), int(day))
@staticmethod
def valid_str(date_str):
year, month, day = tuple(date_str.split("-"))
if int(year)>0 and (int(month) >0 and
int(month)<=12) and (int(day) >0 and int(day)<=31):
return True
else:
return False
@classmethod
def from_string(cls, date_str):
year, month, day = tuple(date_str.split("-"))
return cls(int(year), int(month), int(day))
def __str__(self):
return "{year}/{month}/{day}".format(year=self.year,
month=self.month, day=self.day)
print(Date.valid_str("2018-12-32"))
1990/2/1
28
在判断字符串时，不需要返回对象，只有判断（True or False），这时候就没有必要传递cls参数进去。
静态方法，类方法必须加装饰器，实例方法就是普通的函数。
4.8 数据封装和私有属性
from class_method import Date
class User:
def __init__(self, birthday):
self.__birthday = birthday
def get_age(self):
#返回年龄
return 2018 - self.__birthday.year
user = User(Date(1990,2,1))
print(user.birthday)
print(user.get_age())
1990/2/1
28
输出了birthday和年龄，但一般我们希望将birthday隐藏掉，不希望用户直接看到。
在python中是没有private的，做法是添加双下划线。
from class_method import Date
class User:
def __init__(self, birthday):
self.__birthday = birthday
def get_age(self):
#返回年龄
return 2018 - self.__birthday.year
user = User(Date(1990,2,1))
print(user.__birthday)
print(user.get_age())
print(user.__birthday)
AttributeError: 'User' object has no attribute '__birthday'
告诉我们没有这个__birthday，这样就相当于私有属性的封装。
私有属性是无法通过实例.__birthday来访问的，只能通过公共方法get_age间接获取__birthday。
当然，函数方法上也可以加双划线变为私有属性。
实际上，python封装私有属性，是对原有属性做变形，把名字改掉。
打印_classname__attr：
print(user._User__birthday)
1990/2/1
所以加双下划线不是从语言层面上来解决私有性，只是加了一些小技巧。把birthday变形成了_User__birthday。
4.9 python 的自省机制
自省是通过一定的机制查询到对象的内部结构
from class_method import Date
class Person:
"""
人
"""
name = "user"
class Student(Person):
def __init__(self, school_name):
self.school_name = school_name
user = Student("慕课网")
#通过__dict__查询属性
print(user.__dict__)
print(user.name)
{'scool_name': '慕课网'}
user
dict在python中是c语言实现的，所以效率很高，还有很多优化，这是个性能很高的数据结构。
我们理清关系，user是Student的实例，Student是Person的子类。
看两个输出，既然__dict__打印的是实例属性，为什么user.name打印出来的user没有进入dict呢？
因为name属于Person，是Person类属性，是Person对象空间里的值，并不是Student的属性，没有在Student的对象空间里。用.name这种方法，其实是会向上查找的。
print(Person.__dict__)
{'__module__': '__main__', '__doc__': '\n 人\n ', 'name': 'user', '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}
再用Person.__dict__的时候，里面是有“name”的。
如果对user的属性添加值：
user.__dict__["school_addr"] = "北京市"
print(user.school_addr)
北京市
所以__dict__我们可以取出来，也可以添加值，可以完成动态操纵user对象。
print(dir(user))
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'scool_name']
dir会列出对象中所有的属性，比__dict__功能更加强大，但只有属性名称，没有属性值。
4.10 super真的是调用父类吗
class A:
def __init__(self):
print ("A")
class B(A):
def __init__(self):
print ("B")
b = B()
B
这个打印逻辑很简单，但某种情况下，我们希望再调用父类的init方法。
class A:
def __init__(self):
print ("A")
class B(A):
def __init__(self):
print ("B")
super().__init__()
b = B()
B
A
添加super函数，获取父类的init方法。
这里会有两个疑问：
- 既然B重写了A的构造函数（不一定要是init），为什么还要调用super？
- super的执行顺序是什么样的？
第一个问题回答：
在某些情况下，比如多线程的时候：
from threading import Thread
class MyThread(Thread):
def __init__(self, name, user):
self.user = user
# self.name = name 实际上不用做这一步
super().__init__(name=name) # 不用自己再写处理逻辑
定义自己的MyThread类，继承于Thread，定义初始化方法时，可以使用父类的方法。
class Thread:
_initialized = False
def __init__(self, group=None, target=None, name=None,
args=(), kwargs=None, *, daemon=None):
Thread类中初始化方法有个参数name，Thread有很多处理的逻辑，那我们可以直接调用父类，好处是可以重用代码。
第二个问题回答：
不要认为super是调用父类方法，执行顺序涉及到mro算法。
class A:
def __init__(self):
print ("A")
class B(A):
def __init__(self):
print ("B")
super().__init__()
class C(A):
def __init__(self):
print ("C")
super().__init__()
class D(B, C):
def __init__(self):
print ("D")
super(D, self).__init__()
print(D.__mro__)
d = D()
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
D
B
C
A
可以看到顺序是D、B、C、A，如果是调用父类方法这种逻辑，那么打印应该是D、B、A、C。
4.11 mixin继承案例
python是支持多继承的，但是也不推荐编码使用多继承，设计不好很容易造成关系混乱，mro算法也可能造成预料不到的问题。python中推荐的做法是mixin（混合模式）的模式。
class GoodListViewSet(CacheResponseMixin,mixins.ListModelMixin,
mixins.RetrieveModelMixin,viewsets.GenericViewSet):
"""
商品列表页，分页，搜索，过滤，排序
"""
只写一个类，就能完成商品列表页，分页，搜索，过滤，排序，实际就是集成了多个mixin，这些mixin只写了一个方法。
ListModelMixin也是一个类，但只有一个方法（获取商品的列表）。
RetrieveModelMixin也只有一个函数，返回商品详情。
所以mixin模式，就是自己写一个mixin类，这个类只有一个方法（干一件事情）。
- mixin功能单一，只提供一个方法
- mixin不和基类关联，GenericViewSet才是真正的基类，mixin可以和任何基类组合，基类不和mixin关联也能初始化
- 在mixin中不要使用super
4.12 python中的with语句
首先介绍下try，except，finally
try:
print ("code started")
raise KeyError
except KeyError as e:
print ("key error")
code started
key error
如果改为IndexError
try:
print ("code started")
raise IndexError
except KeyError as e:
print ("key error")
code started
Traceback (most recent call last):
File "D:/py_tutrial/AdvancePython-master/chapter04/ttt.py", line 4, in <module>
raise IndexError
IndexError
这样就没有捕获到error，如果我们知道错误类型，那可以该except语句里的代码，如果不知道错误类型，那么可以加else语句
try:
print ("code started")
# raise IndexError
except KeyError as e:
print ("key error")
else:
print ("other error")
code started
other error
注意else是在没有抛异常时运行的，有异常且无法捕获时无法运行。
还可以加finally，finally后的语句不管前面有没有错误都会运行
try:
print ("code started")
raise KeyError
except KeyError as e:
print ("key error")
else:
print ("other error")
finally:
print ("finally")
code started
key error
finally
finally 有什么用呢？
try:
f_read = open("bobby.txt")
print ("code started")
raise KeyError as e：
f_read.close()
except KeyError as e：
print ("key error")
f_read.close()
比如打开一个文件，如果没有异常，就要close关闭会话，如果有异常，就不会执行close，那么要在
except里写一个close。如果还有其它异常，都写close就很繁琐。close操作其实可以写在finally中。
try:
f_read = open("bobby.txt")
print ("code started")
raise KeyError as e：
except KeyError as e：
print ("key error")
finally：
f_read.close()
所以finally一般是用来做资源释放的。
解下来讲一下try，finally执行过程：
def exe_try():
try:
print ("code started")
raise KeyError
return 1
except KeyError as e:
print ("key error")
return 2
else:
print ("other error")
return 3
finally:
print ("finally")
return 4
result = exe_try()
print(result)
code started
key error
finally
4
加了return后返回4，正常逻辑是raise一个error，进入except return 2，那为什么最后是return 4？
因为先return 2，那么会把2要让栈里，然后return 4，再把4压入栈，最后结果就是栈顶4。
python的with语句（上下文管理器）就是简化try，except，finally 这种用法。
在魔法函数中讲过python的协议，类只要实现了某些魔法函数，就可以看做某种类型的协议。with上下文管理器协议涉及到了两个魔法函数__enter__，__exit__，上下文管理器协议就可以直接使用with语句。
#上下文管理器协议
class Sample:
def __enter__(self):
print ("enter")
#获取资源
return self
def __exit__(self, exc_type, exc_val, exc_tb):
#释放资源
print ("exit")
def do_something(self):
print ("doing something")
with Sample() as sample:
sample.do_something()
enter
doing something
exit
实际上我们并没有调用enter、exit，with自动调用了这两个魔法函数。调用顺序是enter、do_something、exit，所以可以去enter里获取资源，去exit里释放资源。
4.13 contextlib简化上下文管理器
本来自己实现上下文管理器，要写一个class和对应的魔法函数。
为了简化实现，python内置了contextlib。
import contextlib
@contextlib.contextmanager # 装饰器可以把函数变为上下文管理器
def file_open(file_name):
print ("file open") # 可以看成enter
yield {} # 必须是一个生成器
print ("file end") # 可以看成exit
with file_open("bobby.txt") as f_opened:
print ("file processing")
file open
file processing
file end
