python之元类

一、globals查看所有全局变量
二、元类
三、自定义元类

一、globals查看所有全局变量

1. 这里我们就用两行代码就可以直接体现

a = 100
globals()

# 输出

# {'__name__': '__main__',
#  '__doc__': 'Automatically created module for IPython interactive environment',
#  '__package__': None,
#  '__loader__': None,
#  '__spec__': None,
#  '__builtin__': <module 'builtins' (built-in)>,
#  '__builtins__': <module 'builtins' (built-in)>,
#  '_ih': ['', 'a = 100\nglobals()'],
#  '_oh': {},
#  '_dh': ['C:\\Users\\Administrator\\pythontest'],
#  'In': ['', 'a = 100\nglobals()'],
#  'Out': {},
#  'get_ipython': <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x0000026126091310>>,
#  'exit': <IPython.core.autocall.ZMQExitAutocall at 0x261261331c0>,
#  'quit': <IPython.core.autocall.ZMQExitAutocall at 0x261261331c0>,
#  '_': '',
#  '__': '',
#  '___': '',
#  '_i': '',
#  '_ii': '',
#  '_iii': '',
#  '_i1': 'a = 100\nglobals()',
#  'a': 100}

可以看到，最后一行已经出现了我们的a，再这里出现的每一个变量我们都能直接调用

• 其实当我们定义全局变量的时候，python会把所有的全局变量都放到一个空间里，用globals()就能查看

2. 当我们定义一个函数(AAAA)和一个对象(BBBB)之后，再来查看globals的时候

def AAAA():
    pass

class BBBB(object):
    pass

globals()

# 最后两行输出结果
# 'AAAA': <function __main__.AAAA()>,
# 'BBBB': __main__.BBBB

结论：当我们创建一个对象A的时候，都会将其存在globals中，‘A’是键，A的指针是值。
所以当我们定义两个相同的变量的时候，后面一个会覆盖前面一个，因为globals的值是一个字典，字典中的键不能重复，在第二次被定义的时候，同名的键的值就会被之后的覆盖。

二、元类

1. 元类就是创建类的类，由元类创建类，再由类创建实例对象，多以元类再python中的地位就是一个‘造物主’，python中一切的对象都是直接或者间接由元类创造的。
2. 在程序运行过程中，我们可以动态创建类，而不是将类写死在代码上。type()就有这个功能,type实际上就是一个元类，它能创建一个类。

# 定义函数，获取类中所有的值
def getElm(self):
    return self.num1,self.num2,self.a,self.b

# 在外部定义初始化函数
def __init__(self,a,b):
    self.a = a
    self.b = b

# 第一个是类名，第二个是父类元组，第三个是类中的对象，
# 有num1,num2,getElm函数和'__init__初始化函数'
Test = type('Test',(),{'num1':1,'num2':2,'func':getElm,'__init__':__init__})

# 初始化函数并传参
test = Test('a','b')

# 调用函数，获取所有的值，返回一个元组
test.func()

# 输出

# (1, 2, 'a', 'b')

type由三个参数，第一个是类名。第二个是该类索要继承的父类所组成的元组，第三个是一个字典，这个字典储存了类中所有的对象。

三、自定义元类

当python解释器执行道以下代码的时候，会自动调用type方法来创建一个元类

class Foo:
    bar = 'zip'

会自动调用：

Foo = type(‘Foo’,(),{‘bar’:‘zip’})

但是在实际运用中，若我们想把bar这个变量名改成BAR，让他创建一个截然不同的类，就需要自己写一个元类，让解释器调用我们写的那个元类来创建这个类，达到我们的目的

def upper_attr(class_name,class_parents,class_attr):
    new_attr = {}
    for key,value in class_attr.items():
        if not key.startswith('__'):
            new_attr[key.upper()] = value
    return type(class_name,class_parents,new_attr)

class Foo(object,metaclass = upper_attr):
# 小写定义域bar
    bar = 'zip'
    
Foo.__dict__

# 输出

# mappingproxy({'BAR': 'zip',
#               '__module__': '__main__',
#               '__dict__': <attribute '__dict__' of 'Foo' objects>,
#               '__weakref__': <attribute '__weakref__' of 'Foo' objects>,
#               '__doc__': None})

可以看到，虽然我们小写定义bar，但是实际上创建出来的类中的bar是大写。
因为metaclass可以指定元类，默认是type，只要我们把metaclass的值修改之后就可以随意修改我们定义的类。