Python之面向对象继承和派生
什么是继承：
继承是一种创建新的类的方法。在Python中，新建的类可以继承自一个或多个父类。原始类称为基类或超类。
新建的类称为派生类或子类。
Python中类的继承分为单继承和多继承。
class ParentClass1: #定义父类
pass class ParentClass2: #定义父类
pass class SubClass1(ParentClass1) #单继承，基类是ParentClass，派生是SubClass
pass class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类。
pass print(SubClass1.__bases__) #查看继承的类。
注意：
如果没有指定基类。Python的类会默认继承object类。object是所有Python类的基类。他提供了一些常见方法。屁如：（__str__) 的实现。
继承与抽象（先抽象再继承）：
抽象既抽取类似或者说比较像的部分。
抽象分为两个层次：
1，将Obama和George这两个对象比较像的部分抽取成类。
2，将人，猴，狗这三个类比较像的部分抽取成父类。
抽象最主要的作用是划分类别。（可以隔离关注点，降低复杂度）
继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方法去表达出抽象的结果。
抽象只是分析和设计的过程中，一个动作或者说一种技巧。通过抽象可以得到类。
多态：同一种事物的不同形态。人，狗都是动物。
继承与重用性：
重用性：将重复的功能写在父类里。在子类里继承即可。
==========================第一部分
例如 猫可以：喵喵叫、吃、喝、拉、撒 狗可以：汪汪叫、吃、喝、拉、撒 如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下： #猫和狗有大量相同的内容
class 猫： def 喵喵叫(self):
print '喵喵叫' def 吃(self):
# do something def 喝(self):
# do something def 拉(self):
# do something def 撒(self):
# do something class 狗： def 汪汪叫(self):
print '喵喵叫' def 吃(self):
# do something def 喝(self):
# do something def 拉(self):
# do something def 撒(self):
# do something ==========================第二部分
上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现： 动物：吃、喝、拉、撒 猫：喵喵叫（猫继承动物的功能） 狗：汪汪叫（狗继承动物的功能） 伪代码如下：
class 动物: def 吃(self):
# do something def 喝(self):
# do something def 拉(self):
# do something def 撒(self):
# do something # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 猫(动物)： def 喵喵叫(self):
print '喵喵叫' # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 狗(动物)： def 汪汪叫(self):
print '喵喵叫' ==========================第三部分
#继承的代码实现
class Animal: def eat(self):
print("%s 吃 " %self.name) def drink(self):
print ("%s 喝 " %self.name) def shit(self):
print ("%s 拉 " %self.name) def pee(self):
print ("%s 撒 " %self.name) class Cat(Animal): def __init__(self, name):
self.name = name
self.breed = '猫' def cry(self):
print('喵喵叫') class Dog(Animal): def __init__(self, name):
self.name = name
self.breed='狗' def cry(self):
print('汪汪叫') # ######### 执行 ######### c1 = Cat('小白家的小黑猫')
c1.eat() c2 = Cat('小黑的小白猫')
c2.drink() d1 = Dog('胖子家的小瘦狗')
d1.eat() 使用继承来重用代码比较好的例子
在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时
我们不可能从头开始写一个类B，这就用到了类的继承的概念。
通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用
class Hero:
def __init__(self,nickname,aggressivity,life_value):
self.nickname=nickname
self.aggressivity=aggressivity
self.life_value=life_value def move_forward(self):
print('%s move forward' %self.nickname) def move_backward(self):
print('%s move backward' %self.nickname) def move_left(self):
print('%s move forward' %self.nickname) def move_right(self):
print('%s move forward' %self.nickname) def attack(self,enemy):
enemy.life_value-=self.aggressivity
class Garen(Hero):
pass class Riven(Hero):
pass g1=Garen('草丛伦',100,300)
r1=Riven('锐雯雯',57,200) print(g1.life_value)
r1.attack(g1)
print(g1.life_value) '''
运行结果
'''
提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大生了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.
注意：像g1.life_value之类的属性引用，会先从实例中找life_value然后去类中找，然后再去父类中找...直到最*的父类。
重点！！！：再看属性查找
class Foo:
def f1(self):
print('Foo.f1') def f2(self):
print('Foo.f2')
self.f1() class Bar(Foo):
def f1(self):
print('Foo.f1') b=Bar()
b.f2()
派生：
首先要继承一个父类，如果自己不定义自己的内容，那就从父类里拿。
如果在子类里定义和父类重名的东西，那么在调用时，以子类为准。
当然，也可以自己定义一个新的功能，父类没有的功能。
如何在子类里派生的方法里，重用父类的逻辑：
如何在子类的方法里调用父类的方法。
#派生
class Hero:
def __init__(self, nickname,aggressivity,life_value):
self.nickname = nickname
self.aggressivity = aggressivity
self.life_value = life_value
def attack(self, enemy):
print('Hero attack') class Garen(Hero):
camp = 'Demacia'
def attack(self, enemy): #self=g1,enemy=r1
# self.attack(enemy) #g1.attack()
Hero.attack(self,enemy) #用父类里的attack，参数是Hero里的attack的参数。这里的self是g1，enemy是r1
print('from garen attack') def fire(self):
print('%s is firing' % self.nickname) class Riven(Hero):
camp = 'Noxus' g1 = Garen('garen', 18, 200)
r1 = Riven('rivren', 18, 200)
g1.attack(r1)
# print(g1.camp)
# print(r1.camp)
# g1.fire()
在子类里，也定义init，这个init是和父类的init不冲突的。class Hero:
def __init__(self, nickname, aggressivity, life_value):
self.nickname = nickname
self.aggressivity = aggressivity
self.life_value = life_value
def attack(self, enemy):
print('Hero attack')
enemy.life_value -= self.aggressivity
# print(Hero.__init__)
# print(Hero.attack) class Garen(Hero):
camp = 'Demacia'
def __init__(self, nickname, aggressivity, life_value, script):
Hero.__init__(self,nickname,aggressivity,life_value) #调用父类的init方法，
# self.nickname = nickname
# self.aggressivity = aggressivity
# self.life_value = life_value
self.script = script #也可以自己加自己的init。
def attack(self, enemy): # self=g1,enemy=r1
# self.attack(enemy) #g1.attack()
Hero.attack(self, enemy)
print('from garen attack')
def fire(self):
print('%s is firing' % self.nickname)
# g1=Garen('garen',18,200) #Garen.__init__(g1,'garen',18,200)
g1=Garen('garen',18,200,'人在塔在') #Garen.__init__(g1,'garen',18,200)
print(g1.script)
组合：
多个类组合在一起。 解决代码的重用性。是一种类与类之间与的关系。
class Teacher:
def __init__(self,name,sex,course,birth):
self.name = name
self.sex = sex
self.course = course
self.birth = birth class Student:
def __init__(self,name,sex,course):
self.name = name
self.sex = sex
self.course = course class Course:
def __init__(self,name,price,peroid):
self.name = name
self.price = price
self.peroid = peroid python_obj=Course('python',15800,'7m')
t1=Teacher('egon','male',python_obj)
s1=Student('cobila','male',python_obj) print(s1.course.name)
print(t1.course.name) class Teacher:
def __init__(self,name,sex,course_name,course_price,course_period):
self.name=name
self.sex=sex
self.course_name=course_name
self.course_price=course_price
self.course_period=course_period class Student:
def __init__(self,name,sex,course_name,course_price,course_period):
self.name=name
self.sex=sex
self.course_name=course_name
self.course_price=course_price
self.course_period=course_period t1=Teacher('egon','male','python',15800,'7m')
s1=Student('cobila','male','python',15800,'7m') print(s1.course.name)
print(t1.course.name)
接口与归一化设计：
接口：接口是对外入口，Python是没有接口的概念的。所以Python只能用继承去模拟Java的接口。
class Animal:
def run(self):
#主动抛异常
raise AttributeError('子类必须实现这个方法') def speak(self):
raise AttributeError('子类必须实现这个方法') class People(Animal):
def run(self):
print("Human is walk") def speak(self):
print("man is tell") class Pig(Animal):
def run(self):
print('Pig is walking') def speak(self):
print('Pig wow') peo1=People()
# peo1.run()
peo1.speak() # peo1=People()
# pig1=Pig()
#
# peo1.run()
# pig1.run() # class Interface:#定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
# def read(self): #定接口函数read
# pass
#
# def write(self): #定义接口函数write
# pass
#
#
# class Txt(Interface): #文本，具体实现read和write
# def read(self):
# print('文本数据的读取方法')
#
# def write(self):
# print('文本数据的读取方法')
#
# class Sata(Interface): #磁盘，具体实现read和write
# def read(self):
# print('硬盘数据的读取方法')
#
# def write(self):
# print('硬盘数据的读取方法')
#
# class Process(Interface):
# def read(self):
# print('进程数据的读取方法')
#
# def write(self):
# print('进程数据的读取方法') # t1=Txt()
# s1=Sata()
# p1=Process() # t1.read()
# t1.write() # s1.read()
# s1.write() # p1.read()
# p1.write()
主动抛异常：
class Animal:
def run(self):
#主动抛异常
raise AttributeError('子类必须实现这个方法') def speak(self):
raise AttributeError('子类必须实现这个方法')
抽象类：
本质还是类，与普通类额外的特点的是：加了装饰器的函数，子类必须实现他们
用abc模块。
所有子类，必须实现父类中加了装饰器函数的方法。否则无法实例。
import abc
#抽象类：本质还是类，与普通类额外的特点的是：加了装饰器的函数，子类必须实现他们
class Animal(metaclass=abc.ABCMeta):
tag=''
@abc.abstractmethod
def run(self):
pass
@abc.abstractmethod
def speak(self):
pass class People(Animal):
def run(self):
pass def speak(self):
pass peo1=People()
print(peo1.tag)