python基础篇--day12

继承

所有的类都继承了Object类，
目的: 简化代码，提高代码的可读性

单继承

继承会继承父类的所有公有函数和变量

class father:
    money = 1000  # 父类的类属性
    __gril = "女"  # 父类的私有变量

    def __init__(self):
        self.gender = "男"

    def smoke(self):
        print("吸烟有害健康，所以老子吸烟")


class son(father):
    pass


s = son()
print(s.money)  # 能把父类公有的钱继承过来
s.smoke()  # 父类方法也会继承
print(s.__gri)  # 私有不继承，AttributeError: 'son' object has no attribute '__gri'

私有变量不被继承

class Father:
    def __init__(self):
        self.__a = 10
        self.b = 8

    def show(self):
        r = self.__a + self.b # 用的是父类里面的__a
        print('运算结果是:', r)


class Son(Father):
    def __init__(self):
        Father.__init__(self)
        self.__a = 100


s = Son()
s.show() # 输出18

多层继承

经典类：
旧式类的MRO算法是采用深度优先搜索
经典类构造函数重复执行多次。

新式类 ：
新式类都会继承object
新式类相同父类只执行一次构造函数
新式类的MRO(method resolution order 基类搜索顺序)算法采用C3算法广度优先搜索
print(F.mro) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性 F代表最低的子类

class father:
    def fun(self):
        print("祖宗")


class A(father):
    def fun(self):
        print("A")

class B(father):
    def fun(self):
        print("B")

class A1(A):
    def fun(self):
        print("A1")
class A2(A):
    def fun(self):
        print("A2")

class B1(B):
    def fun(self):
        print("B1")
class B2(B):
    def fun(self):
        print("B2")

class C(A2,B1):
    def fun(self):
        print("C")


print(C.__mro__)

重写

父类的方法不能满足于子类的需求，在子类中定义一个与父类相同名的函数(参数也要一致)

• 子类调用父类的方法：
  1. 父类.方法名(self)
  2. super(子类名，self).方法名()

类装饰器

元类

当你用解释器去创建一个类的时候，这个类会调用元类去创建它。

type():用来构建一切类型的一个类

type(对象) ---->返回当前对象的类型

type(name,bases,attrs) --> name:类名 bases：保存所有父类 attrs 字典 类里面的数据和方法

自定义元类：

 class xxx(type):
    def __new__(cls,name,bases,attrs):
        do something
        ....
        return type.__new__(cls,name,bases,attrs)
        
 class Student(父类,metaclass=xxx):
     pass

class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        print(name)
        print(bases)
        print(attrs)
        attrs['b'] = 'world'
        if attrs.get('test'):
            attrs.pop('test')
        return type.__new__(cls, name, bases, attrs)


class MyList(object, metaclass=ListMetaclass):
    a = 'hello'

    def test(self):
        print('---->test')


l = MyList()
print(l)
print(l.a)
# print(l.b)
l.test()

单例类

单例是一种设计模式，在某种应用模式下只能实例化一个对象，而不会产生多个对象。

# 普通方式
class Person:
    __instance = None

    def __new__(cls, *args, **kwargs):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls, *args, **kwargs)
        return cls.__instance

    def __init__(self):
        print('---->init')


p1 = Person()
p2 = Person()
p3 = Person()

print(id(p1))
print(id(p2))
print(id(p3)) # 三个的地址都一样

# 装饰器实现单例
class cls_decorator:
    def __init__(self, f):
        self.f = f
        self.__instance = {}

    def __call__(self, *args, **kwargs):
        if self.f not in self.__instance:
            self.__instance[self.f] = self.f()   # self.f = Singleton   Singleton()
        return self.__instance[self.f]  # {'Singleton':<Singleton object at 0x00000000022205F8>}


@cls_decorator  # 1.cls = cls_decorator()  2. Singleton = cls
class Singleton:
    def __init__(self):
        print('---->Singleton init')


print(Singleton)
s1 = Singleton()  # cls()
s2 = Singleton()

print(s1 is s2) # True