目录

复习

继承：1、父类：在类后()中写父类们class A:passclass B:passclass C(A, B):pass2、属性查找顺序：自己-> ()左侧的父类 -> 依次网友类推3、抽离：先定义子类，有子类的共性抽离出父类   派生：父类已经创建，通过父类再去派生子类    4、继承关系1）父类的所有非封装的属性和方法均能被继承2）父类的所有封装的属性和方法均能被继承3）在父类中要去使用父类的方法    子类继承父类方法：子类不需要去实现父类的方法，子类对象可以直接调用父类方法    --重写父类的方法：方法名与父类相同，但是实现体与父类不同，子类对象调用的自身方法    --重用父类的方法：方法名与父类相同， 实现体中有自己的逻辑也调用的父类的方法(super())        -- super()：在子类中获取可以调用父类方法的对象，且在弗雷中体现调用者子类或子类对象        5、复杂继承：一个类可以继承多个类，查找顺序是根据继承父类从左往右的顺序，并且在查找第一个父类时，将父类的父类也进行查找(一个父类分支全部查找完才去查找下一个父类分支)6、菱形继承    --经典类：py2中类不默认继承object，所以没有明确继承的类就没有继承任何类，称之为经典类    --新式类：所有直接或间接继承object的类，py2中主动继承object的类及py3中所有的类        --前提：父类中有共有属性或方法，子类中没有自己定义这些属性和方法，必须从父类中获取        --查找顺序：        --经典类：深度查找        --新式类：广度优先

面向对象与面向过程分析

# 清晰知道操作的功能，但不明确操作的对象print(len('123'))# 清晰知道操作的对象，但不明确具体的操作方法print('123'.__len__())

接口思想

# 建立关联的桥梁，方便管理代码# python中没有接口语法    接口类：用来定义功能的类，为继承它的子类提供功能，该类功能的方法一般不需要有实现体，实现体由继承它的子类自己去实现(就是在子类中建立一个新的同名功能方法，实现方法的代码就写在子类中的这个方法中)# 提供所有宠物应该有的功能class PetInterface:    def close_master(self): pass# 提供所有看门应该有的功能class WatchInterface:    def watch_door(self): pass# 没有去继承PetInterface，WatchInterface的Dog就是普通的Dog类# 但继承了PetInterface，该Dog就可以作为宠物狗，同理继承WatchInterface就可以作为看门狗class Dog(PetInterface, WatchInterface):    def jiao(self): pass    def chi(self): pass    def pao(self): pass        # 一定要重写接口的方法    pass# 这个类的产生的对象可以作为宠物及看门猫 class Cat(PetInterface, WatchInterface):    pass

抽象父类

抽象父类：拥有抽象方法(子类共有的方法，但是父类不能由具体的实现体)的父类抽象方法：方法名是具体的，但是实现体是抽象的(在子类中重写实现体来具象化抽象方法)有抽象方法的父类不能被实例化(假设能被实例化，能够可以调用自己的抽象方法，但是抽象方法没有实现体，因此也就没有任何意义)实现抽象父类的语法：import abc  # abstract base clasclass Sup(mataclass = abc.ABCMeta):    # 抽象父类中的抽象方法，在继承它的子类中必须有自己的实现体    # -- 抽象父类中的抽象方法实现体没有意义，实现与不实现都是pass填充    @abc.abstractmathod    def func(self):pass        class Sub(Sup):    # 必须重写父类的抽象方法    def func(self):        实现体的代码        # ==案例==import abcclass Quan(metaclass=abc.ABCMeta):    def __init__(self, name):        self.name = name            # 共有方法：子类继承就可以了    def run(self):        print(self.name + 'runing')    @abc.abstractmethod  # 子类必须有此方法    def chi(self):        pass        @abc.abstractmethod  # 子类必须有此方法    def jiao(self):        passclass Dog(Quan):    def kanmen(self):        print(self.name + '看门')            def chi(self):  # 父类中的抽象属性对应，否则会报错        print(self.name + '狗粮')            def jiao(self):        print(self.name + '汪汪汪')                class Wolf(Quan):    def bulie(self):        print(self.name + '捕猎')            def chi(self):        print(self.name + '肉')            def jiao(self):        print(self.name + '嗷嗷嗷')        dog = Dog('来福')wolf = Wolf('哈利')dog.jiao()wolf.jiao()dog.run()wolf.run()run==>来福汪汪汪哈利嗷嗷嗷来福runing哈利runing了了解知识点：# 抽象的类方法import abcclass Sup(mataclass=abc.ABCMeta):    @classmethod    @abc.abstractmethod    def func(cls):pass    class Sub(Sup):    @classmathod    def func(self):        # 必须重写父类的抽象方法        方法的实现体

