python 30 面向对象之 多态

Posted Francis

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python 30 面向对象之 多态相关的知识,希望对你有一定的参考价值。

1,mixins机制

多继承的正确打开方式:mixins机制
mixins机制核心:就是在多继承背景下尽可能地提升多继承的可读性
ps:让多继承满足人的思维习惯=》什么"是"什么

使用Mixin类实现多重继承要非常小心

首先它必须表示某一种功能,而不是某个物品,python 对于mixin类的命名方式一般以 Mixin, able, ible 为后缀
其次它必须责任单一,如果有多个功能,那就写多个Mixin类,一个类可以继承多个Mixin,为了保证遵循继承的“is-a”原则,只能继承一个标识其归属含义的父类
然后,它不依赖于子类的实现
最后,子类即便没有继承这个Mixin类,也照样可以工作,就是缺少了某个功能。(比如飞机照样可以载客,就是不能飞了)


class Vehicle:
    pass

class FlyableMixin:
    def fly(self):
        pass

class CivilAircraft(FlyableMixin,Vehicle):  # 民航飞机
    pass

class Helicopter(FlyableMixin,Vehicle):  # 直升飞机
    pass

class Car(Vehicle):  # 汽车并不会飞,但按照上述继承关系,汽车也能飞了
    pass

补充:通常Mixin结果的类放在左边

2,子类派生的新方法中重用父类的功能

方式一:指名道姓调用某一个类下的函数=》不依赖于继承关系


class OldboyPeople:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def f1(self):
        print(‘%s say hello‘ %self.name)


class Teacher(OldboyPeople):
    def __init__(self,name,age,sex,level,salary):
        OldboyPeople.__init__(self,name,age,sex)

        self.level = level
        self.salary=salary

tea_obj=Teacher(‘egon‘,18,‘male‘,10,3000)
print(tea_obj.__dict__)

方式二:super()调用父类提供给自己的方法=》严格依赖继承关系
调用super()会得到一个特殊的对象,该对象会参照发起属性查找的那个类的mro,去当前类的父类中找属性

    
class OldboyPeople:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def f1(self):
        print(‘%s say hello‘ %self.name)


class Teacher(OldboyPeople):
    def __init__(self,name,age,sex,level,salary):
        # super(Teacher,self).__init__(name,age,sex)
        super().__init__(name,age,sex) # 调用的是方法,自动传入对象

        self.level = level
        self.salary=salary

print(Teacher.mro())
tea_obj=Teacher(‘egon‘,18,‘male‘,10,3000)
print(tea_obj.__dict__)

super()案例


class A:
    def test(self):
        print(‘from A‘)
        super().test()

class B:
    def test(self):
        print(‘from B‘)

class C(A,B):
    pass


obj=C()
obj.test()

print(C.mro())

3, 面向对象之--多态

1、什么多态:同一事物有多种形态


class Animal:
    pass

class People(Animal):
    pass

class Dog(Animal):
    pass

class Pig(Animal):
    pass

2、为何要有多态=》多态会带来什么样的特性,多态性
多态性指的是可以在不考虑对象具体类型的情况下而直接使用对象
class Animal: # 统一所有子类的方法

    def say(self):
        print(‘动物基本的发声频率。。。‘,end=‘ ‘)

class People(Animal):
    def say(self):
        super().say()
        print(‘嘤嘤嘤嘤嘤嘤嘤‘)

class Dog(Animal):
    def say(self):
        super().say()
        print(‘汪汪汪‘)

class Pig(Animal):
    def say(self):
        super().say()
        print(‘哼哼哼‘)

定义统一的接口,接收传入的动物对象

def animal_say(animal):
    animal.say()

animal_say(obj1)
animal_say(obj2)
animal_say(obj3)


print(‘hello‘.__len__())
print([1,2,3].__len__())
print({‘a‘:1,‘b‘:2}.__len__())

def my_len(val):
    return val.__len__()

print(my_len(‘hello‘))
print(my_len([1,2,3]))
print(my_len({‘a‘:1,‘b‘:2}))

len(‘hello‘)
len([1,2,3])
len({‘a‘:1,‘b‘:2})
  • python推崇的是鸭子类型
class Cpu:
    def read(self):
        print(‘cpu read‘)

    def write(self):
        print(‘cpu write‘)

class Mem:
    def read(self):
        print(‘mem read‘)

    def write(self):
        print(‘mem write‘)


class Txt:
    def read(self):
        print(‘txt read‘)

    def write(self):
        print(‘txt write‘)

了解:基类--强制统一父类标准

import abc

class Animal(metaclass=abc.ABCMeta): # 统一所有子类的标准
    @abc.abstractmethod
    def say(self):
        pass

obj=Animal() # 不能实例化抽象类自己

class People(Animal):
    def say(self):
        pass

class Dog(Animal):
    def say(self):
        pass

class Pig(Animal):
    def say(self):
        pass

4,一些内置函数的介绍

print(abs(-1)) #取绝对值
print(all([1,‘aaa‘,‘1‘])) #循环可迭代对象,所有的布尔值都为真才返回True
print(all([])) #循环可迭代对象,如果是空的则返回True

print(any([0,None,1])) #循环可迭代对象,任意一个布尔值为真返回True
print(any([]))  #循环可迭代对象,如果是空的则返回False

print(bin(11)) #十进制转2进制
print(oct(11)) #十进制转8进制
print(hex(11)) #十进制转16进制

print(bool(‘‘))

def func():
    pass
class Foo:
    pass
print(callable(Foo)) # 判断是否可被调用

print(chr(65)) #数字转asc码
print(ord(‘A‘))#asc码转数字

不可变集合
s=frozenset({1,2,3})

hash(不可变类型)

print(round(1.5))
print(round(1.4))


10 ** 2 % 3
print(pow(10,2,3))
s=slice(1,4,2)
l1=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
l2=[‘aaa‘,‘bbb‘,‘ccc‘,‘ddd‘,444]

print(l1[1:4:2]) # l1[s]
print(l2[1:4:2]) # l2[s]


=================》掌握
v1=‘hello‘
v2=[111,222,333,444,5555,6666]
res=zip(v1,v2)
print(list(res))

=================》掌握
print(divmod(10000,33))

=================》掌握
class Foo:
    pass
obj=Foo()
obj.xxx=1111
print(dir(obj)) # obj.哪些属性

=================》掌握
for i,v in enumerate([‘a‘,‘b‘,‘c‘]):
    print(i,v)

=================》掌握
res=eval(‘{"a":1}‘) # 执行字符串中的表达式
print(res,type(res))


=================》掌握
class Foo:
    pass
obj=Foo()
print(isinstance(obj,Foo))
print(isinstance([],list)) # 类型判断推荐使用isinstance
print(type([]) is list) # 不推荐使用

=================》掌握
import ‘time‘ # 错误
time=__import__(‘time‘)
time.sleep(3)

以上是关于python 30 面向对象之 多态的主要内容,如果未能解决你的问题,请参考以下文章

Python面向对象之:三大特性:继承,封装,多态。

19.Python面向对象之:三大特性:继承,封装,多态。

Python3-2020-测试开发-20- 面向对象之封装,继承,多态

python之面向对象中的多态

python基础--面向对象之多态

Python进阶(十六)----面向对象之~封装,多态,鸭子模型,super原理(单继承原理,多继承原理)