面向对象（继承重写多态）以及异常处理

Posted 2021-11-02 zzzynx

一.继承（单继承多继承继承：即可以继承多个父类）

　目标： 实现代码的重用，相同的代码不需要重复的编写。

class Human:          #创建一个类
    def eat(self):
        print(‘chi‘)
    def drink(self):
        print(‘he‘)
    def la(self):
        print(‘la‘)
    def sa(self):           #有吃喝拉撒四种方法
        print(‘sa‘)

class Man(Human):           #再创建一个类Man，以Human做父类，就继承了Human的四种方法
    def ml(self):
        print(‘fight‘)
man = Man()
man.eat（）
man.drink()
...            #实例化man继承了父类Human和Man的所有方法

二 ：父类方法的重写和拓展

1）.当父类方法不满足子类需求时，就需要重写。

2）.对父类的方法进行扩展

1.在子类中重写父类的方法

2.在需要的位置使用super().父类方法来调用父类方法的执行

3.代码其他的位置针对子类的需求，编写子类特有的代码实现

3）关于super

在python中super是一个特殊的类

super()就是使用super类创建出来的对象

最常使用的场景就是在重写父类方法时，调用在父类中封装的方法实现

class Human:          #创建一个类
    def eat(self):
        print(‘chi‘)
    def drink(self):
        print(‘he‘)
    def la(self):
        print(‘la‘)
    def sa(self):           #有吃喝拉撒四种方法
        print(‘sa‘)

class Man(Human):           #再创建一个类Man，以Human做父类，就继承了Human的四种方法
    def ml(self):
        print(‘fight‘)

class Daniu(Man):          #再创建一个类来继承Man，就继承了Man的方法
    def ml(self):           #此处重写父类的ml方法为peace
        print(‘peace‘)
        super().ml()         #此处用super（）.父类方法的格式来调用父类方法，这样就可以在重写的基础上再获得父类方法。
H = Daniu()           #实例化Daniu类
H.ml()
H.eat()
H.drink()
H.la()
H.sa()                 #调用方法查看结果

三：多态

　　面向对象的三大特性：

　　1.封装根据职责将属性和方法封装到一个抽象的类中
定义类的准则
　　2.继承实现代码的重用，相同的代码不需要重复的编写
设计类的技巧
子类针对自己特有的需求，编写特定的代码
　　3.多态不同的子类对象调用相同的父类方法，产生不同的执行结果
　　　　1.多态可以增加代码的灵活度
　　　　2.以继承和重写父类方法为前提
　　　　3.是调用方法的技巧，不会影响到类的内部设计

class Dog:                                  #创建父类Dog
    def __init__(self,name):       #封装属性和方法
        self.name =name
    def game(self):
        print(‘wan‘)

class Xiaotian(Dog):
    def game(self):          #覆盖父类的方法
        print(‘fight‘)

class Human:             #再创建一个类
    def __init__(self,name):
        self.name = name
    def paly_with(self,who):          #和别人玩的方法这里定义一个形参
        print(‘%s和%s一起玩‘ %(self.name,who.name))

xt = Xiaotian(‘小天‘)        #实例化Xiaotian类的对象
dt = Xiaotian(‘大天‘)
# xt.game()                  #查看重写结果
h = Human(‘大牛‘)        #实例化Human
h.paly_with(xt)          #让实例化对象小天和大天做传参对象，就能实现多态，即子类对象调用相同的父类方法，产生不同结果。
h.paly_with(dt)

四：异常处理

什么是异常？

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。一般情况下，在Python无法正常处理程序时就会发生一个异常。

异常是Python对象，表示一个错误。当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。
 
异常处理：

捕捉异常可以使用try/except语句。try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

如果你不想在异常发生时结束你的程序，只需在try里捕获它。

语法：以下为简单的try....except...else的语法：
try:

    print(mama)
except:
    print(‘错误‘)      #--》此处预测print(mama)会报错，使用try和except语法捕捉异常，输出错误，而不是报错停止程序

try:
    print(mama)
except NameError:        #根据预测报错，输出对应的错误
    print(‘名字定义错误‘)


try:
    print(mama)
except NameError as e:      #---》name ‘mama‘ is not defined 将预测的报错信息写入e文件输出
    print(e)

try:
    print(mama)
except ValueError as e:      #---》NameError: name ‘mama‘ is not defined 如果预测错误，except不会捕捉，而是终止程序报错
    print(e)

try:
    print(mama)
    int(‘baba‘)
except NameError as e:
    print(e)                #----》name ‘mama‘ is not defined 执行完毕 ,因为print(mama)先报错，终止程序，int（’baba‘）没有执行。
                            # 但是finaly语法一定会输出结果
except ValueError as e:
    print(e)
finally:
    print(‘执行完毕‘)