DAY24、面向对象

一、复习
继承
1、父类：在类后（）中写父类们
2、属性查找顺序：自己->（）左侧的父类->依次往右类推
3、抽离：先定义子类，由子类的共性抽离出父类
   派生：父类已经创建，通过父类再去派生子类
4、继承关系：
    父类的所有非封装的属性和方法均能被继承
    父类的所有封装的属性和方法不能被继承
    在子类中要去使用父类的方法
        子类继承父类方法：子类不需要去实现父类的方法，子类对象调用的是自身方法
        重写父类的方法：方法名与父类相同，实现体不同，子类调用的是自身方法
        重用父类的方法：方法名与父类相同，实现体中又自己的逻辑也调用了父类的方法（super()）
            super()：在子类中获取可以调用父类方法的对象，且在父类中体现的调用者子类或子类对象
5、复杂继承：一个类可以继承多个类，查找顺序是根据继承父类从坐到右的顺序，并且在查找第一个父类时
             将父类的父类也进行查找（一个父类分支全部查找完毕才去查找下一个父类分支）
6、菱形继承：
    经典类：py2中类不默认继承object，所以没有明确继承的类就没有继承任何类，这样的类称之为经典类
    新式类：所有直接或间接继承object的类，py2中主动继承object的类及py3中所有的类
    前提：父类中有共有属性或方法，子类没有自己去定义这些属性或方法，必须从父类中获取
    获取顺序：经典类是深度查找，即一条分支查到底（查到最后继承的那个父类）
              新式类是广度优先，即先查分招，最后再查底
二、接口思想
1、接口：建立关联的桥梁，方便管理代码
2、接口类：用来定义功能的类，为继承它的子类提供功能的，该类的功能方法一般不需要有实现体，实现体有继承它的子类去实现
3、例：
    class PetInterface:                  #提供所有宠物应该有的功能
        def close_master(self):pass

    class WatchInterface:
        def watch_door(self):pass        #提供所有看门应该有的功能

三、抽象父类
1、抽象父类：拥有抽象方法（子类共有的方法，但是父类不能有具体的实现体）的父类
2、抽象方法：方法名是具体的，但是实现体是抽象的（在子类中重写来具象化）
3、注意点：有抽象方法的父类不能被实例化（假设能被实例化，就可以调用自己的抽象方法，没有任何意义）
4、实现抽象父类的语法：
    import abs
    class Sup(metaclass=abc.ABCMeta):
        @abc.abstractmethod
        def func(self):pass

    class Sub(Sup):
        def func(self):
            #必须重写父类的抽象方法(super())
5、案例
    import abc
    class Quan(metaclass=abc.ABCMeta):
        def __init__(self,name):
            self.name = name

        def run(self):                        #共有方法子类继承就可以了
            print(self.name+'running')

        @abc.abstractmethod                   #抽象方法：子类必须重写
        def eat(self):pass

        @abc.abstractmethod
        def bite(self):pass

    class Dog(Quan):
        def watch_door(self):
            print(self.name+'看门')

        def eat(self):
            super().eat()
            print(self.name+'狗粮')

        def bite(self):
            print('汪汪汪')

    class Wolf(Quan):
        def hunting(self):
            print(self.name+'捕猎')

        def eat(self):
            print(self.name+'肉')

        def bite(self):
            print('嗷嗷嗷')

    dog = Dog('来福')
    wolf = Wolf('狼')
四、多态：
1、多态：对象的多种状态、父类对象的多种（子类对象）状态
    import abc
    class People(metaclass=abc.ABCMeta):
        def __init__(self,name):
            self.name = name

        @abc.abstractmethod
        def speak(self):pass

    class Chinese(People):
        def speak(self):
            print('说中国话')

    class England(People):
        def speak('说英国话')

    if __name__=='__main__':
        def ask_someone(obj):
            print('让%s上台演讲'%obj.name)            #父类提供，子类直接继承
            obj.speak()                               #父类提供，只不过子类重写

        ch = Chinese('王大锤')
        en = England('Tom')

        ask_someone(ch)                               #传入Chinese|England都可以，都
        ask_someone(en)                                 是People的一种状态
2、多态的体现：
    功能或需求，需要父类的对象，可以传入父类对象或任意子类对象
    注：一般都是规定需要父类对象，传入子类对象
五、鸭子类型
1、先规定：有什么属性及什么方法的类的类型叫鸭子类型
2、这些实例化出的对象，都称之为鸭子，都可以作为需求对象的一种具体体现
3、类中能有自己特有的属性和方法，但是必须有鸭子类型规定的属性和方法，不然就不是鸭子类型
六、格式化方法与析构方法
1、格式化方法：在外界打印该类对象时被调用
    格式化外界直接打印该类对象的字符串表示结果
class A:
    def __str__(self):
        return 'abc'                #外界打印A类对象，都打印字符串'abc'
        return super().__str__()    #系统默认的在父类中返回的是对象存放的地址信息
        return '<name:%s |age:%s>'%(self.name,self.age)    #根据对象实际属性格式化输出内容
2、析构方法：在对象被消耗的那一刹那被调用，在被消耗前可以做一些事情
    def __del__(self):
        del self.name
    del 会在self代表的对象被消耗的时候被调用
    我们可以在析构函数中释放该对象持有的其他资源
    或者将一些持有资源持久化（保存到文件或数据库中）
