深入理解Python元类（原创）

最新推荐文章于 2024-09-08 10:23:20 发布
最新推荐文章于 2024-09-08 10:23:20 发布
阅读量1.4w 收藏 138
点赞数 34
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a2011480169/article/details/87891753
版权

同样效果的代码：

    def __init__(cls,cls_name,cls_bases,cls_dict):
        type.__init__(cls,cls_name,cls_bases,cls_dict)

    def __new__(cls, cls_name, cls_bases,cls_dict):
        return type.__new__(cls,cls_name,cls_bases,cls_dict)

    def __call__(self, *args, **kwargs):
        return type.__call__(self,*args,**kwargs)

创造对象的方法：obj = object.__new__(cls)

Python内置函数参考：

 

http://www.runoob.com/python/python-built-in-functions.html　 

https://www.cnblogs.com/coder2012/p/4309999.html

https://www.cnblogs.com/elie/p/6685429.html

https://blog.csdn.net/yugongpeng_blog/article/details/45868909

@在一个类的内部，__new__当中的第一个参数cls就是所在类的类的名字，__init__当中的第一个参数self就是所在类创建的对象的名

字，__call__当中的第一个参数self就是所在类创建的对象的名字。

2018年8月6日19:30:09

刚一接触面向对象元类的时候，我就懵逼了，真的，那是一种无助的懵逼。

当然，我们需要先理清一下思路，先看看什么是元类：

在Python当中万物皆对象，我们用class关键字定义的类本身也是一个对象，负责产生该对象的类称之为元类，元类可以简称为类的类，

元类的主要目的是为了控制类的创建行为.

type是Python的一个内建元类，用来直接控制生成类，在python当中任何class定义的类其实都是type类实例化的结果。

只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类，自定义元类可以控制类的产生过程，类的产生过程其实就是元类

的调用过程.

看到这，你明白了点没，没错，我们每天看到的class XXX这个XXX就是由元类实例化产生的，在Python当中，创建一个类其实有两种方

式，这个让我想起了Scala.

一个类由三大组成部分，分别是

1、类名class_name

2、继承关系class_bases

3、类的名称空间class_dict

方式1：使用class关键字（python解释器转化为第二种）

方式2：通过type关键字，依次传入以上三个参数即可。

听到这里，你先别蒙圈，我们正常定义类是这样写的：

class Person(object):
    country = 'China'
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def tell(self):
        print('%s 的年龄是:%s'%(self.name,self.age))

当然，我们可以通过第二种方式创建类：

#!/usr/bin/python
# -*- coding:utf-8 -*-


country = 'China'
def __init__(self,name,age):
    self.name = name
    self.age = age

def tell(self):
    print('%s 的年龄是:%s'%(self.name,self.age))

Person = type('Person',(object,),{'country':country,
                                  '__init__':__init__,
                                  'tell':tell})

print(Person.__dict__)
person = Person('wtt',25)
print(person.__dict__)

OK，大家看到了吧，Person类实际上就是一个类对象，于是我们将产生类的类称之为元类，默认的元类是type.

 

默认情况下，我们所说的元类都是指type这个元类，但是用户是可以自定义元类的，只要继承type就可以，如下所示：

#!/usr/bin/python
# -*- coding:utf-8 -*-


class MyMetaClass(type):
    pass

country = 'China'
def __init__(self,name,age):
    self.name = name
    self.age = age

def tell(self):
    print('%s 的年龄是:%s'%(self.name,self.age))

Person = MyMetaClass('Person',(object,),{'country':country,
                                  '__init__':__init__,
                                  'tell':tell})

print(Person.__dict__)
person = Person('wtt',25)
print(person.__dict__)

当然，我们也可以用这种日常的形式：

#!/usr/bin/python
# -*- coding:utf-8 -*-


class MyMetaClass(type):
    pass

class Person(object,metaclass=MyMetaClass): #自定义元类,来创建类.
    country = 'China'
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def tell(self):
        print('%s 的年龄是:%s'%(self.name,self.age))

print(Person.__dict__)
person = Person('wtt',25)
print(person.__dict__)

到现在为止，对于元类稍微了解了，为了能够顺利讲下去，我们先介绍一个__new__这个方法，之所以要讲这个，是因为我和你一样：

我开始的时候以为Python当中__init__方法就是Java当中的构造方法，其实不是这样子的，在Python当中，当我们实例化一个对象的时

