"""
鸭子类型：
    在多个类中实现同一个方法，那么这些类可以看成同一个类型
"""

class Cat:
    def say(self):
        print('这是猫')
        
class Dog:
    def say(self):
        print('这是狗')       
        
class Duck:
    def say(self):
        print('这是鸭子')
        

animal_list = [Cat, Dog, Duck]
for animal in animal_list:
    animal().say()               # 多个类实现了同一个方法，那么就可以归为一类
    

# 作用1：判断对象中是否实现了计算长度的方法
from collections.abc import Sized
class Student:
    def __init__(self, student_list):
        self.student_list = student_list
    def __len__(self, item):
        return self.student_list[item]

stu = Student(['小明','小红'])
print(hasattr(stu, '__len__'))
print(isinstance(stu, Sized))

# 作用2：强制子类实现get_cache和set_cache方法
from abc import ABC, abstractmethod
class Cache(ABC):
    @abstractmethod
    def get_cache(self):
        pass
    @abstractmethod
    def set_cache(self, value):
        pass
    
class TulingOnline(Cache):
    def __init__(self):
        self.cache = ''
    
    def get_cache(self):
        return self.cache
    
    def set_cache(self,value):
        self.cache = value
        return True
    
tuling = TulingOnline()
tuling.set_cache(67)
tuling.get_cache()

class A:
    pass

class B(A):
    pass
b = B()

# 判断传入的对象是否是指定的类型
# 判断的对象也参考类的继承关系
print(isinstance(b, B))
print(isinstance(b, A))

# == 是判断两个值是否相等
print(type(b) == B)
print(type(b) == A)

# is判断的是内存地址
print(type(b) is B)
print(type(b) is A)

"""
总结：在判断对象的类型时尽量优先使用isinstance
"""

class A:
    # 类属性
    a = 1
    def __init__(self, b, c):
        # 实例属性
        self.b = b
        self.c = c
        
obj_a = A(2, 3)
# 实例对象可以访问类属性和实例属性
print(obj_a.a, obj_a.b, obj_a.c)

# 类对象也可以访问类属性
print(A.a)

# 类对象无法访问实例属性
# print(A.b, A.c)

# 对类属性的值进行修改
A.a = 11
print(A.a)
print(obj_a.a)

# 实例对象修改类属性
obj_a.a = 22
print(A.a)              # 实例属性无法修改类属性
print(obj_a.a)          # 当前代码是通过示例对象新建了一个实例属性

class A:
    name = "cls_a"
    def __init__(self):
        self.name = 'obj_a'

# 类中的属性查找，优先查找实例属性，如果找不到向上查找类属性
a = A()
print(a.name)
print(A.name)

# 菱形继承
class D:
    name = "cls_d"
    
class B(D):
    name = "cls_b"
#     pass
    
class C(D):
    name = "cls_c"

class A(B, C):
    pass

a = A()
print(a.name)
print(A.__mro__)    # 类A的继承关系链:A→B→C→D→Object

# 树状继承
class E:
    name = "cls_e"

class D:
    name = "cls_d"
    
class B(D):
    name = "cls_b"
#     pass
    
class C(E):
    name = "cls_c"

class A(B, C):
    pass

a = A()
print(a.name)
print(A.__mro__) # 查找顺序：A→B→D→C→E→Object

class Student:
    address = '长沙'
    
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
    
    def __str__(self):
        return f'{self.name}, {self.age}, {self.gender}'
    
    def set_info(self):
        self.age += 1
        print(self.address)
        
    @staticmethod
    def parse_from_string(stu_info):
        name, age, gender = tuple(stu_info.split(','))
        return Student(name, age, gender)
    
    @classmethod
    def parse_from_string_ex(cls, stu_info):
        name, age, gender = tuple(stu_info.split(','))
        return cls(name, age, gender)
    
    
stu_1 = Student('小明', 18, '男')
print(stu_1)
stu_1.age = 20
print(stu_1)
# 实例方法
stu_1.set_info()
print(stu_1)

# 静态方法
stu_2 = Student.parse_from_string('小红,18,女')
print(stu_2)

# 类方法
stu_3 = Student.parse_from_string_ex('大熊,40,男')
print(stu_3)


