python类方法继承_PYTHON3中 类的继承

继承

1：什么是继承

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，也就是说在python中支持一个儿子继承多个爹。

新建的类成为子类或者派生类。

父类又可以成为基类或者超类。

子类会遗传父类的属性。

2：为什么要用继承

减少代码冗余（也就是重复写代码）。

3：怎么用继承：

我们定义两个类；classparenclass1:

passclassparenclass2:

pass

在定义两个类：classsubclass1:

passclasssubclass2:

pass

我想让 ：classparenclass1: 作为 class subclass1: 的父类。

pass pass应该这样用：classsubclass1（ parenclass1）: 这就表示subclass1是子类，parenclass 是subclass1 的父类

pass

两个父类的话怎么表达呢？如下：classsubclass2（parenclass1,parenclass2）:

pass

这就表示subclass2的父类是parenclass1,parenclass2 这两个

想要查看子类的父类 应该怎样查看呢： 用__bases__ 如下：

classParentClass1:

passclassParentClass2:

passclassSubclass1(ParentClass1):

passclassSubclass2(ParentClass1,ParentClass2):

pass

print(Subclass1.__bases__)

#打印结果：(,)

print(Subclass2.__bases__)

#打印结果：

(,)

经典类与新式类

1、只有在python2中才分新式类和经典类，python3中统一都是新式类2、在python2中 没有显示继承的object类的类，以及该类的子类都是经典类3、在python2中，显示的声明继承object的类，以及该类的子类都是新式类4、在python3中，无论是否继承object，都默认 继承object，即python3中所有类均为新式类

至于经典类 与新式类的区别，后面会有讨论。

提示：如果没有指定基类， python的类会默认继承object类， object是所有python类的基类。

二、继承与抽象

继承描述的是子类与父类之间的关系，是一种什么的关系呢？ 要找出这种关系， 必须先抽象在继承。

抽象即抽取类似或者说比较像的部分。

抽象分成两个层次：

1.将奥巴马和梅西这俩对象比较像的部分抽取成类；

2.将人，猪，狗这三个类比较像的部分抽取成父类。

抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象合格过程， 才能通过继承的方式去表达抽象的结构。

抽象只是分析和设计的过程，一个动作或者说一种技巧，通过抽象可以得到类

例如：我们写一个老男孩的老师与学生的类，若是不涉及到继承的话 我们正常是这样写

classOldboyTeacher:

school= 'oldboy'def __init__(self,name,age,sex):

self.name=name

self.age=age

self.sex=sex

def change_score(self):

print('teacher %s is changing score' %self.name)classOldboystudent:

school = 'oldboy’

def __init__(self,name,age,sex):

self.name=name

self.age=age

self.sex=sex

def choose(self):

print('student %s choose course' %self.name)

tea1= OldboyTeacher('egon', 18, 'male') #OldboyTeacher.__init__(...)

stu1=Oldboystudent('alex',73,'female')

print(tea1.name,tea1.age,tea1.sex) # egon 18 maleprint(stu1.name) #alex

但是我们经过分析 发现里面里面有许多重复代码， 这时我们可以用到类的继承来写了。如下：

classOldboyPeople:

school='oldboy'def __init__(self,name,age,sex):

self.name=name

self.age=age

self.sex=sexclassOldboyteacher(OldboyPeople):

def change_score(self):

print('teacher %s is changing score' %self.name)classOldboystudent(OldboyPeople):

def choose(self):

print('student %s choose course'%self.name)

tea1= Oldboyteacher('egon', 18, 'male')

stu1=Oldboystudent('alex',73,'female')

print(tea1.name,tea1.age,tea1.sex)#egon18male

print(stu1.name) #alex

三、基于继承在看属性查找

我们先看一个列子

class Foo:

def f1(self):

print('Foo.f1')

def f2(self): #self=obj

print('Foo.f2') #在父类中找到发 f2属性，第3步打印这一行

self.f1() #obj.f1() 第4步再去掉用self的f1属性

class Bar(Foo):

def f1(self):#第五步， 在回到object自身的名称空间找f1属性，找到后调用

print('Bar.f1') #第6步 执行

obj=Bar() #第一步 ：类的实例化， 先得到一个空对象，

obj.f2() #第2步：空对象调用f2属性 在自身寻找f2属性， 没有找到就去父类中寻找

#结果

Foo.f2

Bar.f1

注意子类的属性查找，一定是优先查找子类自己本身的属性与特征， 在本身没有的情况下 在去父类中查找。

四、派生

