第四章深入理解类和对象

1.鸭子类型和多态

具有相同方法可以做相同任务就是鸭子类型

class Cat(object):
    def say(self):
        print("cat")


class Dog(object):
    def say(self):
        print("dog")


class Duck(object):
    def say(self):
        print("duck")


animal_list = [Cat, Dog, Duck]
for animal in animal_list:
    animal().say()      # cat dog duck，具有多态性

2.抽象基类（abstruct模块）

（1）概念：

• 抽象基类无法实例化
• 规定继承类必须具有抽象基类指定的方法

（2）使用：

• 检查某个类是否有某种方法
• 判定某个对象的类型：使用isintance不建议使用type
• sf

# 检查某个类是否有某种方法
class Company(object):
    def __init__(self, employee_list):
        self.employee = employee_list

    def __len__(self):
        return len(self.employee)


com = Company(["wzh1","wzh2"])
print(hasattr(com, "__len__"))  # True

# 我们在某些情况之下希望判定某个对象的类型
class A:
    pass


class B:
    pass


b = B()
print(isinstance(b, A))  # False
print(isinstance(b, B))  # True

# 如何去模拟一个抽象基类
import abc


class CacheBase(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def get(self, key):
        pass

    @abc.abstractmethod
    def set(self, key, value):
        pass


class RedisCache(CacheBase):
    def get(self, key):
        print("get")

    def set(self, key, value):
        print("set")


redis_cache = RedisCache()
redis_cache.set("name", "wzh")  # set

# 如何去模拟一个抽象基类
class CacheBase(object):
    def get(self, key):
        raise NotImplementedError   # 子类没有重写就报错

    def set(self, key, value):
        raise NotImplementedError   # 子类没有重写就报错


class RedisCache(CacheBase):
    def get(self, key):
        print("get")

    def set(self, key, value):
        print("set")


redis_cache = RedisCache()
redis_cache.set("name", "wzh")  # set

3.使用isintance而不是type

• is 和 == 不要乱用：
  • is：比较两个对象的地址(id)是否相同
  • ==：比较两个变量值是否相同
• type和isinstance区别：
  • type不会追溯到基类去比较，isinstance会追溯到基类比较

class A:
    pass


class B(A):
    pass


b = B()
print(isinstance(b, B))   # True
print(isinstance(b, A))   # True

print(type(b) is B)     # True
print(type(b) is A)     # False

4.类变量和对象变量

• 类变量：类中定义的变量
• 对象变量：又称实例变量，__init__中定义的变量

注意：使用对象名去修改类变量，不会真实修改类中的类变量，只会开辟一个对象变量保存修改的值并且只有这个对象才会是有修改的值，其他创建对象都是类变量原来的值

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.aa变量，但类变量A.aa不会改变
print(a.x, a.y, a.aa)
print(A.aa)

b = A(3, 5)
print(b.aa)

5.类属性和实例属性以及查找顺序

• 属性重名：先找对象实例的属性再找类中的属性
• 查找算法：C3算法

属性重名查找：

class Person:
    name = "Person.name"
    age = 25

    def __init__(self):
        self.name = "self.name"


person = Person()
print(person.name)  # self.name  先找实例属性再找类属性
print(person.age)   # 25        实例属性中没有就用类属性

继承查找：

# 新式类：对于没有写父类的类都会去继承object类
class D:
    pass


class E:
    pass


class C(E):
    pass


class B(D):
    pass


class A(B, C):
    pass


print(A.__mro__)  # C3算法：A->B->D->C->E (DFS：处理非菱形继承)


class W:
    pass


class W1(W):
    pass


class W2(W):
    pass


class W4(W1, W2):
    pass


print(W4.__mro__)  # C3算法：W4->W1->W2->W (BFS:处理菱形继承)

6.静态方法、类方法、对象方法以及参数

• 静态方法：
  • 格式：在方法上面添加 @staticmethod
  • 参数：静态方法可以有参数也可以无参数
  • 应用场景：一般用于和类对象以及实例对象无关的代码。
  • 使用方式： 类名.类方法名(或者对象名.类方法名)。
• 类方法：
  • 在方法上面添加@classmethod
  • 方法的参数为 cls 也可以是其他名称，但是一般默认为cls
  • cls 指向 类对象
  • 应用场景：当一个方法中只涉及到静态属性的时候可以使用类方法(类方法用来修改类属性)。
  • 使用可以是 对象名.类方法名。或者是 类名.类方法名
• 实例方法：又叫对象方法，指类中定义的普通方法

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)


if __name__ == "__main__":
    new_day = Date(2018, 12, 31)
    new_day.tomorrow()
    print(new_day)

    # 2018-12-31
    date_str = "2018-12-31"
    year, month, day = tuple(date_str.split("-"))
    new_day = Date(int(year), int(month), int(day))
    print(new_day)

    # 用staticmethod完成初始化
    new_day = Date.parse_from_string(date_str)
    print(new_day)

    # 用classmethod完成初始化
    new_day = Date.from_string(date_str)
    print(new_day)

    print(Date.valid_str("2018-12-32"))

