继承
单继承
多继承
继承：继承实现代码的重用，相同的代码不需要重复的编写
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()
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): #此处重写时方法要与被重写的一致，即覆盖掉原有方法内容，如
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()
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()
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)
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:
如果没有异常执行这块代码
正常的操作
......................
except:
发生异常，执行这块代码
......................
else:
如果没有异常执行这块代码
例子：
try:
fh = open("testfile", "w")
fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
print("Error: 没有找到文件或读取文件失败")
else:
print("内容写入文件成功")
fh.close()
fh = open("testfile", "w")
fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
print("Error: 没有找到文件或读取文件失败")
else:
print("内容写入文件成功")
fh.close()
try-finally (不管代码成功与否都执行finally的代码块)
try:
<语句>
finally:
<语句> #退出try时总会执行
raise
<语句>
finally:
<语句> #退出try时总会执行
raise
try:
fh = open("testfile", "w")
fh.write("这是一个测试文件，用于测试异常!!")
finally:
print("Error: 没有找到文件或读取文件失败")
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)
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)