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]