Python学习——元类

元类

MetaClass（元类），元类创建了Python中所有的对象。简单的理解，就是创建类的类，即创建类之后，再由类来创建实例进行应用。使用元类可以在创建类时动态修改类定义。为了使用元类动态修改类定义，程序需要先定义元类。简单理解为：元类就是用来创建类的东西

注意，不要从字面上去理解元类的含义，事实上，MetaClass 中的 Meta 这个词根，起源于希腊语词汇 meta，包含“超越”和“改变”的意思。

在python 中 类同样表示一种对象，这个对象拥有创建对象（创建实例）的能力， 它本质是一个对象，于是乎，可以对它做如下操作

1、可以将它赋值给一个变量
2、可以拷贝它
3、可以为它增加属性
4、可以将他作为函数的属性传递

动态创建类

因为类也是对象，所以可以再运行的时候创建他们，就像其他任何对象一样，可以在函数中创建类，使用关键字即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def create_class(name):
    if name == "foo":
        class Foo(object):  # 当使用class关键字时，Python解释器自动创建这个对象。
            pass
        return Foo  # 返回的是类  不是实例
    else:
        class Bar():
            pass
        return Bar

myClass = create_class("foo")
print(myClass)  # <class '__main__.create_class.<locals>.Foo'>
my = myClass()  # 创建实例对象
print(my)  # <__main__.create_class.<locals>.Foo object at 0x0000022B9C5AA390>

type 回顾

查看类型

1
2
3
4
5
6
7
8
9
10
11
12
13
print(type(1))   # <class 'int'>
print(type("aaa")) # <class 'str'>
print(type(myClass)) # <class 'type'>   
print(type(my)) #<class '__main__.create_class.<locals>.Foo'>
# 可以发现  type(myClass) 的类型为 type    继续测试
class aaa(object):
    pass
class bbb(object):
    pass
print(type(aaa)) # <class 'type'>
print(type(bbb)) # <class 'type'>

# 可以发现 通过 type 查看所有的类的类型  都是 type 类型

type 的另一个作用

动态创建类

type可以接受一个类的描述作为参数，返回一个类

格式：type(类名,由父类名称组成的元祖(针对继承的情况 可以为空),包含属性的字典(名称和值))

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
ccc = type("Ccc",(),{"name":"chase"})
print(ccc) # <class '__main__.Ccc'>
print(ccc().name)   # chase
print(type(ccc))  # <class 'type'>
help(ccc)  # 使用help 查看ccc类  输出结果如下

"""
Help on class Ccc in module __main__:

class Ccc(builtins.object)
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  name = 'chase'
"""

使用创建带由父类的示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
ccc = type("Ccc",(),{"name":"chase"})
ddd = type("Ddd",(ccc,),{})  # type中的第二个参数是父类的引用名称，不是字符串
class Eee(object):
    eName = "EEE"
    pass
fff = type("Fff",(Eee,),{"name":"FFF"})
print(fff.eName) # EEE
print(fff.name)  # FFF
help(fff)
"""
Help on class Fff in module __main__:

class Fff(Eee)
 |  Method resolution order:
 |      Fff
 |      Eee
 |      builtins.object
 |  
 |  Data and other attributes defined here:
 |  
 |  name = 'FFF'
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Eee:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from Eee:
 |  
 |  eName = 'EEE'
"""

使用type 创建带有方法的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
def run(self):
    print("实例方法")

@staticmethod
def static_run():
    print("静态方法")

@classmethod
def class_run(cls):
    print("类方法，name为：%s" % cls.name)

Foo = type("Foo",(),{"name":"fooName","run":run,"static_run":static_run,"class_run":class_run})
foo = Foo()
foo.run() # 实例方法
foo.static_run() # 静态方法
Foo.class_run() # 类方法，name为：fooName
help(Foo)
"""
Help on class Foo in module __main__:

class Foo(builtins.object)
 |  Methods defined here:
 |  
 |  run(self)
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  class_run() from builtins.type
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  static_run()
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  name = 'fooName'
"""

type 元类

函数type实际上是一个元类。type就是Python在背后用来创建所有类的元类。

元类就是创建类这种对象的东西。type就是Python的内建元类，当然了，你也可以创建自己的元类。

__metaclass__属性

当执行如下代码时间

