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

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

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