Mixins机制
多继承的正确打开方式:mixins机制

mixins机制核心:就是在多继承背景下尽可能地提升多继承的可读性

  Python提供了Mixins机制,简单来说Mixins机制指的是子类混合(mixin)不同类的功能,而这些类采用统一

的命名规范(例如Mixin后缀),以此标识这些类只是用来混合功能的,并不是用来标识子类的从属"is-a"关系

的,所以Mixins机制本质仍是多继承。

复制代码
class Vehicle:  # 交通工具
    pass


class FlyableMixin:
    def fly(self):
        '''
        飞行功能相应的代码        
        '''
        print("I am flying")


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


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


class Car(Vehicle):  # 汽车
    pass
复制代码
  可以看到,上面的CivilAircraft、Helicopter类实现了多继承,不过它继承的第一个类我们起名为FlyableMixin,

而不是Flyable,这个并不影响功能,但是会告诉后来读代码的人,这个类是一个Mixin类,表示混入(mix-in),

这种命名方式就是用来明确地告诉别人(python语言惯用的手法),这个类是作为功能添加到子类中,而不

是作为父类,它的作用同Java中的接口。所以从含义上理解,CivilAircraft、Helicopter类都只是一个Vehicle,

而不是一个飞行器。

 

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

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

7、在子类派生的新方法中如何重用父类的功能
方式一:指名道姓调用某一个类下的函数,不依赖于继承关系

复制代码
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) # python2中的用法
        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()  # 按发起属性查找的mro顺序,此时会将B当作A的父类


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


class C(A, B):
    pass


obj = C()
obj.test()

print(C.mro())

  

多态
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('哼哼哼')


obj1=People()
obj2=Dog()
obj3=Pig()


obj1.say()
obj2.say()
obj3.say()

# 定义统一的接口,接收传入的动物对象
def animal_say(animal):
    animal.say()

animal_say(obj1)
animal_say(obj2)
animal_say(obj3)
复制代码
鸭子类型
  我们完全可以不依赖于继承,只需要制造出外观和行为相同对象,同样可以实现不考虑对象类型而

使用对象,这正是Python崇尚的“鸭子类型”(duck typing)。

复制代码
#Cpu和Mem二者看起来都像文件,因而就可以当文件一样去用,然而它们并没有直接的关系
class Cpu:  #Cpu类也有两个与文件类型同名的方法:read和write
    def read(self):
        print('cpu read')

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

class Mem: #Mem类也有两个与文件类型同名的方法:read和write
    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): # 统一所有子类的标准,所有子类中都必须有say方法,否则报错
    @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

obj1=People()
obj2=Dog()
obj3=Pig()

  

绑定方法
一:绑定方法:特殊之处在于将调用者本身当做第一个参数自动传入

  1、绑定给对象的方法:调用者是对象,自动传入的是对象

  2、绑定给类的方法:调用者类,自动传入的是类

复制代码
class Mysql:
    def __init__(self,ip,port):
        self.ip=ip
        self.port=port

    def func(self):
        print('%s:%s' %(self.ip,self.port))

    @classmethod # 将下面的函数装饰成绑定给类的方法
    def from_conf(cls):
        print(cls)
        return cls(settings.IP, settings.PORT)


obj2=Mysql.from_conf()
print(obj2.__dict__)
复制代码
非绑定方法
  为类中某个函数加上装饰器@staticmethod后,该函数就变成了非绑定方法,也称为静态方法。该方法不

与类或对象绑定,类与对象都可以来调用它,但它就是一个普通函数而已,因而没有自动传值。

复制代码
class Mysql:
    def __init__(self,ip,port):
        self.nid=self.create_id()
        self.ip=ip
        self.port=port

    @staticmethod # 将下述函数装饰成一个静态方法
    def create_id():
        import uuid
        return uuid.uuid4()

    @classmethod
    def f1(cls):
        pass

    def f2(self):
        pass

  

内置函数
掌握一

v1='hello'
v2=[111,222,333,444,5555,6666]
res=zip(v1,v2)
print(list(res))

结果[('h', 111), ('e', 222), ('l', 333), ('l', 444), ('o', 5555)]
掌握二

print(divmod(10000,33)) # 相当于10000行内容,一页33行,需要多少页

结果(303, 1)   #前者相当于整数部分,后者是余数
掌握三

class Foo:
    pass
obj=Foo()
obj.xxx=1111
print(dir(obj)) # obj.哪些属性,查看obj中的属性
掌握四

复制代码
for i,v in enumerate(['a','b','c']):
    print(i,v)

结果(取出可迭代对象的索引及值)
0 a
1 b
2 c
复制代码
掌握五

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

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

# import 'time' # 错误
time=__import__('time') # 可以将time模块传给任意变量调用
time.sleep(3)

x=__import__('sys')
print(x.path)