多态

多态：对象的多种状态 - 父类对象的多种(子类对象)状态import abcclass 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(self):        print('说英国话')if __name__ == '__main__':    # 多态的体现：功能或是需求，需要父类的对象，可以传入父类对象或任意子类对象    # 注意：一般都是规定需要父类对象，传入子类对象        def ask_someone(obj):        print(obj.name + '上台演讲')        obj.speak()  # 父类提供，只不过子类重写了            ch = Chinese('王大锤')    en = England('Harry')        # 传入Chinese | England 均可以，因为都是People的一种状态(体现方式)    ask_someone(ch)    ask_someone(en)    run==>    王大锤上台演讲    说中国话    Harry上台演讲    说英国话        # 传入str不可以，因为str的对象没有name和speak    # s = str('白骨精')    # ask_someone(s)    # p = People('Kkk')

鸭子类型

需求：需要一个对象，该对象有name属性及speak方法，就可以作为一种状态的体现被传入def ask_someone(obj):    print(obj.name + '上台演讲')    obj.speak()    # 鸭子类型：# 1、先规定：有什么属性及什么方法的 类 的类型 叫鸭子类型# 2、这些类实例化出的对象，都称之为鸭子，都可以作为需求对象的一种具体体现class A:    def __init__(self, name):        self.name = name    def speak(self):        print('say AAA')            # 能有自己特有的属性和方法，可以和B完全不一样，但是必须有鸭子类型规定的属性和方法，不然就不是鸭子类型    def eat(self):        print('AAA eatting')class B:    def __init__(self, name):        self.name = name    def speak(self):        print('say BBB')            # 能有自己特有的属性和方法，可以和A完全不一样，但是必须有鸭子类型规定的属性和方法，不然就不是鸭子类型    def run(self):        print('BBB running')# 使用鸭子类型的对象去调用 需求方法b = B('b')ask_someone(b)run==>b上台演讲say BBB

格式化方法与析构方法

class A:    def __init__(self, name, age):        self.name = name        self.age = age            # 格式化方法：在外界该对象时被调用    # 格式化外界直接打印该类对象的字符串表示结果    def __str__(self):        # return 'abc'  # 外界打印A类的对象，都打印 字符串 abc        # return super().__str__()  # 系统默认的在父类中返回的是对象存放的地址信息        return '
    
     ' % (self.name, self.age)        # 根据对象实际的属性格式化具体的输出内容            # 构析方法：在对象被销毁的那一刹那被调用，在被销毁前可以做一些事情    def __del__(self):        # del 会在self代表的对象被销毁的时候调用        # 我们可以在析构函数中释放该对象持有的其他资源        # 或者将一些持有资源持久化(将数据保存到文件或数据库中)        def self.name  # 也可以将name存起来
    

了解

class B:    # 了解：对象.语法的内部实现    def __setattr__(self, key, value):        self.__dict__[key] = value  # 系统默认实现，在名称空间添加名字        # self.__dict__[key] = value.lower()  # 可以自定义处理一些内容    # 了了解：将对象添加属性的方式可以同字典形式    def __setitem__(self, key, value):        self.__dict__[key] = value        b = B()# 设置b.name = 'BBB'  # 内部走的是 __setattr__b['age'] = 18  # 内部走的是 __setitem__# 访问print(b.name)print(b.age)run==>BBB18

反射

反射：通过字符串 与 类及类的对象 的属性(方法)建立关联# 类的属性类来操作class A:    num = 10print(hasattr(A, 'num'))  # 查看类A中是否有'num'属性print(getattr(A, 'num', '默认值'))  # 获取类A中的'num'属性，没有此属性时则返回指定默认值delattr(A, 'num')  # 删除类A中的'num'属性print(getattr(A, 'num', '类A中没有num属性'))  # 获取类A中的'num'属性，没有此属性时则返回指定默认值setattr(A, 'tag', 10)  # 在类A中增加属性 'tag'，赋值为10print(getattr(A, 'tag'))  # 获取类A中的'tag'属性run==>True10类A中没有num属性10# 对象的属性对象来操作class B:    def __init__(self, name):        self.name = nameb = B('BBB')print(hasattr(b, 'name'))  # 查看对象b中是否有'name'属性print(getattr(B, 'name', '对象的属性类不能获取'))  # 获取类B中的'name'属性，没有此属性时则返回指定默认值delattr(b, 'name')print(getattr(b, 'name', '对象b中没有name属性'))setattr(b, 'age', 18)  # 在对象b中增加属性 'age'，赋值为18print(getattr(b, 'age'))  # 获取对象b中的'age'属性run==>True对象的属性类不能获取对象b中没有name属性18class C:    def fn(self):        print('fn')            @classmethod    def func(self):        print('func')                fn = getattr(C, 'fn')c = C()fn(c)  # 类方法获取对象方法调用时，传入具体的对象obj_fn = getattr(c, 'fn')obj_fn()  # 对象方法获取对象方法调用时不用传参func = getattr(C, 'func')func()  # 类获取类方法调用时不需要传入参数

