Python3.x基础学习-类--多继承、多态


多继承


一个子类继承多个父类,就是多继承,并且拥有所有父类的属性和方法例如:孩子会继承父亲和母亲的特征

如果子类和父类中有相同的方法,就会调用子类中的方法如果不同的父类中存在有相同的方法名称,子类对象调用的时候会调用哪个父类中的方法呢?python 会根据MRO(method resolution order) 方法解析顺序列表进行查找。
class Dog:
    def eat(self):
        print("吃骨头")

class God:
    def eat(self):
        print("吃上帝")

class Thing(God,Dog):
    pass

thing = Thing()
thing.eat()
print(Thing.__mro__)

# 吃上帝
# (<class ‘__main__.Thing‘>, <class ‘__main__.God‘>, <class ‘__main__.Dog‘>, <class ‘object‘>)
MRO列表并遵循如下三条准则:1.子类会先于父类被检查2.多个父类会根据他们在列表中的顺序进行检查3.如果对下一个类中有两个合法的选择,选择第一个父类
class A:
    def func(self):
        print("----A----")

class B(A):
    def func(self):
        print("----B----")

class C(A):
    def func(self):
        print("----B-----")

class D(B,C):
    pass

d = D()
d.func()

print(D.__mro__)
print(D.mro())

# ----B----
# (<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>)
# [<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>]
多继承中super本质不是直接查找父类,而是根据调用节点的广度优先顺序执行的练习:创建 A、B、C、D 类,D 类继承 B,C 类,B 类继承 A 类,C 类继承 A 类。在每个方法中都调用 super().func()方法,查看执行顺序。
class A:
    def func(self):
        print("----A----")

class B(A):
    def func(self):
        super(B, self).func()
        print("----B----")

class C(A):
    def func(self):
        super(C, self).func()
        print("----C-----")

class D(B,C):
    def func(self):
        super(D, self).func()
        print("----D-----")

d = D()
d.func()   # 继承顺序 D-->B-->C-->A

#结果:A,C,B,D
print(D.__mro__)
print(D.mro())
# (<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>)
# [<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>]
如图,B 继承 A, C 继承 A, D 继承 B 和 C。深度优先遍历是从 D 开始往上搜索到 B,若 B 没有数据,则继续往上搜索到 A;广度优先遍历是从 D 开始往上搜索到 B,若 B 没有数据,则搜索和 B 同级的 C 里的数据,若同级的 C 里还是没有数据,再继续往上搜索到 A 。Tips:py2 经典类是按深度优先来继承的,新式类是按广度优先来继承的。           py3 经典类和新式类都是统一按广度优先来继承的
class A:
    def func(self):
        print("----A----")

class B(A):
    def func(self):
        super(B, self).func()
        print("----B----")

class C(A):
    def func(self):
        super(C, self).func()
        print("----C-----")

class D(B):
    def func(self):
        super(D, self).func()
        print("----D-----")

class E(C):
    def func(self):
        super(E, self).func()
        print("----E-----")

class F(D, E):
    def func(self):
        super(F, self).func()
        print("----F-----")

f = F()
f.func()   # 继承顺序 D-->B-->C-->A

# ----A----
# ----C-----
# ----E-----
# ----B----
# ----D-----
# ----F-----
class A:
    def func(self):
        print("----A----")

class B(A):
    def func(self):
        super(B, self).func()
        print("----B----")

class C(A):
    def func(self):
        super(C, self).func()
        print("----C-----")

class D(C):
    def func(self):
        super(D, self).func()
        print("----D-----")

class E(B):
    def func(self):
        super(E, self).func()
        print("----E-----")

class G(B):
    def func(self):
        super(G, self).func()
        print("----G-----")

class H(A):
    def func(self):
        super(H, self).func()
        print("----H-----")

class F(D, E,G,H):
    def func(self):
        super(F, self).func()
        print("----F-----")

f = F()
f.func()

# ----A----
# ----H-----
# ----B----
# ----G-----
# ----E-----
# ----C-----
# ----D-----
# ----F-----
class A1: pass
class A2: pass
class A3: pass
class B1(A1,A2): pass
class B2(A2): pass
class B3(A2,A3): pass
class C1(B1): pass
class C2(B1,B2): pass
class C3(B2,B3): pass
class D(C1, C2, C3): pass

print("从D开始查找:")
for s in D.__mro__:
    print(s)

# 从D开始查找:
# <class ‘__main__.D‘>
# <class ‘__main__.C1‘>
# <class ‘__main__.C2‘>
# <class ‘__main__.B1‘>
# <class ‘__main__.A1‘>
# <class ‘__main__.C3‘>
# <class ‘__main__.B2‘>
# <class ‘__main__.B3‘>
# <class ‘__main__.A2‘>
# <class ‘__main__.A3‘># <class ‘object‘>

多态

面向对象三大特性: 封装、继承、多态

 1.封装:屏蔽提供细节,但提供调用方式,将功能封装成一个整体,提供简单的调用方式 2.继承:可以拥有另一个类的方法和属性 3.多态:让某个类呈现多种形态

实现多态的三个条件: 1.必须存在继承关系 2.重写目标方法  3.使用子类对象调用父类方法

