元类type

内置的元类：type ,它是所有类对象的类！

一个类对象没有声明它的元类，那么它的默认元类就是type .

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

if __name__ == "__main__":
    demo  = DemoClass("tom")
    print(type(demo))
    print(type(DemoClass))
'''
输出：
<class '__main__.DemoClass'>
<class 'type'>  #类对象的类型都是type
'''

我们能够通过继承type 来自定义元类，然后其他类对象创建的时候就可以用metaclass 来指定自定义元类。

类对象的创建流程：（用自定义元类创建类对象）

class Mymeta(type):  #自定义元类
    def __init__(self,class_name,class_bases,class_dict):
        super().__init__(class_name,class_bases,class_dict) #重用父类的init
        print(class_name,"
================")
        print(class_bases,"
================")
        print(class_dict,"
================")

        if class_name.islower():
            raise TypeError("类对象名{}请修改为驼峰式".format(class_name))

        if '__doc__' not in class_dict or len(class_dict['__doc__'].strip('
'))==0:
            raise TypeError("类中要有注释，且注释不能为空")
#类对象的创建
#DemoClass = Mymeta(name,(object,),{})
class DemoClass(metaclass=Mymeta):  #这时类对象DemoClass 的类就不是type而是Mymeta了
    '''
    DemoClass 的注释
    '''
    def __init__(self,name):
        self.name = name

'''
    输出：
    DemoClass 
    ================
    () 
    ================
    {'__module__': '__main__', '__init__': <function DemoClass.__init__ at 0x00000144C9943B70>, '__doc__': '
    DemoClass 的注释
    ', '__qualname__': 'DemoClass'} 
    ================
'''

我们知道 类对象+（） 会触发元类中的__call__（）方法，

class Mymeta(type):  #自定义元类
    def __init__(self,class_name,class_bases,class_dict):
        super().__init__(class_name,class_bases,class_dict) #重用父类的init

        if class_name.islower():
            raise TypeError("类对象名{}请修改为驼峰式".format(class_name))

        if '__doc__' not in class_dict or len(class_dict['__doc__'].strip('
'))==0:
            raise TypeError("类中要有注释，且注释不能为空")
    def __call__(self, *args, **kwargs):
        print(args,kwargs)


#类对象的创建
#DemoClass = Mymeta(name,(object,),{})
class DemoClass(metaclass=Mymeta):  #这时类对象DemoClass 的类就不是type而是Mymeta了
    '''
    DemoClass 的注释
    '''
    def __init__(self,name):
        self.name = name
if __name__ == "__main__":
    DemoClass("tom") #DemoClass 其实是个类对象，然后它加() 会调用__call__

'''
    输出：
    ('tom',) {}
'''

默认的类对象 实例化的过程会做三件事：

1、产生一个空对象obj

2、调用__init__方法初始化对象obj

3、返回初始化好的obj

所以，我们也自己加上这三件事：

class Mymeta(type):  #自定义元类
    def __init__(self,class_name,class_bases,class_dict):
        super().__init__(class_name,class_bases,class_dict) #重用父类的init
        print("1")
        if class_name.islower():
            raise TypeError("类对象名{}请修改为驼峰式".format(class_name))

        if '__doc__' not in class_dict or len(class_dict['__doc__'].strip('
'))==0:
            raise TypeError("类中要有注释，且注释不能为空")
    #产生类对象之后，加括号会调__call__
    def __call__(self, *args, **kwargs):
        print(id(self))
        # 1,产生空对象
        obj = self.__new__(self)  #self是类对象DemoClass 不是demo ,obj 才是demo
        # 2，调用类对象的init

        print("2")
        self.__init__(obj,*args,**kwargs)
        print("4")
        print(args,kwargs)
        #,3 返回obj
        return obj

#类对象的创建
#DemoClass = Mymeta(name,(object,),{})
class DemoClass(metaclass=Mymeta):  #这时类对象DemoClass 的类就不是type而是Mymeta了
    '''
    DemoClass 的注释
    '''

    def __init__(self,name):  #__init__() 是类对象的属性，所以在元类__call__中，self才能调它.
        print("3")
        self.name = name
if __name__ == "__main__":
    demo =  DemoClass("tom") #DemoClass 其实是个类对象，然后它加() 会调用__call__
    print(id(DemoClass))
'''
    输出：
    1
    1817911787480
    2
    3
    4
    ('tom',) {}
    1817911787480
'''

所以，demo = DemoClass("tom") 这个过程不是自动的调init() 而是先调__call__() 然后，在__call__中会回头调的init() 。

属性查找：

class Mymeta(type):  #只有继承type 才是自定义元类，否则是普通的类
    n = 100
    def __call__(self, *args, **kwargs):
        obj = self.__new__(self)
        self.__init__(obj,*args,**kwargs)
        return obj

class Demo1(object):  #继承object
    n  =200

class Demo2(Demo1):
    n = 300

class Demo3(Demo2,metaclass=Mymeta):
    n = 400

    def __init__(self,name):
        self.name = name
print(Demo3.n)
#查找n 的顺序：
#先类对象层 ：Demo3 ->Demo2-->Demo1-->object
#再元类层： Mymeta -->type 


# 注：object 也是个类对象
print(type(object))
#<class 'type'>

下面是产生obj的方法  类对象的方法__new__ 的查找：

class Mymeta(type):  #只有继承type 才是自定义元类，否则是普通的类
    n = 100
    def __call__(self, *args, **kwargs):
        obj = self.__new__(self)
        print(self.__new__ is object.__new__)

class Demo1(object):  #继承object
    n  =200
    # def __new__(cls, *args, **kwargs):
    #     print("Demo1_new")
class Demo2(Demo1):
    n = 300
    # def __new__(cls, *args, **kwargs):
    #     print("Demo1_new")
class Demo3(Demo2,metaclass=Mymeta):
    n = 400

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

Demo3("tom")
'''
    输出：True
'''

结论：Mymeta下的__call__里的self.__new__在Demo3、Demo2、Demo1里都没有找到__new__的情况下，会去找object里的__new__，而object下默认就有一个__new__，所以即便是之前的类均未实现__new__,也一定会在object中找到一个，根本不会、也根本没必要再去找元类Mymeta->type中查找__new__

在元类的__call__中也可以用object.__new__(self)去造对象

但还是推荐在__call__中使用self.__new__（self）去创造空对象，因为这种方式会检索三个类Demo3->Demo2->Demo1,而object.__new__则是直接跨过了他们三个

 补：

class Mymeta(type):  #只有继承type 才是自定义元类，否则是普通的类
    n = 100
    def __new__(cls, *args, **kwargs):
        obj = type.__new__(cls,*args,**kwargs) #必须按照这样传值 cls 为类对象
        print(obj.__dict__)
        #return obj #只有返回obj 才会调下面的init 
        return 123
    def __init__(self,class_name,class_bases,class_dict):
        print("run....")
#Demo = Mymeta()
class Demo(object,metaclass=Mymeta):
    n  = 200

    def __init__(self,name):
        self.name = name
#产生类对象Demo 的过程就是在调Mymeta ,而Mymeta 也是type类的一个对象，
#那么Mymeta 之所以可以调用，一定是因为元类type中有一个__call__方法

# class type:
#     def __call__(self, *args, **kwargs): #self=<class '__main__.Mymeta'>
#         obj=self.__new__(self,*args,**kwargs) # 产生Mymeta的一个对象
#         self.__init__(obj,*args,**kwargs) 
#         return obj

class Mymeta(type):  #只有继承type 才是自定义元类，否则是普通的类
    n = 100
    def __new__(cls, *args, **kwargs):
        obj = type.__new__(cls,*args,**kwargs) #cls 是Mymeta这个类对象
        print(obj.__dict__)
        return obj
        
    def __init__(self,class_name,class_bases,class_dict):
        print("run....")

#把自定义的数据属性都变成大写
class Demo(object,metaclass=Mymeta):
    n  = 200
    def __init__(self,name):
        self.name = name

demo  = Demo("tom")  #这会找到type 中的__call__方法
'''
type 中的方法应该是：
# class type:
#     def __call__(self, *args, **kwargs): #self=<class '__main__.Mymeta'>
#         obj=self.__new__(self,*args,**kwargs) # 产生Mymeta的一个对象
#         self.__init__(obj,*args,**kwargs) 
#         return obj
'''
print(demo.n)

 练习1：将类属性变为全大写：

class Mymeta(type):  #只有继承type 才是自定义元类，否则是普通的类
    def __new__(cls, class_name,class_bases,class_dict):  #type中的__call__ 会调它
        update_attrs = {}
        for k,v in class_dict.items():
            if not callable(v) and not k.startswith('__'):
                update_attrs[k.upper()]=v
            else:
                update_attrs[k] =v
        return type.__new__(cls,class_name,class_bases,update_attrs)#生成的Demo对象

#把类中的数据属性都变成大写
class Demo(object,metaclass=Mymeta):
    name = "tom"
    age = 18
    def test(self):
        pass

print(Demo.__dict__)
'''
输出：{'__weakref__': <attribute '__weakref__' of 'Demo' objects>, '__module__': '__main__', 'AGE': 18, 'test': <function Demo.test at 0x000002C156163B70>, '__doc__': None, 'NAME': 'tom', '__dict__': <attribute '__dict__' of 'Demo' objects>}
'''

练习二：类中无需__init__方法：

class Mymeta(type):  #只有继承type 才是自定义元类，否则是普通的类
    def __call__(self, *args, **kwargs):
        if args:
            raise TypeError("必须以键值对传参")
        obj = object.__new__(self)

        for k,v in kwargs.items():
            obj.__dict__[k.upper()] = v
        return obj

class DemoClass(metaclass=Mymeta):
    salary = 1000
    def test(self):
        pass


p = DemoClass(name = "tom",age = 18)
print(p.__dict__)
print(DemoClass.__dict__)
'''
{'AGE': 18, 'NAME': 'tom'}
{'salary': 1000, '__module__': '__main__', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'DemoClass' objects>, '__dict__': <attribute '__dict__' of 'DemoClass' objects>, 'test': <function DemoClass.test at 0x000002B2B3A03BF8>}
'''

class Mymeta(type):  #只有继承type 才是自定义元类，否则是普通的类
    def __call__(self, *args, **kwargs):
        print(args,kwargs)
        if args:
            raise TypeError("必须以键值对传参")
        obj = object.__new__(self)

        for k,v in kwargs.items():
            obj.__dict__[k.upper()] = v
        return obj

class DemoClass(object,metaclass=Mymeta):
    salary = 1000
    def test(self):
        pass
p = DemoClass(18,name = "tom",age = 18,)
print(p.__dict__)
print(DemoClass.__dict__)
'''
Traceback (most recent call last):
(18,) {'name': 'tom', 'age': 18}
  File "C:/Users/Administrator/Desktop/test/m1/testtest.py", line 16, in <module>
    p = DemoClass(18,name = "tom",age = 18,)
  File "C:/Users/Administrator/Desktop/test/m1/testtest.py", line 5, in __call__
    raise TypeError("必须以键值对传参")
TypeError: 必须以键值对传参
'''

三：属性设置为隐藏属性：

class Mymeta(type):
    def __call__(self, *args, **kwargs):
        obj = self.__new__(self)
        self.__init__(obj,*args,**kwargs)
        obj.__dict__ ={"_{}__{}".format(self.__name__,k):v for k,v in obj.__dict__.items() }
        return obj

class DemoClass(object,metaclass=Mymeta):
    def __init__(self,name,age,sex):
        self.name = name
        self.age= age
        self.sex = sex


obj=DemoClass('tom',18,'male')
print(obj.__dict__)
setattr(obj,"salary",15054)
print(obj.__dict__)
'''
{'_DemoClass__age': 18, '_DemoClass__sex': 'male', '_DemoClass__name': 'tom'}
{'_DemoClass__age': 18, '_DemoClass__sex': 'male', '_DemoClass__name': 'tom', 'salary': 15054}
'''

参考博客：https://www.cnblogs.com/linhaifeng/articles/8029564.html