面向对象多继承 异常处理

总结
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 一下

1. 提取⽗类. 然后在⽗类中定义好⽅法. 在这个⽅法中什么都不⽤⼲. 就抛⼀个异常就可以了. 这样所有的⼦类都必须重写这个⽅法. 否则. 访问的时候就会报错.

2. 使⽤元类来描述⽗类. 在元类中给出⼀个抽象⽅法. 这样⼦类就不得不给出抽象⽅法的具体实现. 也可以起到约束的效果.
class Payment:
    """
    此类什么都不做，就是制定一个标准，谁继承我，必须定义我里面的方法。
    """
    def pay(self,money):
        raise Exception("你没有实现pay方法")

class QQpay(Payment):
    def pay(self,money):
        print('使用qq支付%s元' % money)

class Alipay(Payment):
    def pay(self,money):
        print('使用阿里支付%s元' % money)

class Wechatpay(Payment):
    def fuqian(self,money):
        print('使用微信支付%s元' % money)


def pay(obj,money):
    obj.pay(money)

a = Alipay()
b = QQpay()
c = Wechatpay()
pay(a,100)
pay(b,200)
pay(c,300)
复制代码
第二种方式：引入抽象类的概念处理。

复制代码
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):    # 抽象类 接口类  规范和约束  metaclass指定的是一个元类
    @abstractmethod
    def pay(self):pass  # 抽象方法

class Alipay(Payment):
    def pay(self,money):
        print('使用支付宝支付了%s元'%money)

class QQpay(Payment):
    def pay(self,money):
        print('使用qq支付了%s元'%money)

class Wechatpay(Payment):
    # def pay(self,money):
    #     print('使用微信支付了%s元'%money)
    def recharge(self):pass

def pay(a,money):
    a.pay(money)

a = Alipay()
a.pay(100)
pay(a,100)    # 归一化设计：不管是哪一个类的对象，都调用同一个函数去完成相似的功能
q = QQpay()
q.pay(100)
pay(q,100)
w = Wechatpay()
pay(w,100)   # 到用的时候才会报错



# 抽象类和接口类做的事情 ：建立规范
# 制定一个类的metaclass是ABCMeta，
# 那么这个类就变成了一个抽象类(接口类)
# 这个类的主要功能就是建立一个规范
总结: 约束. 其实就是⽗类对⼦类进⾏约束. ⼦类必须要写xxx⽅法. 在python中约束的⽅式和⽅法有两种:

1. 使⽤抽象类和抽象⽅法, 由于该⽅案来源是java和c#. 所以使⽤频率还是很少的

2. 使⽤⼈为抛出异常的⽅案. 并且尽量抛出的是NotImplementError. 这样比较专业, ⽽且错误比较明确.(推荐)
    #
# 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