# 实例方法：
#    方法中的第一个参数是self，实例方法可以访问类中的所有属性和方法
#    
# 静态方法@staticmethod：
#    场景：在文件中保存了一些学生的信息，需要将文件中的信息导入到类中进行处理。
#    格式：'学生姓名，年龄，性别'
#    
# 类方法@classmethod：
#    可以被类对象和实例对象调用，类方法可以访问类属性
#    
# 1、如果当前的需求不需要创建实例对象，并且不需要访问实例属性/类属性，可以使用静态方法
# 2、如果当前的需求不需要创建实例对象，但是需要访问类属性，可以优先使用类方法
# 3、如果当前的需求需要实例对象，并且需要访问类中的所有属性和方法，则使用实例方法

class Person:
    def __init__(self, name, money):
        self.name = name
        self.__money = money
        
    def get_money(self):
        print(self.__money)
    
p = Person('小明', 10000)
# print(p.name, p.__money)  # 直接通过实例对象是无法访问的
p.get_money()

class Person:
    name = 'user'

class Student(Person):
    def __init__(self, school_name):
        self.school_name = school_name
        
stu = Student('兰州大学')

# 查询这个对象中包含的属性
print(stu.__dict__)
print(Person.__dict__)

stu.__dict__['address'] = '长沙' 
print(stu.__dict__)

# dir函数可以查询一个对象中的所有属性和方法，包含这个对象的父类
print(dir(stu))

class A:
    def __init__(self):
        print('A')

class B(A):
    def __init__(self):
        print('B')
        # 如果想在B的init函数中也调用父类A的init函数，有两种方法：
        
        # 方法1：
        # A.__init__(self)
        
        # 方法2：
        super().__init__()

b = B()

class D:
    def __init__(self):
        print('d')
        
class C(D):
    def __init__(self):
        print('c')
        super().__init__()
        
class B(D):
    def __init__(self):
        print('b')
        super().__init__()

class A(B, C):
    def __init__(self):
        print('a')
        super().__init__()
        
a = A()
# super()本质上是按照__mro__顺序调用方法

class Animal:
    def __init__(self, name):
        self.name = name

class RunMixin:
    def run(self):
        print(f'{self.name} 正在跑...')
        
class SwimMixin:
    def swim(self):
        print(f'{self.name} 正在游泳...')

class FlyMixin:
    def fly(self):
        print(f'{self.name} 正在飞...')
        
class Duck(Animal, RunMixin, SwimMixin, FlyMixin):
    pass

duck = Duck('鸭子')
duck.run()
duck.swim()
duck.fly()
# 当前的继承方式是一种混合继承
#  1、mixin功能是单一的
#  2、mixin类不继承其他的类(除了object)
# 使用注意事项：
#  1、mixin因为功能简单，并且没有复杂的继承关系，特别好管理
#  2、在使用mixin的时，应该尽量避免在子类中使用super

# try语句的基本使用
try:
    print('程序运行....')
    raise KeyError
except KeyError:
    print('key error 错误...')
else:
    print('程序未产生异常时则运行当前代码...')
finally:
    print('程序无论是否出现异常都执行此语句...')
    
    
# 在函数中使用try语句
def func_try_except():
    try:
        print('程序运行....')
        # raise KeyError
        return 1
    except KeyError:
        print('key error 错误...')
        return 2
    else:
        print('程序未产生异常时则运行当前代码...')
        return 3
    finally:
        print('程序无论是否出现异常都执行此语句...')
        # 如果finally中出现return，则优先返回finally中的返回值
        return 4

res = func_try_except()
print(res)

# 上下文管理协议
# 1、通过上下文管理协议实现try-except会相对简单，
# 2、使用上下文管理协议时，需要实现对应的魔术方法

class Sample:
    def __enter__(self):
        try:
            self.file_obj = open('test.txt')
            
        except FileNotFoundError:
            self.file_obj = None
            
        print('我被执行了:__enter__')
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('我被执行了:__exit__')
        if self.file_obj is None:
            print('当前文件不存在')
        else:
            self.file_obj.close()
        
    def run(self):
        print('程序启动...')

# 以下使用With之后，相比try..except..else..finally的写法要简单很多
with Sample() as sample:
    sample.run()

import contextlib

# 增加以下装饰器，则函数就支持上下文管理协议
@contextlib.contextmanager
def open_file(file_name):
    print(f'open: {file_name}')
    # __enter__必须在yield的上面
    
    # 被contextmanger装饰的函数必须是一个生成器函数
    yield {'name': '小明', 'age': 30}
    
    # __exit__必须在yield的下面
    print(f'close:{file_name}')
    
with open_file('测试.txt') as f_open:
    print('程序启动...')