鸭子类型和多态
当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。
例如下面三个类(Cat、Dog、Duck)的定义中都定义了say方法
class Cat:
def say(self):
print("I am a cat！")
class Dog:
def say(self):
print("I am a dog! ")
class Duck:
def say(self):
print("I am a duck! ")
我们就可以如下面的方法，使用这三个类的定义。
animals = [Cat, Dog, Duck]
for Animal in animals:
Animal().say();
复制代码
要在Java、C++那些静态语言中，要实现上述效果，通常要使用如下的多态机制。
class Animal:
def say(self):
print("I am a animal！")
class Cat(Animal):
def say(self):
print("I am a cat！")
a_animal = Cat()
a_animal.say() # 多态
扩展：列表的extend方法传递可迭代的对象即可，它会调用getitem方法
抽象基类 (abc模块)
首先看看如下定义：
class Company:
def init(self, employee_list):
self.employee = employee_list
def len(self):
return len(self.employee)
com = Company(["bobby1", "bobby2"])
抽象基类通常有以下几个优点：
判断类型
我们要判定某个类型是否是“某个鸭子”，通常有如下两种方法。
print(hasattr(com, "len"))
print(isinstance(com, Company)) # 这种方式更好
扩展：abc模块collections.abc，和全局abc
强制某个子类必须实现某些方法
例如要实现了一个web框架， 集成Cache(redis、cache、、)，需要设计一个抽象基类， 指定子类必须实现某些方法
from abc import abstractmethod
class Cache:
@abstractmethod
def get(self, key):
pass
@abstractmethod
def set(self, key, value):
pass
class RedisCache(Cache):
def get(self, key):
pass
def set(self, key, value):
pass
redis = RedisCache()
redis.set("key", "value")
扩展：isinstance和type的区别 首先看看如下定义：
class A:
pass
class B(A): #A、B可以看成是模板对象，全局只有一个
pass
b = B()
print(isinstance(b, A)) #True
python中的is是判断两个对象的地址是否一样，==是判断两个对象的内容是否一样。
print(type(b) is B) #判断地址是否相同 True
print(type(b) == B) #判断值是否相同 True
print(type(b) is A) #False
类变量和实例变量
class A:
aa = 1
def init(self, x, y):
self.x = x
self.y = y
a = A(2, 3)
A.aa = 11
a.aa = 100 # 添加新的属性到a对象上
print(a.x, a.y, a.aa) # 100
print(A.aa) # 11
print(A.x) #抛异常
b = A(4, 6)
print(b.aa)
类和实例属性的查找顺序—mro查找
多继承子类属性的查找问题，如下所述，采用广度和深度搜索都是有问题的。 父类 子类 D---->B---->A E---->C---->A
DFS: A->B->D->C->E BFS: A->B->C->D->E, 如果D和C有重名方法，C会覆盖D
菱形继承 D---->B---->A D---->C---->A
DFS: A->B->D->C, C的方法无法覆盖D的方法 BFS: A-->B->C->D
python采用一种C3的算法查找属性和函数。
class D:
pass
class C(D):
pass
class B(D):
pass
class A(B, C):
pass
print(A.mro) # 获取查询顺序
类方法、静态方法和实例方法
class Date:
#构造函数
def init(self, year, month, day):
self.year = year
self.month = month
self.day = day
def tomorrow(self): #实例方法
self.day += 1
@staticmethod # 不需要cls类型的信息
def vaild_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
@staticmethod
def parse_from_string(date_str): #静态方法
year, month, day = tuple(date_str.split("-"))
return Date(year, month, day)
@classmethod
def parse_from(cls, date_str): #类方法
year, month, day = tuple(date_str.split("-"))
return cls(year, month, day) #cls不用硬编码了
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("-"))
数据封装和私有属性
class User: def init(self, birthday): self.__birthday = birthday
def age(self):
return 2020 - self.__birthday.year
user = User(Date(1990, 2, 1))
print(user.__birthday) #报错，到达私有目的， 子类也没办法获取
print(user._User__birthday) #变形规则 print(user.age())
class Student(User): def init(self, birthday): self.__birthday = birthday
stu = Student(Date(1995, 4, 1))
print(stu._Student__birthday)
python对象的自省机制
自省是通过一定的机制查询到对象的内部结构
class Person: """ 人 """ name = "person"
class Student(Person): def init(self, school): self.school = school
stu = Student("慕课网") print(stu.dict) print(stu.name) # name属于Person类 print(Person.dict)
stu.dict["addr"] = "北京市" print(stu.addr) print(dir(stu)) # 列出对象所有属性
4-10 super真的是调用父类吗？
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().init() b = B() print("-------------------") d = D() #按MRO算法 super调用顺序 from threading import Thread
class MyThread(Thread): def init(self, name, user): self.user = user super().init(name=name) # MRO算法
mixin继承案例
python中的with语句
try except finally
try: print("code started") raise KeyError # raise IndexError except KeyError as e: print("key error") else: print("other error") finally: print("finally...")
上下文管理器（协议）
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()
from contextlib import contextmanager
@contextmanager def openFile(file): print("file open....") yield {} print("file close....")
print("-------------") with openFile("hao.txt"): print("file processing...")