python元类

在大多数编程语言中，类就是一组用来描述如何生成一个对象的代码段。在Python中这一点仍然成立类也是对象。但是，Python中的类还远不止如此。类同样也是一种对象。是的，没错，就是对象。只要你使用关键字class，Python解释器在执行的时候就会创建一个对象。类是一组用来描述如何生成一个对象的代码段。

class Dog():
    pass


d1 = Dog()
print(type(d1))
print(type(Dog))
print(type(type))

结果如下：

d1是有Dog创建的，所以他是Dog的类。Dog是type的类，而type还是type的类。所以说类也是对象。因为类也是对象，就像其他任何对象一样，可以在运行时动态的创建。
首先可以在函数中创建类，使用class关键字即可。

def CreatClass(name):
    if name ==  'foo':
        class Foo(object):
            pass
        return Foo
    else:
        class Koo(object):
            pass
        return Koo

t1 = CreatClass('foo')
print(t1)
t2 = CreatClass('xx')
print(t2)

结果如下：

这显然不够动态，因为仍然需要自己编写整个类的代码。由于类是由type创建的，type可以接受一个类的描述作为参数，然后返回一个类。因此，可以直接用type手动创建类。

'''
使用type创建类
type('类名',(继承的父类（可以为空）)，{属性（名称和值）或者方法（方法名和方法）})
'''
Person = type('Person',(),{})
print(Person)
print(dir(Person))

People = type('People',(object,),{'name':'小明','age':'18'})
print(People)
print(dir(People))

def show(self):
    print('姓名：%s 年龄：%s'%(self.name,self.age))

Dog = type('Dog',(),{'name':'小白','age':'3','show':show})
d1 = Dog()
print(dir(d1))
d1.show()

结果如下：

dir()是查看类的所以属性和方法，截图截不完，后看到后两个dir的显示会有name和age的属性，同时最后一个还有一个show。需要注意的是元组中添加父类时，如果只有一个，需要加逗号。
元类就是用来创建类的“东西”。python中所有的东西（包括整数、函数、字符串等等）都是对象。
MyClass = MetaClass() #使用元类创建一个对象，这个对象称为‘类’
MyObject = MyClass() #使用‘类’来创建实例对象
以上代码可以这样写：
Myclass = type（‘Myclass’,(),{}）
函数type实际上是一个元类，type就是python在背后用来创建所有类的元类。使用class可以查看属性

可以看到，a属于字符串类型，而字符串类型又属于type类型。如果再加一个class会发现type还是属于type。
在定义一个类时，可以添加metaclass属性。
创建方案一：
class Foo ()
　　methclass = something
　　pass
对比创建方案二：
class Foo(Father):
　　pass
如果使用创建方案一，python就会用元类来创建类Foo。首先，写下class Foo()，但是类Foo还没有在内存中创建。python会在类的定义中寻找metaclass属性，如果找到了，Python就会用它来创建类Foo，如果没有找到，就会用内建的type来创建这个类。如果选用创建方案二，python将做如下操作：
1、Foo中有metaclass这个属性吗？如果有，Python会通过metaclass创建一个名字为Foo的类(对象)
2、如果Python没有找到metaclass，它会继续在Father（父类）中寻找metaclass属性，并尝试做和前面同样的操作。
3、如果Python在任何父类中都找不到metaclass，它就会在模块层次中去寻找metaclass，并尝试做同样的操作。
4、如果还是找不到metaclass,Python就会用内置的type来创建这个类对象。
那可以在metaclass中添加什么代码？比如，你决定在你的模块里所有的类的属性都应该是大写形式。有好几种方法可以办到，但其中一种就是通过在模块级别设定metaclass。采用这种方法，这个模块中的所有类都会通过这个元类来创建，我们只需要告诉元类把所有的属性都改成大写形式就万事大吉了。

def upper_attr(future_class_name, future_class_parents, future_class_attr):
    print(future_class_name)          #类名
    print(future_class_parents)       #父类
    print(future_class_attr)          #属性
    #遍历属性字典，把不是__开头的属性名字变为大写
    newAttr = {}
    for name,value in future_class_attr.items():
        if not name.startswith("__"):
            newAttr[name.upper()] = value

    #调用type来创建一个类
    return type(future_class_name, future_class_parents, newAttr)


class Foo(object, metaclass = upper_attr):
    bar = 'bip'
    def haha(self):
        pass

print(hasattr(Foo, 'bar'))
# 输出: False
print(hasattr(Foo, 'BAR'))
# 输出:True
print(hasattr(Foo, 'haha'))
# 输出: False
print(hasattr(Foo, 'HAHA'))
# 输出:True
f = Foo()
print(f.BAR)
# 输出:'bip'

结果如下：

这次用一个class来当元类。

class UpperAttrMetaClass(type):
    # __new__ 是在__init__之前被调用的特殊方法
    # __new__是用来创建对象并返回之的方法
    # 而__init__只是用来将传入的参数初始化给对象
    # 你很少用到__new__，除非你希望能够控制对象的创建
    # 这里，创建的对象是类，我们希望能够自定义它，所以我们这里改写__new__
    def __new__(cls, future_class_name, future_class_parents, future_class_attr):
        # 遍历属性字典，把不是__开头的属性名字变为大写
        newAttr = {}
        for name, value in future_class_attr.items():
            if not name.startswith("__"):
                newAttr[name.upper()] = value
        # 方法3：使用super方法
        return super(UpperAttrMetaClass, cls).__new__(cls, future_class_name, future_class_parents, newAttr)


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

    def haha(self):
        pass

print(hasattr(Foo, 'bar'))
# 输出: False
print(hasattr(Foo, 'BAR'))
# 输出:True
print(hasattr(Foo, 'haha'))
# 输出: False
print(hasattr(Foo, 'HAHA'))
# 输出:True
f = Foo()
print(f.BAR)
# 输出:'bip'

结果如下：

以上就是关于元类的总结。