异常处理：程序运行时的错误

程序中的异常处理机制：1、程序中的所有异常都会被处理2、程序中的所有异常都需要手动处理3、如果没有手动处理异常，异常会交给python解释器处理    --处理的方式就是打印异常信息，并停止接收器    异常信息的三部分：1、异常的追踪信息：提示错误位置2、异常的类型：告之处理异常应该捕获什么类型3、异常的内容：告之错误信息 *****# 处理异常的语法try:    # 会出现异常的代码块except 异常类型 as 异常别名：    # 异常处理逻辑else:    # 没有出现异常会执行该分支finally:    # 无论是否出现异常都会执行该分支# 输入错误try:    print(adsdasadsdasadsdas)except NameRrror as e:    print('异常信息：', e)else:    print('被检测的代码块正常')finally:    print('异常是否出现都会执行该分支')run==>异常信息： name 'adsdasadsdasadsdas' is not defined异常是否出现都会执行该分支# 输入正确try:    print('adsdasadsdasadsdas')except NameRrror as e:    print('异常信息：', e)else:    print('被检测的代码块正常')finally:    print('异常是否出现都会执行该分支')run==>adsdasadsdasadsdas被检测的代码块正常异常是否出现都会执行该分支

异常语法

# 将可能出现异常的代码放在try分支进行检测#       -- 如果不出现异常，正常执行内部所有代码#       -- 如果出现异常会进入except分支# part1# 1.建议大家对异常处理时，一次只处理一个异常try:    print(asdsdsdsdsdsdsdsdsdsdsdsdsd)  # NameErrorexcept NameError:  # except 后跟异常类型，如果不需要查看异常信息，可以省略异常信息    print('出现了NameError异常')try:    ls = [1, 2, 3, 4, 5]    print(ls[10])  # IndexErrorexcept IndexError as e:  # 如果想知道异常信息，用别名接收    print('出现了IndexError异常: %s' % e)# part2# 2.如果无法避免一句话或是一个完整的代码结构会出现多个可能的异常，需要在一个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)  # AttributeErrorexcept (AttributeError, IndexError) as e:    print('出现了异常: %s' % e)print('===============================')# part3# 3.有些异常提前无法明确，或是压根没有明确的必要，可以捕获异常的父类异常ls = [1, 2, 3, 4, 5]# ls = (1, 2, 3, 4, 5, 6)try:    print(ls[5])  # IndexError    ls.append(10)  # AttributeErrorexcept Exception as e:  # 可以通过多态的应用，捕获父类，只要抛出的是该父类的子类异常，均可以被捕获    print('出现了异常: %s' % e)# BaseException：所有异常的基类  |  Exception：常规错误的基类# part4# 4.了了解 - try语法的else分支：当try检测的代码块没有出现异常，才会走else分支try:    print(aaaa)except Exception as e:    print('出现了异常', e)else:    print('没有异常')# part5# 5.finally：无论是否出现异常都会执行该分支try:    f = open('1.txt', 'w', encoding='utf-8')    f.write(b'123')except Exception as e:    print('出现了异常', e)finally:    print('无论是否出现异常都会执行该分支')    f.close()  # 文件只要打开，不管操作是否出现异常，都需要释放文件资源

自定义异常

# 自定义异常的目的：想抛一个有意义的异常，但这个异常系统没有提供，我们可以自定义一个class PeopleNameError(Exception):  # Exception | BaseException    # pass    # 可用通过__init__明确外界的错误信息接受给那个属性    # 再在__str__中格式化外界不花异常，打印异常信息的格式    def __init__(self, msg):        self.msg = msg    def __str__(self):        return 'PeopleNameError:' + sele.msg    def get_name():    name = input('name:')    if 'sb' in name.lower():        raise PeopleNameError('人名不能有敏感词汇')    return nametry:    print(get_name())except PeopleNameError as e:    print(e)  # PeopleNameError：人名不能有敏感词汇

断言

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