1
2
class Foo(Bar):
    pass

Python做了如下的操作：

1、Foo中有__metaclass__这个属性吗？如果是，Python会通过__metaclass__创建一个名字为Foo的类(对象)

2、如果Python没有找到__metaclass__，它会继续在Bar（父类）中寻找__metaclass__属性，并尝试做和前面同样的操作。

3、如果Python在任何父类中都找不到__metaclass__，它就会在模块层次中去寻找__metaclass__，并尝试做同样的操作。

4、如果还是找不到metaclass,Python就会用内置的type来创建这个类对象。

自定义元类

元类的主要目的就是为了当创建类时能够自动地改变类。

网上摘抄的一个例子

假想一个很傻的例子，你决定在你的模块里所有的类的属性都应该是大写形式。有好几种方法可以办到，但其中一种就是通过在模块级别设定__metaclass__。采用这种方法，这个模块中的所有类都会通过这个元类来创建，我们只需要告诉元类把所有的属性都改成大写形式就万事大吉了。

幸运的是，__metaclass__实际上可以被任意调用，它并不需要是一个正式的类。所以，我们这里就先以一个简单的函数作为例子开始。

来源：网络

  • python2 中
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    #-*- coding:utf-8 -*-
    def upper_attr(class_name, class_parents, class_attr):

        # class_name 会保存类的名字 Foo
        # class_parents 会保存类的父类 object
        # class_attr 会以字典的方式保存所有的类属性

        # 遍历属性字典，把不是__开头的属性名字变为大写
        new_attr = {}
        for name, value in class_attr.items():
            if not name.startswith("__"):
                new_attr[name.upper()] = value

        # 调用type来创建一个类
        return type(class_name, class_parents, new_attr)

    class Foo(object):
        __metaclass__ = upper_attr # 设置Foo类的元类为upper_attr
        bar = 'bip'

    print(hasattr(Foo, 'bar'))
    print(hasattr(Foo, 'BAR'))

    f = Foo()
    print(f.BAR)
  • python3中
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    def upper_attr(class_name, class_parents, class_attr):

        #遍历属性字典，把不是__开头的属性名字变为大写
        new_attr = {}
        for name,value in class_attr.items():
            if not name.startswith("__"):
                new_attr[name.upper()] = value

        #调用type来创建一个类
        return type(class_name, class_parents, new_attr)

    class Foo(object, metaclass=upper_attr):
        bar = 'bip'

    print(hasattr(Foo, 'bar')) # False
    print(hasattr(Foo, 'BAR')) # True
    f = Foo()
    print(f.BAR) # bip
  • 用一个真正的class来当做元类。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    class UpperAttrMetaClass(type):
        # __new__ 是在__init__之前被调用的特殊方法
        # __new__是用来创建对象并返回之的方法
        # 而__init__只是用来将传入的参数初始化给对象
        # 你很少用到__new__，除非你希望能够控制对象的创建
        # 这里，创建的对象是类，我们希望能够自定义它，所以我们这里改写__new__
        # 如果你希望的话，你也可以在__init__中做些事情
        # 还有一些高级的用法会涉及到改写__call__特殊方法，但是我们这里不用
        def __new__(cls, class_name, class_parents, class_attr):
            # 遍历属性字典，把不是__开头的属性名字变为大写
            new_attr = {}
            for name, value in class_attr.items():
                if not name.startswith("__"):
                    new_attr[name.upper()] = value

            # 方法1：通过'type'来做类对象的创建
            return type(class_name, class_parents, new_attr)

            # 方法2：复用type.__new__方法
            # 这就是基本的OOP编程，没什么魔法
            # return type.__new__(cls, class_name, class_parents, new_attr)

    # python3的用法
    class Foo(object, metaclass=UpperAttrMetaClass):
        bar = 'bip'

    # python2的用法
    # class Foo(object):
    #     __metaclass__ = UpperAttrMetaClass
    #     bar = 'bip'


    print(hasattr(Foo, 'bar'))
    # 输出: False
    print(hasattr(Foo, 'BAR'))
    # 输出:True

    f = Foo()
    print(f.BAR)
    # 输出:'bip'
Python
#元类
Python学习——元类
http://yoursite.com/post/90bd119b.html/
Author
Chase Wang
Posted on
November 29, 2019
Licensed under