候，最先调用的并不是__init__方法，而是这个__new__方法。

代码示例：

#!/usr/bin/python
# -*- coding:utf-8 -*-



class Student(object):
    def __new__(cls, *args, **kwargs):
        """这个相当于Java当中的构造函数"""
        print(cls)   #注意:第一个参数就是类本身
        print('---------new--------------')
        obj = super().__new__(cls)
        print(obj)
        print(obj.__dict__)
        return obj

    def __init__(self, name, age):
        """创建完实例对象之后,才会调用__init__."""
        print(self)
        print('------------init----------')
        self.name = name
        self.age = age


student = Student('wtt',30)

运行结果示例：

<class '__main__.Student'>
---------new--------------
<__main__.Student object at 0x00000000021C9C88>
{}
<__main__.Student object at 0x00000000021C9C88>
------------init----------

Process finished with exit code 0

正如代码所示：__new__创造出了对象，但是这个对象是空的，名称空间的装备需要通过__init__来完成。

之前我已经介绍过了，元类的主要目的是为了为了控制类的创建行为，但是到现在还没有见到元类到底有什么高逼格的用途！！，不要着

急，我们先来一个实例场景：

要求：利用元类的知识，保证用户设计的类必须有文档注释，不能为空 ，同时要求在一个类内部定义的所有函数必须有文档注释，不能为

空。

 

#!/usr/bin/python
# -*- coding:utf-8 -*-

"""利用元类:第一:类必须有文档注释,不能为空 第二:在一个类内部定义的所有函数必须有文档注释,不能为空.(这个很通用)"""

# !/usr/bin/python
# -*- coding:utf-8 -*-

"""利用元类:第一:类必须有文档注释,不能为空 第二:在一个类内部定义的所有函数必须有文档注释,不能为空.(这个很通用)"""


class MyMetaClass(type):
    def __init__(self, cls_name, cls_bases, cls_dict):
        print(self)    #<class '__main__.Person'>
        """注意:self.__dict__传进来的时候类的名称空间不是空的."""
        print(self.__dict__) #{'__init__': <function Person.__init__ at 0x0000000002946268>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Person' objects>, 'tell_info': <function Person.tell_info at 0x00000000029462F0>, 'country': 'China', '__doc__': '\n    元类.\n    ', '__dict__': <attribute '__dict__' of 'Person' objects>}
        if '__doc__' not in cls_dict or len(cls_dict['__doc__'].strip()) == 0:
            raise TypeError('类:%s 必须有文档注释,并且注释不能为空.' % cls_name)
        for key, value in cls_dict.items():
            if key.startswith('__'):
                continue
            if not callable(value):
                continue
            if not value.__doc__ or len(value.__doc__.strip()) == 0:
                raise TypeError('函数:%s 必须有文档注释,并且文档注释不能为空.' % (key))

        super().__init__(cls_name, cls_bases, cls_dict)  # 重用父类的功能.


class Person(object, metaclass=MyMetaClass):  # 这一行: Person = MyMetaClass('Person',(object,),{...})
    """
    元类.
    """
    country = 'China'

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

    def tell_info(self):
        """
        绑定方法.
        """
        print('%s 的年龄是:%s' % (self.name, self.age))

 

因为刚才我们已经介绍了__init__和__new__的区别了，所以我们也可以在__new__当中直接做手脚.

#!/usr/bin/python
# -*- coding:utf-8 -*-

"""利用元类:第一:类必须有文档注释,不能为空 第二:在一个类内部定义的所有函数必须有文档注释,不能为空.(这个很通用)"""



class MyMetaClass(type):
    def __new__(cls, cls_name, cls_bases, cls_dict):
        print(cls)  #注意:<class '__main__.MyMetaClass'>
        if '__doc__' not in cls_dict or len(cls_dict['__doc__'].strip()) == 0:
            raise TypeError('类:%s 必须有文档注释,并且注释不能为空.' % cls_name)
        for key, value in cls_dict.items():
            if key.startswith('__'):
                continue
            if not callable(value):
                continue
            if not value.__doc__ or len(value.__doc__.strip()) == 0:
                raise TypeError('函数:%s 必须有文档注释,并且文档注释不能为空.' % (key))
        obj =  super().__new__(cls,cls_name,cls_bases,cls_dict)
        print(obj)  #<class '__main__.Person'>  创建出来的就是Person类,是我们需要的.
        return obj