七、反射
1、反射：通过字符串与类及类的对象的属性（方法）建立关联
    类的属性来操作
    class A:
        num = 10

    print(hasattr(A,'num'))    #判断A类中num是否存在
    res = getattr(A,'num','默认值')    #A类中有num就返回num的值，没有就返回默认值
    delattr(A,'num')                   #删除A类中的num
    print(setattr(A,'tag',10))         #给A类中加值，即tag=10

    对象的属性来操作
    class B:
        def __init__(self,name):
            self.name = name
    b = B('bbb')
    print(hasattr(b,'name'))               #判断对象b的属性中是否有name
    print(getattr(b,'name','对象的属性类不能获取'))  #获取对象name的值，没有就返回默认值
    delattr(b,'name')                                #删除
    print(setatter(b,'age',18))                       #给对象加值

    class C:
        def fn(self):
            print('fn')

        @classmethod
        def func(cls):
            print('func')

    fn = getattr(C,'fn')
    c = C()
    fn(c)                     #类获取对象方法调用时传入具体的对象

    obj_fn = getattr(c,'fn')
    obj_fn()                  #对象获取对象方法调用时不用传参

    func = getattr(C,'func')
    func()                    #类获取类方法时不需要传入参数
总结：类的属性用类来操作
      对象的属性对象来操作
      方法建议使用类来操作，得到的方法调用时
            对象的方法要传入具体的对象
            类的方法不需要传入参数
八、异常处理
1、程序中的异常处理机制：
    程序中的所有异常都会被处理
    程序中的所有异常都需要手动处理
    如果没有手动处理异常，异常会交给Python解释器处理
        处理的方式就是打印异常信息，并停止解释器
2、异常信息的三部分
    异常的追踪信息：提示错误位置
    异常的类型：告知处理异常应该捕获什么类型
    异常的内容：告知错误信息
3、处理异常的语法:
    try:
        #会出现异常的代码块
    except 异常类型 as 异常别名：
        #异常处理逻辑
    else:
        #没有出现异常会执行该分支
    finally:
        #无论是否出现异常都会执行该分支

4、异常语法
    part1:建议大家对异常处理时，一次只处理一个异常
    try:
        print(asdsdsdsdsdsdsdsdsdsdsdsdsd)  # NameError
    except NameError:  # except 后跟异常类型，如果不需要查看异常信息，可以省略异常信息
        print('出现了NameError异常')

    try:
        ls = [1, 2, 3, 4, 5]
        print(ls[10])  # IndexError
    except IndexError as e:  # 如果想知道异常信息，用别名接收
        print('出现了IndexError异常: %s' % e)

    part2:如果无法避免一句话或是一个完整的代码结构会出现多个可能的异常，需要在一个try中提供多个except
    ls = [1, 2, 3, 4, 5]
    ls = (1, 2, 3, 4, 5, 6)
    try:
        print(ls[5])  # IndexError
        ls.append(10)  # AttributeError
    except IndexError as e:
        print('出现了IndexError异常: %s' % e)
    except AttributeError as e:
        print('出现了AttributeError异常: %s' % e)
    try:
        print(ls[5])  # IndexError
        ls.append(10)  # AttributeError
    except (AttributeError, IndexError) as e:
        print('出现了异常: %s' % e)

    part3:有些异常提前无法明确，或是压根没有明确的必要，可以捕获异常的父类异常
    ls = [1, 2, 3, 4, 5]
    ls = (1, 2, 3, 4, 5, 6)
    try:
        print(ls[5])  # IndexError
        ls.append(10)  # AttributeError
    except Exception as e:  # 可以通过多态的应用，捕获父类，只要抛出的是该父类的子类异常，均可以被捕获
        print('出现了异常: %s' % e)

    # BaseException：所有异常的基类  |  Exception：常规错误的基类

    part4:try语法的else分支：当try检测的代码块没有出现异常，才会走else分支
    try:
        print(aaaa)
    except Exception as e:
        print('出现了异常', e)
    else:
        print('没有异常')

    part5:finally：无论是否出现异常都会执行该分支
    try:
        f = open('1.txt', 'w', encoding='utf-8')
        f.write(b'123')
    except Exception as e:
        print('出现了异常', e)
    finally:
        print('无论是否出现异常都会执行该分支')
        f.close()  # 文件只要打开，不管操作是否出现异常，都需要释放文件资源

5、自定义异常
    # 自定义异常的目的：想抛一个有意义的异常，但这个异常系统没有提供，自定义一个
class PeopleNameError(Exception):  # Exception | BaseException
    # pass
    # 可以通过__init__明确外界的错误信息接收给那个属性
    # 再在__str__中格式化外界捕获异常，打印异常信息的格式
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return 'PeopleNameError: ' + self.msg

def get_name():
    name = input('name: ')
    if 'sb' in name.lower():
        raise PeopleNameError('人名不能有敏感词汇')
    return name

try:
    print(get_name())
except PeopleNameError as e:
    print(e)  # PeopleNameError: 人名不能有敏感词汇

6、断言
num = int(input('num: '))
assert num < 0  # 断言：只有满足断言条件，程序才能往下执行，反之抛出异常
print(abs(num))