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)