定义人类,可以跳舞,可以玩,在玩的过程跳舞实现多态,老年人跳广场舞
class Person:
    def dance(self):
        print(‘跳舞‘)

    def play(self):
        self.dance()  #old.dance()

class Oldman(Person):
    def dance(self):
        print("跳广场舞")

old = Oldman()
old.play()

per = Person()
per.play()




原文地址:https://www.cnblogs.com/johnsonbug/p/12708027.html

时间: 04-15

Python3.x基础学习-类--多继承、多态的相关文章

Python3.x基础学习-类--类属性和实例属性

类属性和实例属性 定义: 实例属性:在实例对象中定义的属性类属性: 在类对象中定义的属性,并且多个实例对象共享一份类属性类属性使用方式:类名.类属性,也可以使用 对象.类属性注意: 1.不可变类型:对象名.属性名=属性值 是给对象添加属性,而不是进行修改 2. 可变类型:如果对象是修改可变数据类型变量中的数据,是真正的修改如果是重新给可变数据类型变量赋值,这是给该对象添加属性 class Dog: pass dog=Dog dog.name = '旺财' print(dog.name) dog.

【代码笔记】Java基础:类的继承(构造器)

在Java中,创建对象的格式为: 类名 对象名 = new 类名(): 如: 1 JFrame jf = new JFrame(); 一个对象被创建出来时,经常要先做一些事这个对象才能正常使用,也可以说是准备工作,比如给这个对象赋些初始值,或者先运行一些别的方法.这时候就需要一个“构造器”用于: 构造对象 初始化属性这样,把那些在创建时要做的事写在构造方法里,每次创建就会被执行一遍. 我们常见的一种Java格式: public 返回类型 方法名(参数){ } 如: 1 public void s

python面向对象编程基础II(类的继承)

继承一个类 继承的好处: 1.复用已有代码 2.自动拥有现有类的所有功能 3.只需要编写缺少的功能 如果已经定义了Person类,需要定义新的Student和Teacher类时,可以直接从Person类继承: class Person(object): def __init__(self, name, gender): self.name = name self.gender = gender 定义Student类时,只需要把额外的属性加上,例如score: class Student(Pers

Python学习-类的继承

1 继承: 2 #python2 经典类是按深度优先来继承的,新式类是按广度优先来继承的 3 #python3 经典类和新式类都是按广度优先来继承的 4 5 6 7 #经典类:class People: 8 class People(object): #这个是新式类,多继承的时候有了改变 9 10 def __init__(self, name, age): 11 self.name =name 12 self.age = age 13 14 15 def eat(self): 16 print

基础回顾:get方法和set方法(类的继承多态)

基础回顾:get方法和set方法 定义类成员变量时,可以在@interface中定义,也可以在@implementation中定义: 在@interface中声明,成员变量的状态是受保护的,即“@protected”: 在@implementation中声明,成员变量的状态是私有的,即“@private” 在类的外面,是无法直接访问成员变量的,只有将成员变量修改为@public时,才可以外部访问. 使用@public时,访问成员变量使用“->”,如: time->hour=25; 但使用@pu

Java基础学习之final和多态及类型转换

final关键字: final关键字是最终的意思,可以修饰类,成员变量,成员方法. ?    修饰类,类不能被继承 ?    修饰变量,变量就变成了常量,只能被赋值一次. ?    修饰方法,方法不能被重写 final关键字面试题 ?    final修饰局部变量 在方法内部,该变量不可以被改变,只可以赋值一次. 在方法声明上,分别演示基本类型和引用类型作为参数的情况 基本类型,是值不能被改变 引用类型,是地址值不能被改变.对象在堆内存的值是可以改变的. ?    final修饰变量的初始化时机

Python学习 Day 8 继承 多态 Type isinstance dir __slots__

继承和多态 在OOP程序设计中,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类.父类或超类(Base class.Superclass). >>> class Animal(object):#名为Animal的class defrun(self): print'Animal is running...' >>> class Dog(Animal):#从Animal类继承 pass

Java基础学习之(6)--继承+访问权限

一.继承的相关概念: B继承A可以描述为:B是一种A,B是一种A的继承关系,B从A继承. 子类自动拥有基类(父类)的所有成员(包括成员变量和成员方法). java只支持单继承,c++支持多继承,但是Java有多种语义存在.  child类中n_private=10是错的,因为子类拥有父类私有变量的访问权,但是没有使用权:即私有变量,只在父类对象中可以访问!!!  二.访问控制: 对象成员的权限有private,default,protected,public. 类的权限只有public,defa

黑马程序员---Objective-C基础学习---类、对象、方法相关知识笔记

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 类.对象.方法相关知识笔记 Objective-C相对于C语言有了面向对象的特性,但是ObjC又没有其他面向对象语言那么多语法特性,ObjC本身对面向对象进行了精简.下面是一些相关知识笔记. 类定义 成员变量 方法和属性 self关键字 类定义 在C#.Java等其他高级语言中定义一个类是相当简单点的,直接一个关键字class加一对大括号基本就完成了,但是在ObjC中类的定义相对变化比较大.现