学习使我快乐

鸭子类型和多态

当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。

例如下面三个类(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...")

写给编程高手的Python教程(11) 深入类和对象