标签：报错 __init__ 对象 继承 编程 重定义 创建 选择 图片
继承是一种创建新类的方式，新建的类可以继承一个或多个父类(python支持多继承)
父类：又称基类，超类
新建类：派生类，子类
作用：子类会‘遗传’父类的属性，从而解决代码重用问题，减少代码冗余。
#单继承
class subclass(Parentclass)
#多继承
class subclass(Parentclass1,Parentclass2)查看继承关系
#查看继承的所有父类
>>>subclass.__bases__
#查看从左到右继承的第一个子类
>>>subclass.__base__继承描述的是子类与父类之间的关系，是一种什么是什么的关系。要找出这种关系，必须先抽象再继承。
什么是抽象？
即：抽取类似或者说比较像的部分。
看个图片
那么到底什么是继承？
继承是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
再看个图片
在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时
我们不可能从头开始写一个类B，这就用到了类的继承的概念。
通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用
再看属性查找
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.f1()
class Bar(Foo):
def f1(self):
print('Bar.f1')
b=Bar()
b.f2()
>>>Foo.f2
>>>Bar.f1总结：依然是先找自己的，再找类的，再找父类的，还是找不到就报错。
子类定义自己的新的属性，如果属性名和父类同名，就以子类自己的为准，定义这个新属性的过程就是派生
组合：除继承外的代码重用的另一个方式。组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合。
组合与继承
组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同。
继承
通过继承建立了派生类和基类之间的关系，它是一种‘是’的关系。当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好。
组合
用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系。当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好。
代码示例
class People:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
class Course:
def __init__(self,name,period,price):
self.name=name
self.period=period
self.price=price
def tell_info(self):
print('<%s %s %s>' %(self.name,self.period,self.price))
class Teacher(People):
def __init__(self,name,age,sex,job_title):
People.__init__(self,name,age,sex)
self.job_title=job_title
self.course=[]
self.students=[]
class Student(People):
def __init__(self,name,age,sex):
People.__init__(self,name,age,sex)
self.course=[]
egon=Teacher('egon',18,'male','沙河霸道金牌讲师')
s1=Student('牛榴弹',18,'female')
python=Course('python','3mons',3000.0)
linux=Course('python','3mons',3000.0)
#为老师egon和学生s1添加课程
egon.course.append(python)
egon.course.append(linux)
s1.course.append(python)
#为老师egon添加学生s1
egon.students.append(s1)
#使用
for obj in egon.course:
obj.tell_info()什么是接口
自己提供给使用者来调用自己功能的方法\入口
为什么要用接口
接口提供了一群类共同的函数，可以把接口当做一个函数的集合，然后让子类去实现接口中的函数。
这么做的意义在于归一化。
归一化：就是只要是基于同一个接口实现的类，那么所有的这些类的对象在使用时，从用法上来说都是一样的。
归一化的好处：
1.让使用者无需关心对象的类是什么，只需要知道这些对象都具备某些功能就可以了。极大的降低了使用者的使用难度。
2.使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合
模仿接口
python中没有接口的关键字，如果非要去模仿接口的概念，可以使用继承：
继承的两种用途：
1、继承基类的方法，并且做出子的改变或者拓展（代码重用）：实践中，继承的这种用途意义并不大，甚至有害。因为它使得子类与基类出现强耦合。
2、声明某个子类兼容与某基类，定义一个接口类，接口类中定义了一些接口名(函数名)且并未实现接口的功能，?子类继承接口类，并且实现接口中的功能
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('进程数据的读取方法')上面的代码只是看起来像接口，其实并没有起到接口的作用，子类完全不用去实现接口，这就用到了抽象类。
什么是抽象类
python的抽象类需要借助模块实现，抽象类是一个特殊的类，特殊在只能被继承，不能被实例化
为什么要有抽象类
如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性
从设计角度来看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的
从实现角度来看，抽象类与普通类的不同之处在于：抽象类中只能有抽象方法(没有实现功能)，该类不能被实例化，只能被继承，且子类必须实现抽象方法。
在python中实现抽象类
利用abc模块下的abstractmethod方法
#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
#一切皆文件
import abc #利用abc模块实现抽象类
class All_file(metaclass=abc.ABCMeta):
all_type='file'
@abc.abstractmethod #定义抽象方法，无需实现功能
def read(self):
'子类必须定义读功能'
pass
@abc.abstractmethod #定义抽象方法，无需实现功能
def write(self):
'子类必须定义写功能'
pass
# class Txt(All_file):
# pass
#
# t1=Txt() #报错,子类没有定义抽象方法
class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print('文本数据的读取方法')
def write(self):
print('文本数据的读取方法')
class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print('硬盘数据的读取方法')
def write(self):
print('硬盘数据的读取方法')
class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print('进程数据的读取方法')
def write(self):
print('进程数据的读取方法')
wenbenwenjian=Txt()
yingpanwenjian=Sata()
jinchengwenjian=Process()
#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()
print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)抽象类与接口
抽象类的本质还是类，指的的一组类的相似性，包括数据属性和函数属性，而接口只强调函数属性的相似性。
抽象类是一个介于类和接口之间的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计
继承顺序
python支持多继承
如果继承关系为非菱形结构，则会按照先找B分支，再找C分支，最后找D分支的顺序直到找到我们想要的属性
如果继承关系为菱形结构，那么属性的查找方式有两种，分别是：深度优先和广度优先
class A(object):
def test(self):
print('from A')
class B(A):
def test(self):
print('from B')
class C(A):
def test(self):
print('from C')
class D(B):
def test(self):
print('from D')
class E(C):
def test(self):
print('from E')
class F(D,E):
# def test(self):
# print('from F')
pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性
#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类继承原理(python如何实现继承)
对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表，例如
>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]为了实现继承，python会在MRO列表上从左到右开始查找基类，直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法实现的。我们不去深究这个算法的数学原理，它实际上就是合并所有父类的MRO列表并遵循下面三条准则：
1、子类会先于父类被检查
2、多个父类会根据他们在列表中的顺序被检查
3、如果对下一个类存在两个合法的选择，选择第一个父类
1、指名道姓，即父类名.父类方法()
#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
class Vehicle: #定义交通工具类
Country='China'
def __init__(self,name,speed,load,power):
self.name=name
self.speed=speed
self.load=load
self.power=power
def run(self):
print('开动啦...')
class Subway(Vehicle): #地铁
def __init__(self,name,speed,load,power,line):
Vehicle.__init__(self,name,speed,load,power)
self.line=line
def run(self):
print('地铁%s号线欢迎您' %self.line)
Vehicle.run(self)
line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
line13.run()2、super()
class Vehicle: #定义交通工具类
Country='China'
def __init__(self,name,speed,load,power):
self.name=name
self.speed=speed
self.load=load
self.power=power
def run(self):
print('开动啦...')
class Subway(Vehicle): #地铁
def __init__(self,name,speed,load,power,line):
#super(Subway,self) 就相当于实例本身 在python3中super()等同于super(Subway,self)
super().__init__(name,speed,load,power)
self.line=line
def run(self):
print('地铁%s号线欢迎您' %self.line)
super(Subway,self).run()
class Mobike(Vehicle):#摩拜单车
pass
line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
line13.run()即使没有直接继承关系，super仍然会按照mro继续往后查找
#A没有继承B,但是A内super会基于C.mro()继续往后找
class A:
def test(self):
super().test()
class B:
def test(self):
print('from B')
class C(A,B):
pass
c=C()
c.test() #打印结果:from B
print(C.mro())
#[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]指名道姓与super()的区别
#指名道姓
class A:
def __init__(self):
print('A的构造方法')
class B(A):
def __init__(self):
print('B的构造方法')
A.__init__(self)
class C(A):
def __init__(self):
print('C的构造方法')
A.__init__(self)
class D(B,C):
def __init__(self):
print('D的构造方法')
B.__init__(self)
C.__init__(self)
pass
f1=D() #A.__init__被重复调用
'''
D的构造方法
B的构造方法
A的构造方法
C的构造方法
A的构造方法
'''
#使用super()
class A:
def __init__(self):
print('A的构造方法')
class B(A):
def __init__(self):
print('B的构造方法')
super(B,self).__init__()
class C(A):
def __init__(self):
print('C的构造方法')
super(C,self).__init__()
class D(B,C):
def __init__(self):
print('D的构造方法')
super(D,self).__init__()
f1=D() #super()会基于mro列表,往后找
'''
D的构造方法
B的构造方法
C的构造方法
A的构造方法
'''当你使用super()函数时，python会在MRO列表上继续搜索下一个类。只要每个重定义的方法统一使用super()并只调用它一次，那么控制流最终会遍历完整个MRO列表，每个方法也只会被调用一次(注意：使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过代码去找继承关系，一定要看MRO列表)
标签：报错 __init__ 对象 继承 编程 重定义 创建 选择 图片
原文地址：https://www.cnblogs.com/guodengjian/p/9168937.html