派生：子类定义自己新的属性，如果与父类同名，以子类自己的为准。

classOldboyPeople:

school= 'oldboy'def __init__(self, name, age, sex):

self.name=name

self.age=age

self.sex=sex

def f1(self):

print('爹的f1')classOldboyTeacher(OldboyPeople):

def change_score(self):

print('teacher %s is changing score' %self.name)

def f1(self):

print('儿子的f1')

tea1= OldboyTeacher('egon', 18, 'male')

tea1.f1()

#调用显示：儿子的f1

# 父类和子类中都有f1, 优先调用自己的属性，所以结果调用的是儿子的f1

五、在子类中派生出的新方法重用父类的功能

拿上一案例来举例 在oldboyteacher 这个类中要添加薪水与级别。 然后调用。 有两种方式。

方式一：指名道姓的调用（与继承没有什么关系）

classOldboyPeople:

school='oldboy'def __init__(self,name,age,sex):

self.name=name

self.age=age

self.sex=sex

def tell_info(self):

print(''' ====个人信息====姓名：%s

年龄：%s

性别：%s'''%(self.name,self.age,self.sex))

classOldboyTeacher(OldboyPeople):

def __init__(self,name,age,sex,level,salary):

OldboyPeople.__init__(self,name,age,sex) #在这里指明道姓来调用这一个函数里的属性

self.level=level

self.salary=salary

def tell_info(self):

OldboyPeople.tell_info(self) #指名道姓的来调用这个函数里的属性

print(""" 等级：%s

薪资：%s"""%(self.level,self.salary))

tea1= OldboyTeacher('egon', 18, 'male', 9, 3.1)

print(tea1.name, tea1.age, tea1.sex, tea1.level, tea1.salary)

tea1.tell_info()

#打印结果：

egon18 male 9 3.1

====个人信息====姓名：egon

年龄：18性别：male

等级：9薪资：3.1

方法二、

用super()调用（严格依赖于继承）

super() 的返回值是一个特殊的对象，该对象专门用来调用父类中的属性， 一般在python2中，需要super(自己的类名,self)， 而python3中，括号里面一般不填类名

classOldboyPeople:

school= 'oldboy'def __init__(self, name, age, sex):

self.name=name

self.age=age

self.sex=sex

def tell_info(self):

print(""" ===========个人信息==========姓名：%s

年龄：%s

性别：%s"""%(self.name,self.age,self.sex))

classOldboyTeacher(OldboyPeople):

def __init__(self, name, age, sex, level, salary):

super().__init__(name,age,sex)

self.level=level

self.salary=salary

def tell_info(self):

super().tell_info()

print(""" 等级：%s

薪资：%s"""%(self.level,self.salary))

tea1= OldboyTeacher('egon', 18, 'male', 9, 3.1)

print(tea1.name, tea1.age, tea1.sex, tea1.level, tea1.salary)

tea1.tell_info()

#调用结果：

egon18 male 9 3.1

===========个人信息==========姓名：egon

年龄：18性别：male

等级：9薪资：3.1

六：经典类 与新式类

1新式类：

继承object的类，以及该类的子类，都是新式类

在python3中，如果一个类没有指定继承的父类，默认就继承object

所以说在python3中所有的类都是新式类

2经典类：（只有在python2才区分经典类和新式类）：

没有继承object的类，以及该类的子类 都是经典类

1 经典类：深度优先

2 新式类：广度优先

如果继承关系为非菱形结果吗则会按照先找B 这一条分支，然后在找c这一条分支，最后找D这一条分支的顺序，直到找到我们想要的属性

当继承关系为菱形结构时

经典类查找顺序：

若是在A 类里自己没找到， 则会先去B类里去找， B类里没找到，就会在E类里找， 然后在G类里找，

G类里没找到 会去C 类里找， 然后去F 类里找，最后去D 类里找。

新式类查找顺序：

按照图中1 ，2 ， 3, 4,5,6的顺序查找， 这个为广度优先的查找方式

七: super（）依赖继承

super（）会严格按照mro列表从当前查找到的位置继续往后查找

classA:

def test(self):

print('A.test') #2执行这一步 打印

super().f1 #3然后在调用父类里的f1, 根据C.mro里的查找顺序执行到A 往后继续执行到B里去查找classB:

def f1(self): #4找到f1, 执行

print('from B') #5打印classC(A,B):

pass

c=C()

print(C.mro()) #调用属性的顺序 [, , , ]

c.test() #1：C里没有 ，去A里调用

#打印结果

A.test

from B