元类及其相关

 什么是元类
    与普通类的区别
    有什么用
    如何使用

# code = """
# global s
# s = 1000
# a = 10
# print(a)
# """
#
# global_dic = {}
# local_dic = {}
#
# exec(code,global_dic,local_dic)
# print(global_dic)

# print(globals())
# print(local_dic)

# 要求你把你一个字符串中出现的名字 存储到一个名称空间中
# text = """
# def func():
#     print("func run")
# """
# l_dic = {}
# exec(text,{},l_dic)
# l_dic["func"]()

# """
#     什么是元类
#     一切皆对象
#
#
#     类的类就是元类
#     Person 类的元类是type   默认情况下所有类的元类都是type(object除外)
#
#
# """
# import abc  # 抽象类
#
# class Person(metaclass=type): # Person == type(..........)
#     def __init__(self,name,gender):
#         self.name = name
#         self.gender = gender
#
#     def say_hi(self):
#         print("hello im am %s  gender is %s" % (self.name,self.gender))
#
# p = Person("xx","xxx")
# # p.say_hi()
#
# # 函数对象
# # ls = [Person]
# # print(ls[0])
# #
# # def f1(cls):
# #     print(cls)
# #
# # f1(Person)
#
# print(type(p))
# print(type(Person)) # Person类是有type实例化产生的
#
#
# # 一个类需要包含三个部分
# # 类名称  它的父类 名称空间
#
# class_name = "myclass"
# class_bases = (object,)
# class_namespace = {}
#
# code = """
# school = "xxx"
# def hello(self):
#     print(self)
# """
#
# exec(code,{},class_namespace)
# print(class_namespace)
#
# # 创建类的另一种方式
# # 自己来实例化type类
# obj = type(class_name,class_bases,class_namespace)

# type类中肯定有__init__方法
#

class MyMetaClass(type):
    # 创建类时 就会自动执行元类中的init方法
    def __init__(self,class_name,bases,namespace):
        print("MyMetaClass init run")

# 产生一个空的类对象 在调用MyMetaClass中的__init__方法
class ClassA(metaclass=MyMetaClass): # ClassA = type("ClassA",(,),{})

    def __init__(self,name):
        self.name = name

# 创建出一个CLassA的类对象

class Test:
    def __init__(self):
        pass

t = Test() #实例化
# 1.创建一个对象的名称空间    空对象
# 2.执行__init__方法来为对象赋初始值

 

 

元类中init方法的执行:
class A:
    pass

# print(A)
# print(type(A))

namespace = {}
namespace["name"] = "jack"

cls = type("这是一个实例化Type产生的类",(object,),namespace)
#
# print(cls.name)
# print(A)

# 一个类是通过实例化type类产生
# 元类就是用于产生类的类

# 自定义一个元类
# class MyMeta(type):
#     # 创建B这个类对象的时候回自动执行
#     def __init__(self,a,b,c):
#         print("MyMeta init run")
#         print(self)
#         print(a)
#         print(b)
#         print(c)
#         self.school = "xxx"
#
# class B(metaclass=MyMeta): # B = MyMeta(B,"B",(object,),{......})
#     pass
#
# print(B.school)
#

# 必须保证类名大写开头
# class Meta1(type):
#     def __init__(self,clas_name,bases,namespace):
#         if not clas_name.istitle():
#             raise  TypeError("类名必须大写开头!")
# # 命名方式  大驼峰
# class person(metaclass=Meta1):
#     pass

class Meta2(type):
    def __init__(self,cls_name,bases,namespace):
        if not self.__doc__:
            raise  TypeError("必须包含类注释!!")

        super().__init__(cls_name,bases,namespace)

#
# 请编写代码 完成  限制一个类必须拥有类注释 否则 不允许创建类
class Animal(metaclass=Meta2):
    """
    asas
    """
    pass

print(Animal.__doc__)
print(Animal)

 

 

__call__方法的执行时机:

__call__
会在某个时间自动执行

class MyMeta(type):
    # 会在类对象 准备实例化产生对象时执行
    # 该函数可以控制实例化对象的过程
    def __call__(self, *args, **kwargs):
        print("Mymeta call run!")
        # print(self)
        # print(args)
        # print(kwargs)

        #无论你要添加什么功能  只要覆盖了__call__  就必须把下面两个步骤做了
        #1.需要创建一个对象
        obj = object.__new__(self)
        #2.调用对应init来初始化这个对象
        self.__init__(obj,*args,**kwargs)
        return obj

        # super().__call__(*args,**kwargs)

class Student(metaclass=MyMeta):
    def __init__(self,name):
        self.name = name
    pass

s = Student("xxx") # 是为了创建并实例化一个Student类的对象
print(s)

#__init__ 创建类对象的时候执行  控制类的创建过程

#__call__ 实例化产生对象时执行  控制对象的创建过程    单例模式

 

单例模式:

单例模式
    一种设计模式,MVVM MVC MTV
    常推荐书籍见设计模式

    要保证一个类只能有一个实例(单例)

    为什么这么设计?
        目的是为了节省内存开销
        如果两个对象的数据一模一样  就没有必要创建新对象  直接使用已有的即可

    场景:
        当一个类的所有实例数据都完全相同时 则应该设计为单例
        音乐播放器类 实例化产生播放器对象

    单例的实现方式:
        自定义元类 覆盖__cal__  添加判断逻辑 保证只能实例化一个对象

class MySingleton(type):
    obj = None
    def __call__(self, *args, **kwargs):
        if not self.obj:
            # 创建空对象
            obj = object.__new__(self)
            # 调用初始化方法
            self.__init__(obj, *args, **kwargs)
            self.obj = obj
        return self.obj

class Player(metaclass=MySingleton):
    # 默认为空
    obj = None

    def __init__(self):
        print("创建了一个播放器对象....")

    def play(self,path):
        self.stop()
        print("playing...",path)

    def stop(self):
        print("stop music")

    # 用于获取播放器对象
    @classmethod
    def get_player(cls):
        if not cls.obj:
            print("创建播放器...")
            cls.obj = cls()
        return  cls.obj

# p = Player("给我一杯忘情水.mp3")
# p.play()
#
#
# p.stop()
# p1 = Player("回首掏.mp3")
# p1.play()

# p = Player()
# p.play("一杯忘情水.")
#
#
p1 = Player.get_player()
p1.play("爱你一万年1.")

p2 = Player.get_player()
p2.play("爱你一万年2.")

# 上述代码 有bug  可以通过直接调用类 来产生新对象
Player().play("我的滑板鞋!")
 

 

存在元类时的属性查找顺序:

类自身属性 -->  父类--> object--> type

# class Meta(type):
#     s = 1000
#
#
# class A:
#     s = 1
#     pass
# class B(A,metaclass=Meta):
#     # s = 2
#     pass
#
# b = B()
# # b.s = 3
#
# print(b.s)
class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    n=444

class Bar(object):
    # n = 333
    pass
class Foo(Bar):
    # n=222
    pass
class Teacher(Foo,metaclass=Mymeta):
    # n=111
    pass
print(Teacher.n)