7.数据封装和私有属性

• 私有属性：以双下划线开头__xxx
• 私有属性也是可以访问的：_classname__attrname即可访问

class User:
    def __init__(self, name):
        self.__name = name  # __birthday为私有属性

    @staticmethod
    def get_age():
        # 返回年龄
        return 25


if __name__ == "__main__":
    user = User("wzh")
    print(user._User__name)     # wzh
    print(user.get_age())       # 25

8.python对象的自省机制

• 概念：自省是通过一定机制查询到对象的内部结构
• 使用：
  • __dict__：显示部分属性和值，不能显示对象的父类属性，但是可以添加属性和显示文档内容
  • dir()：dir比__dict__更强大，获得所有属性但是没有值

class Person:
    """
    人
    """
    name = "user"


class Student(Person):
    def __init__(self, school_name):
        self.school_name = school_name


if __name__ == "__main__":
    user = Student("慕课网")

    # 通过__dict__查询属性
    print(user.__dict__)    # {'school_name': '慕课网'}不能显示父类属性
    user.__dict__["school_addr"] = "北京市"    # 添加属性
    print(user.school_addr)  # 北京市
    print(Person.__dict__)   # 可以显示文档内容
    print(user.name)
    a = [1, 2]
    print(dir(a))

9.super函数

• 目的：主要是把父类继承来的属性赋值
• super执行的顺序：使用C3算法调用

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__()


if __name__ == "__main__":
    print(D.__mro__)  # C3算法：D->B->C->A
    d = D()     # D B C A

10.django rest framework中对多继承使用的经验

使用mixin模式：

• Mixin类功能单一
• 不和基类关联，可以和任意基类组合，基类可以不和mixin关联就能初始化成功
• 在mixin中不要使用super这种用法
• 使用__bases__将需要继承的类组合在一起

def mixin(pyClass, pyMixinClass, key=0):
    if key:
        pyClass.__bases__ = (pyMixinClass,) + pyClass.__bases__
    elif pyMixinClass not in pyClass.__bases__:
        pyClass.__bases__ += (pyMixinClass,)
    else:
        pass


class test1:
    def test(self):
        print('In the test1 class!')


class testMixin:
    def test(self):
        print('In the testMixin class!')


class test2(test1, testMixin):
    def test(self):
        print('In the test2 class!')


class test0(test1):
    pass


if __name__ == '__main__':
    print(test0.__mro__)  # 继承了test1，object
    test_0 = test0()
    test_0.test()  # 调用test1的方法
    mixin(test0, testMixin, 1)  # 优先继承testMixin类
    test__0 = test0()
    test__0.test()  # 由于优先继承了testMixin类，所以调用testMixin类的方法
    print(test0.__mro__)

    print(test2.__mro__)
    mixin(test2, testMixin)     # test2中已经继承了testMixin
    print(test2.__mro__)

(<class '__main__.test0'>, <class '__main__.test1'>, <class 'object'>)
In the test1 class!
In the testMixin class!
(<class '__main__.test0'>, <class '__main__.testMixin'>, <class '__main__.test1'>, <class 'object'>)
(<class '__main__.test2'>, <class '__main__.test1'>, <class '__main__.testMixin'>, <class 'object'>)
(<class '__main__.test2'>, <class '__main__.test1'>, <class '__main__.testMixin'>, <class 'object'>)

11.python中的with语句

• 普通的try...finally语句的调用流程：
  • 如果无异常：try->else->finally
    • finally中有return，则调用finally中的return
    • finally中无return
      • try中有return，则调用try中return
      • try中无return，则调用else中的return
  • 如果有异常：try->except->finally
    • finally中有return，则调用finally中的return
    • finally中无return，则调用except中的return

# try except 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


if __name__ == "__main__":
    result = exe_try()   
    print(result)　　# 4

• 上下文管理器协议：with
  • 两个魔法函数：__enter__、__exit__
    • __enter__：进入时执行，用于获取资源
    • __exit__：结束时执行，用于释放资源

# 上下文管理器协议
class Sample:
    def __enter__(self):
        print("enter")
        # 获取资源
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        # 释放资源
        print("exit")

    @staticmethod
    def do_something():
        print("doing something")


with Sample() as sample:
    sample.do_something()   # enter, doing something, exit

• contextlib简化上下文管理器
  • 将__enter__、__exit__以及中间处理函数都整合到一个函数中
  • yield：中间处理函数
  • 使用装饰器：@contextlib.contextmanager

import contextlib


@contextlib.contextmanager
def file_open(file_name):
    print("file open")
    yield {}
    print("file end")


with file_open("bobby.txt") as f_opened:
    print("file processing")  # file open, file processing, file end