class Person(object,metaclass=MyMetaClass):  #这一行: Person = MyMetaClass('Person',(object,),{...})
    """
    元类.
    """
    country = 'China'

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

    def tell_info(self):
        """
        绑定方法.
        """
        print('%s 的年龄是:%s'%(self.name,self.age))

OK，到这里你是否懂了呢，还不懂，OK，那我在写一步，你肯定会懂的。

#!/usr/bin/python
# -*- coding:utf-8 -*-

"""利用元类:第一:类必须有文档注释,不能为空 第二:在一个类内部定义的所有函数必须有文档注释,不能为空.(这个很通用)"""



class MyMetaClass(type):
    def __new__(cls, cls_name, cls_bases, cls_dict):
        print(cls)  #注意:<class '__main__.MyMetaClass'>
        if '__doc__' not in cls_dict or len(cls_dict['__doc__'].strip()) == 0:
            raise TypeError('类:%s 必须有文档注释,并且注释不能为空.' % cls_name)
        for key, value in cls_dict.items():
            if key.startswith('__'):
                continue
            if not callable(value):
                continue
            if not value.__doc__ or len(value.__doc__.strip()) == 0:
                raise TypeError('函数:%s 必须有文档注释,并且文档注释不能为空.' % (key))
        obj =  super().__new__(cls,cls_name,cls_bases,cls_dict)
        print(obj)  #<class '__main__.Person'>  创建出来的就是Person类,是我们需要的.
        print('--------名称空间------')
        print(obj.__dict__)
        return obj

    def __init__(self,cls_name, cls_bases, cls_dict):
        print(self)   #<class '__main__.Person'>
        #接下来我们初始化这个对象
        super().__init__(cls_name,cls_bases,cls_dict)



class Person(object,metaclass=MyMetaClass):  #这一行: Person = MyMetaClass('Person',(object,),{...})
    """
    元类.
    """
    country = 'China'

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

    def tell_info(self):
        """
        绑定方法.
        """
        print('%s 的年龄是:%s'%(self.name,self.age))

但是有个地方我不是太懂，为什么在__new__中打印出来的名称空间不是空的呢??，现在能想到的就是继承的类是type导致的，而且在最

开始__init__打印的时候也是这个样子的。

其实核心就是下面这个图：

 

简化版：

#!/usr/bin/python
# -*- coding:utf-8 -*-

class MyMeta(type):
    n = '测试'
    def __new__(cls, *args, **kwargs):
        print(cls)   #<class '__main__.MyMeta'>
        obj = super().__new__(cls,*args,**kwargs)
        print(obj.__dict__)
        #{'__weakref__': <attribute '__weakref__' of 'Student' objects>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__init__': <function Student.__init__ at 0x00000000025162F0>, 'country': 'China', '__module__': '__main__', '__doc__': None, 'say': <function Student.say at 0x0000000002516378>}
        print(obj)
        #<class '__main__.Student'>
        return obj

    def __init__(self,class_name,class_bases,class_dic):
        print(self) #<class '__main__.Student'>
        super().__init__(class_name,class_bases,class_dic)



class Student(object,metaclass=MyMeta):  #Student = MyMeta('Student',(object,),{....})
    country = 'China'
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def say(self):
        print('%s 的年龄是:%s'%(self.name,self.age))

上面我们讲的这些可以用几句话来进行概括：元类对类创建行为的影响。　

 

 接下来我们要讲的是元类对类实例化行为的影响。

 但是在讲之前，我们需要介绍一下__call__，不然没法写下去了。

内置函数__call__的用法:

一个可调用的对象加括号，就是触发这个对象所在的类中的__call__方法的执行，一个对象可以加括号意味着产生这

个对象对应的类里面肯定含有__call__方法，

反之要想让某个对象变成一个可调用的对象，需要在该对象的类中定义一个方法__call__方法。

 是不是有点听不懂，不要着急，举个例子：

#!/usr/bin/python
# -*- coding:utf-8 -*-

