继承、多态、异常处理

继承

单继承

多继承

继承：继承实现代码的重用，相同的代码不需要重复的编写

 class Anamal:
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Anamal):
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我会飞啦！！！！')
dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()

 

#重写哮天犬叫唤的方法
class Anamal(object):
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Anamal):
    def bark(self):
        print('汪汪叫')
class XiaoTianQuan(Dog):           
    def fly(self):
        print('我会飞啦！！！！')
    def bark(self):                          #此处重写时方法要与被重写的一致，即覆盖掉原有方法内容，如

这里的bark。
        print('牛逼的叫.......')

dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()

 

class Animal(object):

    def eat(self):

        print('chi')

    def drink(self):

        print(' he')

    def sleep(self):

        print('sleep132456')

class Dog():

    def spark(self):

        print('张建成你个垃圾')

    def sleep(self):

        print('sleepaaaaaaaaaaaaaa')

class xiaotianquan(Animal,Dog):         #若不同类下具有相同方法，此处哪个类在前调用该类里内容

    def ww(self):

        print('wawawa')

    def zz(self):

        print('lalaal')

dog=xiaotianquan()

dog.sleep()

对父类的方法进行扩展

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

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

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

关于super

在python中super是一个特殊的类

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

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

#用super继承父类的方法并扩展新内容
class Anamal(object):
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Anamal):
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我会飞啦！！！！')

    def bark(self):
        print('牛逼的叫.......')           
        super().bark()                         #super()就是使用super类创建出来的对象
        print('%*#*@^$*(@')

dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()

多态

　　面向对象的三大特性：

　　1.封装：根据职责将属性和方法封装到一个抽象的类中

• 定义类的准则

　　2.继承：实现代码的重用，相同的代码不需要重复的编写

• 设计类的技巧
• 子类针对自己特有的需求，编写特定的代码

　　3.多态：不同的子类对象（实例化出的对象）调用相同的父类方法，产生不同的执行结果

　　　　1.多态可以增加代码的灵活度

　　　　2.以继承和重写父类方法为前提

　　　　3.是调用方法的技巧，不会影响到类的内部设计

 #多态的特性：让不同的子类对象调用相同的代码产生不同的结果
class Dog(object):
    def __init__(self, name):
        self.name = name

    def game(self):
        print('%s 开开心心去玩耍.....' % self.name)

class XiaoTianQuan(Dog):
    def game(self):
        print('%s 开开心心去玩耍.....' % self.name)

class Person(object):
    def __init__(self, name):
        self.name = name

    def game_with_dog(self, dog):
        print('%s 和 %s 正在开开心心的玩耍......' % (self.name, dog.name))
        dog.game()
#创建人对象
xiaoming = Person('小明')
#创建狗对象
dog = Dog('旺财')
#让小明跟狗玩耍
xiaoming.game_with_dog(dog)

 异常处理

什么是异常？

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。

一般情况下，在Python无法正常处理程序时就会发生一个异常。

异常是Python对象，表示一个错误。

当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

 

异常处理：

捕捉异常可以使用try/except语句。

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

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

语法：

try:

    print(a)

except NameError:#捕捉错误类型

    print('变量没定义')

 

try:

    print(a)

except NameError as e:                 #捕捉原生错误

    print(e)

 

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

try:
    正常的操作
   ......................
except:
    发生异常，执行这块代码
   ......................
else:
    如果没有异常执行这块代码

例子：

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
    print("Error: 没有找到文件或读取文件失败")
else:
    print("内容写入文件成功")
    fh.close()

 

try-finally (不管代码成功与否都执行finally的代码块)

try:
<语句>
finally:
<语句>    #退出try时总会执行
raise

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
finally:
    print("Error: 没有找到文件或读取文件失败")

 

处理多个异常：

try:

    print(a)

    b= int('aaa')

except NameError as e1:

    print(e1)

except ValueError as e2:

    print(e2)

name 'a' is not defined 

 

用户自定义异常：

通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类，通过直接或间接的方式。

以下为与RuntimeError相关的实例,实例中创建了一个类，基类为RuntimeError，用于在异常触发时输出更多的信息。

在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例。

#定义一个异常类

class MyError(Exception):
    def __init__(self,age):
        self.age=age
def ag():            #定义一个函数
    age=int(input('输入年龄：'))
    if age<=0 or age>100:
        raise MyError('年龄只能在0到100岁之间')
try:
     ag()             #运行这个函数
except MyError as e:
    print(e)