python之面向对象三大特性: 继承(单继承)
什么是继承
专业角度: B 继承 A类, B就叫做A的子类,派生类, A叫做B的父类,基类,超类. B类以及B类的对象使用A类的所有的属性以及方法.
字面意思: 继承就是继承父母所有的资产
class Person:
def __init__(self,name,sex,age):
self.name = name
self.age = age
self.sex = sex
class Dog:
def __init__(self,name,sex,age):
self.name = name
self.age = age
self.sex = sex
class Cat:
def __init__(self,name,sex,age):
self.name = name
self.age = age
self.sex = sex
继承的优点(用途)
- 节省代码,减少代码的重复性
- 增强耦合性(也就是增强代码可读性)
- 使代码更加规范化
- 子类可以调用父类的所有属性
以上定义三个类,人类,狗类,猫类,发现以上代码有很多重复代码,三个类都有一样的属性,就要将重复代码合起来,重新定义一个动物类,那么就可以删除多余的代码,改成以下这种的
继承的用法
class Animal:
live = '有生命的'
def __init__(sefl, name, age, sex):
self.name = name
self.age = age
self.sex = sex
def eat(self):
print('动物都需要进食')
class Person(Animal): # 括号中Animal就是父类
pass
class Dog(Animal): # 括号中的Animal就是父类
pass
class Cat(Animal): # 括号中的Animal就是父类
pass
# 类名后面括号中传入的参数就是父类
# 1. 从类名执行父类的属性
先打印一下Person类中所有的属性
print(Person.__dict__) #输出结果:{'name': '小胖', 'age': 18, 'sex': '男'}
print(Persion.live) # 输出结果:有生命的
# 2. 类名可以执行父类的方法
Person.eat(555)
# 3. 从对象执行父类的一切
实例化对象一定会执行三件事.一定会执行__init__
p1 = Person('dsb', 21, 'boy')
print(p1.__dict__)
print(p1.live)
p1.eat()
print(f'p1 ---> {p1}')
# 注意: 子类以及子类对象只能调用父类的属性以及方法,不能操作(增删改).
继承的分类
单继承
多继承
Person Dog Cat:就叫做子类或者派生类
Animal:就叫做父类,基类,超类
单继承的用法
class Aniaml(object):
live = '有生命的'
def __init__(self,name,sex,age):
self.name = name
self.age = age
self.sex = sex
def eat(self):
print(f'self ---> {self}')
print('吃东西')
class Person(Aniaml):
def eat(self):
print('人类需要进食')
class Cat(Aniaml):
pass
class Dog(Aniaml):
pass
p1 = Person('dsb', 21, 'boy')
p1.eat()
# 输出结果
人类需要进食
# 说明一个问题: 子类将父类的方法,覆盖了,(重写父类的方法) 查找位置
# 对象查找顺序,先从对象空间找名字,子类找名字,父类找名字
方法一: 第三个继承
人类的不同于其他狗类和猫类的特性
如何既要执行父类方法又要执行子类方法
class Aniaml(object):
live = '有生命的'
def __init__(self,name,sex,age):
self.name = name
self.age = age
self.sex = sex
def eat(self):
print(f'self ---> {self}')
print('吃东西')
class Person(Aniaml):
def eat(self):
print('人类需要进食')
def __init__(self,name, age, sex, hobby):
Aniaml.__init__(self, name, age, sex) # 关键点,手动的把对象空间传给self,但是()中需要接收参数
self.hobby = hobby
class Cat(Aniaml):
pass
class Dog(Aniaml):
pass
# 正常子类有__init__就不执行父类的__init__,现在的目的既要执行父类方法又要执行子类方法
p1 = Person('催牛逼') # 这里的传参方法:p1 = Person('对对哥', 23, '不详','吹牛逼')
print(p1.__dict__)
# 方法二
class Aniaml(object):
live = '有生命的'
def __init__(self, name, sex, age):
self.name = name
self.age = age
self.sex = sex
def eat(self):
print(f'self ---> {self}')
print('吃东西')
class Person(Aniaml):
def eat(self):
print('人类需要进食')
def __init__(self, name, age, sex, hobby):
super(Person, self).__init__(name,age,sex) # 关键点
# 简写成super().__init__(name, age, sex) # 使用了父类的init
self.hobby = hobby
class Cat(Aniaml):
pass
class Dog(Aniaml):
pass
# 正常子类有__init__就不执行父类的__init__,现在的目的既要执行父类方法又要执行子类方法
p1 = Person('对对哥', 23, '不详', '吹牛逼')
print(p1.__dict__)
一句话总结
单继承是为节省代码而设计的,定义一个公共的父类,但是如果子类中存在于父类中相同的方法,子类中的方法会将父类中的方法进行覆盖,对象在查找名字的时候先重对象空间查找name,如果有直接引用,如果没有继续从子类空间中查找name,如果还没有就继续从父类空间中查找name
多继承的用法
class God:
def __init__(self, name):
self.name = name
def fly(self):
print('会飞')
def climb(self):
print('神仙累了也需要爬树')
class Monkey:
def __init__(self,sex):
self.sex = sex
def climb(self):
print('爬树')
class MonkeySun(God,Monkey): # 继承了2个类,孙猴子既是神仙又是猴子
pass
# 多继承的难点就是继承顺序的问题
# 现在执行的时候是先执行神仙的还是先执行猴子的呢?
这里面就涉及到单进程与多进程的分类:
面向对象:
python2.2之前都是经典类
python2.2之后到python2.7之间存在2种类型:经典类,新式类.区别:经典类是基类,不继承object,它的查询规则,依靠的是深度优先的原则,
python3x之后新式类,新式类必须继承object,查询规则是mro算法,在多进程的时候查询顺序不同
多继承与单继承的区别
单继承只继承一个父类,多继承需要继承多个父类,这个时候多继承就出现一个问题就是,继承顺序的问题,到底该先继承哪个父类,执行哪个父类中的方法
多继承的难点: 继承顺序的问题
经典类深度查找顺序
原则:在经典类中采⽤的是深度优先遍历⽅案. 什么是深度优先. 就是⼀条路走到头. 然后再回来. 继续找下⼀个
新式类的多继承
mro算法
通用计算公式
mro(Child(Base1，Base2)) = [ Child ] + merge( mro(Base1), mro(Base2), [ Base1, Base2] )
例题
mro(Foo(H,G)) = [Foo] + merge(mro(H), mro(G),[H,G])
表头:
列表的第一个元素
表尾:
列表中表头以外的元素集合(表位可以为空)
表头,表位
[A,B,C] A表头 [B,C]表尾
[A] : 表头: A 表尾: []
工作中研究新式类的四算方法
例题
'''
class O:
pass
class D(O):
pass
class E(O):
pass
class F(O):
pass
class B(D,E):
pass
class C(E,F):
pass
class A(B,C):
pass
# a = A()
# a.func()
'''
'''
mro(A) = mro(A(B,C))
= [A] + merge(mro(B), mro(C), [B,C])
mro(B) = mro(B(D,E))
= [B] + merge(mro(D), mro(E), [D,E])
= [B] + merge([D,O], [E,O], [D,E])
= [B,D] + merge([O], [E,O], [E])
= [B,D,E,O]
mro(C) = mro(C(E,F))
= [C] + merge(mro(E), mro(F),[E,F])
= [C] + merge([E,O],[F,O],[E,F])
= [C,E] + merge([O],[F,O],[F])
= [C,E,F,O]
mro(A) = mro(A(B,C))
= [A] + merge([B,D,E,O], [C,E,F,O], [B,C])
= [A,B] + merge([D,E,O], [C,E,F,O], [C])
= [A,B,D] + merge([E,O], [C,E,F,O], [C])
= [A,B,D,C] + merge([E,O], [E,F,O])
= [A,B,D,C,E] + merge([O], [F,O])
= [A,B,D,C,E,F,O]