class Student(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __call__(self, *args, **kwargs):
        print(args)
        print(kwargs)


student = Student('wtt',25)
"""如果没有__call__：TypeError: 'Student' object is not callable"""
print(callable(student))
student(10,20,30,40)  #一个可调用的对象加括号,就是触发这个对象所在类中的__call__方法的执行.

总之一句话：一个可调用的对象加括号,就是触发这个对象所在类中的__call__方法的执行.

在这里我们可以细想一下，由元类造出的这些类之所以可以加上（）被调用，肯定是因为元类当中也存在着__call__方法，OK，先上一个

例子在说。

#!/usr/bin/python
# -*- coding:utf-8 -*-

class MyMetaClass(type):
    pass


class Person(object, metaclass=MyMetaClass):  # 这一行: Person = MyMetaClass('Person',(object,),{...})

    country = 'China'

    def __init__(self, name, age):
        print('-----Person--init-----')
        self.name = name
        self.age = age

    def tell_info(self):
        print('%s 的年龄是:%s' % (self.name, self.age))

print(callable(Person))
person = Person('wtt',25)   #Person这个类之所以可以被调用,肯定是因为造出Person的类：MyMetaClass当中含有__call__方法.
print(person.__dict__)

在上面的例子当中，我们来重写一下MyMetaClass当中__call__方法，你会发现一个很有意思的事情。

#!/usr/bin/python
# -*- coding:utf-8 -*-

class MyMetaClass(type):
    def __call__(cls, *args, **kwargs):
        print(cls)
        return 666

class Person(object, metaclass=MyMetaClass):  # 这一行: Person = MyMetaClass('Person',(object,),{...})

    country = 'China'

    def __init__(self, name, age):
        print('-----Person--init-----')
        self.name = name
        self.age = age

    def tell_info(self):
        print('%s 的年龄是:%s' % (self.name, self.age))

print(callable(Person))
person = Person('wtt',25)   #Person这个类之所以可以被调用,肯定是因为造出Person的类：MyMetaClass当中含有__call__方法.
print(person)

运行结果：

True
<class '__main__.Person'>
666

Process finished with exit code 0

OK，你是不是已经发现了什么，没错：

一个可调用的对象加上()的返回值就是这个对象所在类中的__call__方法的返回值.

 到这里，你可能会懵逼，我去，说好的Person对象呢，怎么返回一个666呢，到这里就将到了重点：

在Python当中，简述__call__,__new__,__init__三者之间的关系

在类实例化的过程当中，哪个对象加()就寻找产生这个对象的类的__call__方法，只要是__call__方法，一定会做三件事情：

第一：调用__new__方法，构造新的对象，相当于Java当中的构造函数.（对象自己的__new__）

第二：调用__init__方法,去初始化这个对象（对象自己的__init__）

第三：返回这个对象.

注意:__new__更像是其他语言当中的构造函数，必须有返回值，返回值实例化的对象，__init__只是初始化构造函数，必须没有返回

值，仅仅只是初始化功能，并不能new创建对象.

也就是说,一个类在实例化的时候实际上是做了三件事情：

第一：触发元类中（造出这个类的类）的__call__方法

第二：通过__new__产生一个空对象

第三：通过__init__初始化这个对象

第四：返回这个对象

 OK，到这里我写一个完整的例子你就彻底懂了。

#!/usr/bin/python
# -*- coding:utf-8 -*-

class MyMetaClass(type):
    def __call__(cls, *args, **kwargs):
        print('--自动触发元类当中的__call__方法---')
        #调用__new__产生一个空对象obj
        obj = cls.__new__(cls)
        print(obj)
        print(obj.__dict__)   #此时名称空间为空.
        #调用__init__初始化这个对象.
        cls.__init__(obj,*args,**kwargs)
        #返回初始化的对象
        print(obj.__dict__)

        return obj



class Person(object, metaclass=MyMetaClass):  # 这一行: Person = MyMetaClass('Person',(object,),{...})

    country = 'China'

    def __init__(self, name, age):
        print('-----Person--init-----')
        self.name = name
        self.age = age

    def tell_info(self):
        print('%s 的年龄是:%s' % (self.name, self.age))

    def __new__(cls, *args, **kwargs):
        print('---------new--------')
        return super().__new__(cls)


print(callable(Person))
person = Person('wtt',25)   #Person这个类之所以可以被调用,肯定是因为造出Person的类：MyMetaClass当中含有__call__方法.
print(person)

运行结果：

True
--自动触发元类当中的__call__方法---
---------new--------
<__main__.Person object at 0x0000000001F6D390>
{}
-----Person--init-----
{'name': 'wtt', 'age': 25}
<__main__.Person object at 0x0000000001F6D390>

Process finished with exit code 0　　

   老铁，我在给你导入一张图片：

从图片上面我们是不是理解了很多了呢？类在实例化对象的时候函数的调用顺序依次是__call__==>__new__==>__init__.

到这里你是否感觉元类很高级：既可以控制创建类的行为，也可以控制类的实例化行为。

但是这么牛逼的功能有什么用途呢，不着急，咱么接着先举一个例子试一试：

要求：利用元类，在元类中控制自定义的类产生的对象的相关的属性全部为隐藏属性

#!/usr/bin/python
# -*- coding:utf-8 -*-


"""利用元类:将一个对象的所有属性都变成私有的"""

class MyMeta(type):
    def __call__(cls, *args, **kwargs):
        obj = cls.__new__(cls,*args,**kwargs)
        cls.__init__(obj,*args,**kwargs)

        #这个对象本来构造并初始化完毕了,但是我们不立即进行返回,而是进行进一步的操作:
        obj.__dict__ = {'_%s__%s'%(cls.__name__,key):value for key,value in obj.__dict__.items()}
        print(obj.__dict__)

        return obj


class Student(object,metaclass=MyMeta):
    country = 'China'

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

    def tell_info(self):
        print('%s的姓名是:%s'%(self.name,self.age))


    def __new__(cls, *args, **kwargs):
        return super().__new__(cls)



student = Student('wtt',25)
print(student.__dict__)
print(student._Student__name,student._Student__age)

运行结果示例：

{'_Student__name': 'wtt', '_Student__age': 25}
{'_Student__name': 'wtt', '_Student__age': 25}
wtt 25

Process finished with exit code 0

方法2：

#!/usr/bin/python
# -*- coding:utf-8 -*-




class MyMetaClass(type):
    def __new__(cls,cls_name,cls_bases,cls_dict):
        return type.__new__(cls,cls_name,cls_bases,cls_dict)


    def __init__(cls,cls_name,cls_bases,cls_dict):
        """这个类没有什么用."""
        pass

    def __call__(cls, *args, **kwargs):
        obj = cls.__new__(cls,*args,**kwargs)
        cls.__init__(obj,*args,**kwargs)
        obj_dict = obj.__dict__
        obj.__dict__ = {}
        for key,value in obj_dict.items():
            setattr(obj,'_%s__%s'%(cls.__name__,key),value)

        return obj





class Student(object,metaclass=MyMetaClass):

    country = 'China'
    langage = 'Chinese'

    def __init__(aa,name,age):
        aa.name = name
        aa.age = age

    def __teach(self):
        pass

student = Student('wtt',35)
print(student.__dict__)

看着是不是很牛掰，现在我们稍微总结一下完整代码：

#!/usr/bin/python
# -*- coding:utf-8 -*-


"""

def __call__(cls, *args, **kwargs):
    obj = cls.__new__(cls,*args,**kwargs)
    cls.__init__(obj,*args,**kwargs)
    return obj

"""


class MyMeta(type):
    """用来控制类的创建行为."""
    def __init__(self,cls_name,cls_bases,cls_dict):
        super().__init__(cls_name,cls_bases,cls_dict)

    def __new__(cls, *args,**kwargs):
        return super().__new__(cls,*args,**kwargs)

    
    """用来控制类的实例化行为."""
    def __call__(cls, *args, **kwargs):
        obj = cls.__new__(cls,*args,**kwargs)
        cls.__init__(obj,*args,**kwargs)

        obj.__dict__ = { '_%s__%s'%(cls.__name__,key):value for key,value in obj.__dict__.items()}
        print(obj.__dict__)
        return obj

class Student(object,metaclass=MyMeta):   #Student = MyMeta('Student',(object,),{...})
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def tell(self):
        print('%s 的基本信息是:%s'%(self.name,self.age))


    def __new__(cls, *args, **kwargs):
        return super().__new__(cls)


student = Student('wtt',25)

　　

接下来我们上一个更牛X的例子，通过元类来实现单例模式，直接看我的博客吧。

https://www.cnblogs.com/zhangmingyang/p/9439882.html

 

到这里我们在可以总结一下__new__和__init__的关系：

官方文档是如此说明的

If __new__() does not return an instance of cls, then the new instance’s __init__() method will not be invoked.

当__new__函数没有返回这个类的实例时，__init__函数不会被调用，其实也容易理解，__init__需要类实例self参数，而__new__没有返

回一个类实例，这样的话__init__自然无法运行。

OK ，我们在来感受一下元类的强大：

要求：在元类中控制把自定义类的数据属性都变成大写。

代码示例：

#!/usr/bin/python
# -*- coding:utf-8 -*-

"""在元类中控制把自定义类的数据属性都变成大写"""

class MyMeta(type):
    def __new__(cls, cls_name,cls_bases,cls_dict):
        cls_new_dict = {}
        for key,value in cls_dict.items():
            if callable(value) or key.startswith('__'):
                cls_new_dict[key] = value
            else:
                cls_new_dict[key.upper()] = value

        cls_new_dict['salary'] = '呵呵哒.'

        return super().__new__(cls,cls_name,cls_bases,cls_new_dict)

    def __init__(cls,cls_name,cls_bases,cls_dict):
        """在这里你会发现cls即Student这个类(对象)的数据属性已经被初始化完了,看来元类的_new_比普通强大."""
        for key,value in cls.__dict__.items():
            print(key,value)
        """cls_dict你会发现和我们想的不一样(应该等于cls_new_dict),看来元类不一样啊."""
        print('&'*60)
        print(cls_dict)
        super().__init__(cls_name,cls_bases,cls_dict)


class Student(object,metaclass=MyMeta): #Student = MyMeta('Student',(object,),{...})

    country = 'China'
    age = 35

    def __init__(self,name,age):
        print(self)
        print(self.__dict__)
        self.name = name
        self.age = age


    def tell(self):
        print('%s 的姓名是:%s'%(self.name,self.age))

print('-'*30)
for key,value in Student.__dict__.items():
    print(key,value)

运行结果：

salary 呵呵哒.
__module__ __main__
__doc__ None
tell <function Student.tell at 0x0000000002916378>
COUNTRY China
__weakref__ <attribute '__weakref__' of 'Student' objects>
__dict__ <attribute '__dict__' of 'Student' objects>
AGE 35
__init__ <function Student.__init__ at 0x00000000029162F0>

Process finished with exit code 0

在这里我有一个疑问：本来我之前的代码是按照下面写的，但是没有生效：

#!/usr/bin/python
# -*- coding:utf-8 -*-

"""在元类中控制把自定义类的数据属性都变成大写"""


class MyMeta(type):
    def __init__(cls,cls_name,cls_bases,cls_dict):
        """疑问1:cls作为一个对象竟然有属性了????"""
        cls_dict_new = {}
        for key,value in cls_dict.items():
            if callable(value) or key.startswith('__'):
                cls_dict_new[key] = value
            else:
                cls_dict_new[key.upper()] = value
        for key,value in cls_dict_new.items():
            print(key,value)

        cls_dict_new['salary'] = '呵呵哒'
        """疑问2:修改完之后传进去没有生效.??"""
        super().__init__(cls_name,cls_bases,cls_dict)



class Student(object,metaclass=MyMeta): #Student = MyMeta('Student',(object,),{...})

    country = 'China'
    age = 35

    def __init__(self,name,age):
        print(self)
        print(self.__dict__)
        self.name = name
        self.age = age


    def tell(self):
        print('%s 的姓名是:%s'%(self.name,self.age))


print('-'*30)
for key,value in Student.__dict__.items():
    print(key,value)

运行结果：

__init__ <function Student.__init__ at 0x00000000021C6268>
__module__ __main__
COUNTRY China
AGE 35
__qualname__ Student
tell <function Student.tell at 0x00000000021C62F0>
------------------------------
age 35
__init__ <function Student.__init__ at 0x00000000021C6268>
country China
__module__ __main__
__dict__ <attribute '__dict__' of 'Student' objects>
__weakref__ <attribute '__weakref__' of 'Student' objects>
tell <function Student.tell at 0x00000000021C62F0>
__doc__ None

Process finished with exit code 0

我这里是这么猜测的，普通类的__new__用来创造空对象，__init__用来初始化对象，但是元类的__new__把这两个活都干了，__init__没有什么用！！！

后来没有办法，我采用了下面的方法：

#!/usr/bin/python
# -*- coding:utf-8 -*-

"""在元类中控制把自定义类的数据属性都变成大写"""


class MyMeta(type):
    def __init__(cls,cls_name,cls_bases,cls_dict):
        for key,value in cls.__dict__.items():
            if callable(value) or key.startswith('__'):
                pass
            else:
                key_new = key.upper()
                """删除cls对应的属性值,不能用del"""
                delattr(cls,key)
                """为cls属性值重新赋值,不能用cls."""
                setattr(cls,key_new,value)


        super().__init__(cls_name,cls_bases,cls_dict)

class Student(object,metaclass=MyMeta): #Student = MyMeta('Student',(object,),{...})

    country = 'China'
    age = 35

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

    def tell(self):
        print('%s 的姓名是:%s'%(self.name,self.age))

for key,value in Student.__dict__.items():
    print(key,value)

运行结果：

__weakref__ <attribute '__weakref__' of 'Student' objects>
tell <function Student.tell at 0x00000000029162F0>
__init__ <function Student.__init__ at 0x0000000002916268>
__doc__ None
COUNTRY China
AGE 35
__dict__ <attribute '__dict__' of 'Student' objects>
__module__ __main__

Process finished with exit code 0

最后在来一道题，装X技能：　

要求:

在元类中控制自定义的类无需__init__方法

1.元类帮其完成创建对象，以及初始化操作

2.要求实例化时传参必须为关键字形式，否则抛出异常TypeError: must use keyword argument

3.key作为用户自定义类产生对象的属性，且所有属性变成大写

代码示例：呵呵，这这道题告诉我们，元类控制着根本啊，根本没用到__init__方法。

#!/usr/bin/python
# -*- coding:utf-8 -*-

'''
在元类中控制自定义的类无需__init__方法
1.元类帮其完成创建对象，以及初始化操作
2.要求实例化时传参必须为关键字形式，否则抛出异常TypeError: must use keyword argument
3.key作为用户自定义类产生对象的属性，且所有属性变成大写
'''


class MyMeta(type):
    def __call__(cls, *args, **kwargs):
        if args:
            raise  TypeError('must use keyword argument')
        obj = cls.__new__(cls,*args,**kwargs)
        for key,value in kwargs.items():
            setattr(obj,key.upper(),value)
            #obj.__dict__[key.upper()]=v
        return obj



class Student(object,metaclass=MyMeta):
    def __new__(cls, *args, **kwargs):
        return super().__new__(cls)

    def tell(self):
        print('%s 的信息是:%s'%(self.NAME,self.AGE))

student = Student(name='wtt',age=25)
student.tell()

　　

 

 

 

 

 

 

 

 

一只懒得睁眼的猫
关注
专栏目录
Python元类详解
既然选择远方，便只顾风雨兼程！
10-22 3203
Python从设计之初就是一门面向对象的语言，它有一个重要的概念，即一切皆对象。Python与java的区别：Java虽然也是面向对象编程的语言，但是血统没有Python纯正。比如Java的八种基本数据类型之一int，在持久化的时候，就需要包装成Integer类对象。但是在python中，一切皆对象。数字、字符串、元组、列表、字典、函数、方法、类、模块等等都是对象，包括你的代码。MetaClass元类，本质也是一个类，但和普通类的用法不同，它可以对类内部的定义（包括类属性和类方法）进行动态的修改。
你真的创建过类吗？——Python类创建流程深入解读
W-H2099的博客
04-16 544
你真的创建过类吗？——Python类创建深入解读 类 是OOP（面向对象编程）的核心概念，更是 Python 中不可或缺的一部分。 日常中，我们天天都在用 Python 中的类，貌似类的相关内容已经没有什么新奇的了，可是，你真的 创建 过类吗？ 通常，我们所做的不过是用 class 来 声明 一个类，而后利用它来 创建实例对象。 那么，具体的类创建 又是如何完成的呢？ 在整理并深入研究了大量 PEP、Python Reference及相关博文的基础上，作者将通过本文解读 **Python 类创建的具体过程。
Python面试题：使用Python进行元编程：元类和元编程技巧
bigorsmallorlarge的专栏
07-19 1078
元类: 用于创建和修改类的定义，是高级的元编程技术。通过自定义元类，可以控制类的创建过程和行为。装饰器: 用于修改函数或类的行为而无需直接修改它们的代码。可以在函数或类定义之前通过装饰器添加功能。描述符: 用于控制对对象属性的访问，通过实现__get____set__和__delete__方法来实现。动态属性和方法: 使用setattr和getattr可以动态地添加或修改对象的属性和方法。类工厂函数: 动态创建类，并根据需求生成不同的类定义。
python中的元类（metaclass）
最新发布
7huaping的专栏
09-08 823
在 Python 中，元类（metaclass）是用来创建类的 “东西”。
Python中的元类
weixin_34236869的博客
08-25 110
万物皆对象，在Python也是这样，类也是对象，但是Python不像Java这样有反射，Python有元类，元类就是创建类的类。 既然类也是对象，所以你可以对类进行如下操作。 　　1.你可以将它赋值给一个变量 　　2.你可以拷贝它 　　3.你可以为它增加属性 　　4.你可以将它作为函数参数进行传递 　　5.可以像创建对象一样，动态的创建类 1.type的使用。说明：当只有一个参数的时候，代表判断参...
Python元类
weixin_30352191的博客
12-06 390
新式类 　　新式类统一了类和类型，如果obj是新式类的实例，则type(obj)等同于obj.__class__ >>> class Foo: ... pass >>> obj = Foo() >>> obj.__class__ <class '__main__.Foo'> >&...
python的元类
qq_21294095的博客
12-21 247
元类从概念上理解是不难的，仅从字面上去理解，当初学数据库的时候，就知道有元数据这么个东西，那么元数据是什么？元数据就是用来描述数据库的数据。那么一样的道理，类是什么？类是创建对象用的，那么元类就是创建类用的。 一，先来看type方法 class Lan(object): def run(self): print('run...') l = Lan() print(t...
Python 元类
Keivn_666
03-16 1497
一、元类是什么？ 定义理解： Python中一切皆为对象，对象是有类实例化生成； 类也是对象（类对象），生成类对象的类可称之为元类； 所以，元类就是来创建类对象的，可称之为类工厂； type是python内建元类，type是最上层的元类，也可称为一切类对象的元类； 常见对象如str, int等，其__class__属性都是type，class 的__class__ 也是type。 type也可动态创建类 二、元类设置 metaclass 属性 在声明一个类时可以使用 metaclass class F
python-tkinter.messagebox 整蛊人的代码 可运行 原创
02-17
Python的Tkinter库是Python标准库中的一个GUI（图形用户界面）工具包，它提供了丰富的控件和功能，包括创建...在娱乐编程或教学场景下，利用这个模块可以设计出有趣的整蛊代码，同时也能够加深对Python GUI编程的理解。
import sys是什么意思_深入理解Python中import机制
weixin_39932300的博客
11-22 2266
大型项目中为了维护方便，通常使用模块化开发，模块化的过程中，就会涉及到各种包或者模块的相互导入，即使是对于有多个项目的Python开发者来说，import也会让人困惑！本文带你深入了解python中import的内在机制，从而避免import导入引发的异常。概念模块(module)任何.py文件都可以称为模块包(package)可以将多个模块放入一个包中，就像电脑中的文件夹，但与文件夹的...
python入门课程ppt（原创）
01-10
"13-基本类型：字符串(1).pptx"和"16-容器类型：列表和元组（1）.pptx"深入讲解了Python的基础数据类型。字符串是处理文本信息的基本工具，而列表和元组则是存储和操作数据的重要容器。理解它们的特性和操作方法是...
Python源码学习笔记：深入认识Python内建类型——int
xiaoli_Jenny的博客
04-28 1478
“深入认识Python内建类型”这部分的内容会从源码角度为大家介绍Python中各种常用的内建类型。本篇博客是关于int的源码分析。
Python的元类
qq_38380338的博客
03-17 951
有关于元类方面一些常用知识。
python中的元类
瑞瑞的博客
03-29 941
在Python中，一切皆对象，包括基本数据类型（如整数、字符串）、函数、模块等。每个对象都有一个类型来描述它是什么。类型不仅定义了对象可以进行哪些操作，还规定了对象占用的内存大小以及布局方式。自定义一个元类型主要涉及继承自type并重写其__new__或者__init__方法来控制如何创建或初始化新型态（即新建立一个class）。# 定义一个名为 Meta 的元素, 继承自 type# 这是一个类的类。print('__new__方法，创建一个类！不是实例！类名：', name)
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一只懒得睁眼的猫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值