一、继承

1、什么是继承

继承是一种创新类的方式，在python中，

新建的类可称子类或者派生类，父类称为基类或者超类

子类会继承父类所有属性

需要注意的是：

python支持多继承

新建的类可以继承一个或者多个父类

class Parent1:
pass
class Parent2:
pass
class Sub1(Parent1): # 单继承
pass
class Sub2(Parent1,Parent2): # 多继承
pass
# 查看子类调用的父类
print(Sub1.__bases__) # (,)
print(Sub2.__bases__) # (, )
python的多继承

优点：子类可以同时继承多个父类的属性，最大限度的重用代码。

缺点：

1、违背人的思维习惯，继承表达的是一种什么“是”什么的关系。

2、代码可读性会变差

3、不建议使用多继承，扩展性变差，如果真的涉及到一个子类不可避免的要重用多个父类的属性，应该使用Mixins

单继承：继承表达的是一种什么“是”什么的关系

人类

动物类

共同的特点：吃，睡，跑，叫，也就是说人是动物

多继承：就不能像单继承那样，一个事物不能同时是多个事物，逻辑冲突

class A:
pass
class B(A):
x = 222
class C(B):
pass
class D(C):
pass
print(D.x) # 222 先去D找，再去C找，再去B找
# ps1：在python2中有经典类和新式类之分
# 新式类：继承了object类的子类，以及该子类的子类
# 经典类：没有继承object类的子类，以及该子类的子类子子类
# 总结：object类是python内置的类，也就是所有类的超类
"""
>>> class Foo: # 经典类
... pass
...
>>> Foo.__bases__
()
>>> class Bar(object): # 新式类
... pass
...
>>> Bar.__bases__
(,)
>>>
"""
# ps2:在python3中有没有经典类和新式类之分?
# 在python3之中没有继承任何类，那么会默认继承object类，所以python3中所有的类都是新式类
print(Parent1.__bases__) # (,)
print(Parent2.__bases__) # (,)
# 所以思考如何让python3中的类在python2中兼容？加入(object)
class Parent3(object): # 兼容python2
pass

2、为何要用继承？

用来解决代码冗余，

类是解决对象之间代码冗余，

继承是解决类之间代码冗余。

class Parent4:
x = 1
class Sub4(Parent4):
y = 2
print(Sub4.x,Sub4.y) # 1 2

3、要找出类与类之间的继承关系，需要先抽象，再继承。抽象即总结相似之处，总结对象之间的相似之处得到类，总结类与类之间的相似之处就可以得到父类，如下图所示


基于抽象的结果，我们就找到了继承关系


4、继承的使用

# 思考一下找到学生和老师的共同之处：
# 示范1：基于类与类之间存在冗余问题
# 选课系统
# 定义学生类
class Student:
school = 'OLDBOY'
# 定义学生属性
def __init__(self,stu_id,name,age,sex):
self.name = name
self.age = age
self.sex = sex
# 定义学生功能
def choose_course(self):
print('%s 正向选课' % self.name)
# 定义老师类
class Teacher:
school = 'OLDBOY'
def __init__(self,name,age,sex,salary,level):
self.name = name
self.age = age
self.sex = sex
self.salary = salary
self.level = level
def score(self):
print('老师 %s 正在给学生打分' % self.name)
# 派生的三种情况：新建，修改，扩展
# 提取出共有的属性
class OldboyPeople:
school = 'OLDBOY'
# 定义共有属性
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
# 选课系统
# 定义学生类
class Student(OldboyPeople):
# 派生之一：新建一个功能
def choose_course(self):
print('%s 正向选课' % self.name)
# 派生之二：修改
school = '派生之二修改OLDBOY学校名'
# 实例话学生
stu_obj = Student('lili',18,'female')
print(stu_obj.__dict__) # {'name': 'lili', 'age': 18, 'sex': 'female'}
print(stu_obj.school) # 派生前OLDBOY 派生后运行结果：派生之二修改OLDBOY学校名
stu_obj.choose_course() # lili 正向选课
"""
对象本身,lsj',18,'male',3000,2
init中(self,name,age,sex,salary,level)
"""
class Teacher(OldboyPeople):
# 派生之三：扩展
def __init__(self,name,age,sex,salary,level):
# 指名道姓的跟父类要init这个方法(name,age,sex)
OldboyPeople.__init__(self,name,age,sex)
self.salary = salary
self.level = level
def score(self):
print('老师 %s 正在给学生打分' % self.name)
tea_obj = Teacher('lsj',18,'male',3000,2)
# 派生之三前运行结果：TypeError: __init__() takes 4 positional arguments but 6 were given
print(tea_obj.__dict__)
# 派生之三后运行结果：{'name': 'lsj', 'age': 18, 'sex': 'male', 'salary': 3000, 'level': 2}
print(tea_obj.school) # OLDBOY
tea_obj.score() # 老师 lsj 正在给学生打分

5、单继承下属性的查找顺序

# 单继承背景下的属性查找
# 示范一
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.f1() # obj.f1()
class Bar(Foo):
def f1(self):
print('Bar.f1')
obj = Bar()
obj.f2()
# 运行结果：Foo.f2 Bar.f1
# 为什么是这样的结果：不是就近查找
# 单继承背景下的属性查找
# 需求必须调用Foo类下的f1该怎么办？
# 示范一
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
Foo.f1(self) # 调用当前类中的f1，运行结果：Foo.f1
self.f1() # obj.f1()
class Bar(Foo):
def f1(self):
print('Bar.f1')
obj = Bar()
obj.f2()
# 运行结果：Foo.f2 Bar.f1
# 为什么是这样的结果：不是就近查找
# 示范二
class Foo:
# 使用隐藏属性
def __f1(self): # _Foo__f1
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.__f1() # self._Foo__f1
class Bar(Foo):
def __f1(self): # _Bar__f1
print('Bar.f1')
obj = Bar()
obj.f2()

# 运行结果：Foo.f2 Foo.f1

标签：__,f1,Python,self,面向对象,print,Foo,class,三大