在大多數編程語言中，類就是一組用來描述如何生成一個對象的代碼段。在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'
結果如下：
以上就是關于元類的總結。
