面向对象多继承 异常处理

总结
1 多继承
2封装,多态  :比如定义一个变量  a=  这里a可以赋值多种类型比如字典列表,字符串等  Python 本身就是默认多态的
3 super()方法
4 类的约束
5 异常处理

多继承的顺序 和 super()方法

‘‘‘
class A:
    def func1(self):
        # super().func()
        print(self,‘A‘)
class B():
    def func(self):
        super().func()

        print(self,‘这是B‘)
class C():
    def func(self):
        # super().func()
        print(self,‘这是C‘)
class D(B,C):   #当你执行这个func方法时 先走B,B走完后,如果B里边没有super 就不会跳到下一步去在找C,
    def func(self):
        super().func()
        #super这个位置括号里边其实是super(B,self)
        # 第一个参数是类,第二个是参数self 那个对象调用的就是那个对象的内存地址,
        #若不是B,改为C的话直接跳到C这个位置,就不走B了
        print(self,‘这是D‘)
python中类的分类:
python2x版本:
    python2.2之前,只有经典类,python2.2之后出现了新式类.
    经典类: 不继承object类. 多继承遵循深度优先.
        class A:
            pass
    新式类: 继承object的类. 多继承遵循c3算法,mro方法.
        class A(object):
            pass

python3x版本: 所有类都默认继承object.
    只有新式类.

‘‘‘
深度优先: 从左至右,一条路走到底.

新式类的多继承: C3算法.
‘‘‘
class O:
    pass

class D(O):
    pass

class E(O):
    pass

class F(O):
    pass

class B(D,E):
    pass

class C(E,F):
    pass

class A(B,C):
    pass

obj = A()
print(A.mro())

mro(C(A,B)) = [C] + merge(mro(A),mro(B),[A,B])
mro(B(A)) = [B,A]
mro(B(A1,A2,A3)) = [B] + merge(mro(A1),mro(A2),mro(A3),[A1,A2,A3])
[A,B,C] 表头:A 表尾: B,C
[A] 表头: A ,表尾: 空.
[A] + [B] = [A,B]
# 如果计算merge里面的顺序:
merge([A,O], [C,E,F,O],[C])
# [A] + merge([O], [C,E,F,O],[C])
# [A,C] + merge([O], [E,F,O])

A.mro(B,C)=[A] + merge(mro(B),mro(C),[B,C])
A.mro(B,C)=[A] + merge([B,D,E,O],[C,E,F,O],[B,C])
[A,B,D,C,E,F,O]
mro(B)=B.mro(D,E)=[B] + merge(mro(D),mro(E),[D,E])
mro(D)=[D,O]
mro(E)=[E,O]
mro(B)=B.mro(D,E)=[B] + merge([D,O],[E,O],[D,E])  --[B,D,E,O]

mro(C)=C.mro(E,F)=[C] + merge(mro(E),mro(F),[E,F])
mro(E)=[E,O]
mro(F)=[F,O]
mro(C)=C.mro(E,F)=[C] + merge([E,O],[F,O],[E,F])--[C,E,F,O]
‘‘‘

4类的约束  强制我的子类必须有某种方法  .主动抛异常 rice 一下

方法一 主动抛异常 rice 一下 :归一化设计,在鸭式基础上去 添加.一个接口.把不同的类,相同方法 作为一个函数放调用
方法二 抽象类 接口类 : 制定一个规范,强制子类必须有pay方法,如果没有,在你实例化的时候就会报错.
 ‘第一种方式 :Python最常用的方式.
   列:
   class Payment:
       def pay(self,money):
           raise Exception (‘错误提示语句‘)
    class Alipay(Payment):
        def pay(self,money):
            print(‘你使用阿里支付了%s‘%money)
    class Wecahat(Payment):
        def pay(self,money):
            print(‘您使用了微信支付了%s‘%money)
    class QQpay(Payment):
        def pay(self,money):
            print(‘您使用了QQ支付了%s‘%money)
    def pay(obj,money):#统一了支付方式.归一化设计
        obj.pay(money)

方式 二:
from abc import ABCMeta,abstractclassmethod    #没有这个方法时子类是不可以生成对象的
class Payment(metaclass=ABCMeta):
        @abstractclassmethod
        def pay(self,money):
                pass
class Alipay(Payment):
    def pay(self,money):
        print(‘您是使用了啊里支付了%s‘%money)

    class Wechatpay(Payment):
        def pay(self, money):
            print(‘您用微信支付了%s元‘ % money)

    class Applepay(Payment):
        def pay(self, money):
            print(‘您用苹果支付了%s元‘ % money)

    def pay(obj, money):  # 统一了支付方式:归一化设计
        obj.pay(money)  # obj2.pay(200)

    #
# 5 异常处理
# 异常错误分类
    1.语法异常
        输入的代码错误
        直接飘红

    2.逻辑错误
        不会直接飘红
        但是,逻辑是错误的
        比如查索引的时候超过下标
        代码执行了后 才会出现的错误

如何处理这些逻辑错误.
异常错误信息
错误类型,
一,异常处理
    1.先捕捉
    2.在进行处理
二,异常处理的俩种方式
    if  预防
    用if处理异常劣势:
    1,对于相同的错误类型,你要用大量的重复代码处理异常.
    2,如果异常种类较多,利用if 你得代码会出现冗余(无用代码过多).

    try : except 异常处理,  代码异常报错,但是可以执行 expcet 下的代码

    1,
    单支
    try:   一个try
        pass
    except IndexError(错误类型 不定)  一个错误类型
    2.
    多支
    try:
        pass
        pass
     except IndexError as e:  可以接收对应的报错
        print(e)  可以打印,可不打印
    except KeyError as e:   可以接收对应的报错
        print(e)
    except ValueError as e:  可以接收对应的报错
        print(e)

    3.
    万能异常
    try  except   Exception

    try:
        pass
        pass
    except Exception:  可以接收多个错误类型   继续走下面代码
    pass
如果 你只想将异常处理掉,对错误信息不关心,用万能异常.
如果 你需要根据不同的错误信息而执行不同的逻辑(分流),那么用多分支,或者多分支加万能异常
    4,
    多分支 + 万能
    try  except else
      else : 如果出现异常,就不执行else 否则执行else语句.

    try:
        pass
        pass
    except ValueError:
        pass
    except Exception:
        pass
    else:
        pass

try except (else) finally
finally 出不出现异常都执行,异常出现前执行fianlly.
用途:
    1关闭文件句柄,关闭数据库链接.
    2 函数return之前能够执行finally代码.
    3, break之前可以执行finally.

    例题
        try:
            f = open(‘aaa‘, encoding=‘utf-8‘,mode=‘w‘)
            f.write(‘fdsafsd‘)
            # 文件件句柄操作的代码非常多
        except Exception:
            print(333)
        else:
            print(666)
        finally:
            # print(‘执行‘)
            f.close()

    7  raise 主动抛出异常
        raise IndexError(‘超出索引范围‘)
    8 assert   在源码中常出现   断言  表示一个强硬的态度,不满足条件直接报错

    9 自定义

原文地址：https://www.cnblogs.com/LMTlmt/p/10324830.html