type()

動態語言和靜態語言最大的不同，就是函數和類的定義，不是編譯時定義，而是運行時動態創建的。

比方說我們要定義一個 Hello 的 class ，就寫一個hello.py 模塊：

class Hello(object):

def hello(self, name='world'):

print('Hello, %s' %name)

當 Python 解釋器載入 hello 模塊時，就會依次執行該模塊的所有語句，執行結果就是動態創建出一個 Hello 的 class 對象，測試如下:

fromhello import Hello

h=Hello()

h.hello() # Hello,world

print(type(Hello)) #print(type(h)) #

type() 函數可以查看一個類型或變量的類型，Hello 是一個class，它的類型就是 type ，而 h 是一個實例，它的類型就是 class Hello。

我們說 class 的定義是運行時動態創建的，而創建 class 的方法就是使用 type() 函數。

type() 函數既可以返回一個對象的類型，又可以創建出新的類型，比如，我們可以通過 type() 函數創建出 Hello 類，而無需通過 class Hello(object) 來定義。

def fn(self, name='world'): # 先定義函數

print('Hello, %s'%name)

Hello= type('Hello', (object,), dict(hello=fn)) # 創建Hello classh=Hello()

h.hello() # Hello， world

print(type(Hello)) #print(type(h)) #

要創建一個 class 對象， type() 函數依次傳入3個參數：

class 的名稱。

繼承的父類集合，注意 Python 支持多重繼承，如果只有一個父類，別忘了 tuple 的單元素寫法。

class 的方法名稱與函數綁定，這里我們把函數 fn 綁定到方法名上。

通過 type() 函數創建的類和直接寫 class 是完全一樣的，因為Python 解釋器遇到 class 定義時，僅僅是掃描一下 class 定義的語法，然后調用 type() 函數創建出 class。

正常情況下，我們都用 class xxx 來定義類，但是， type() 函數也允許我們動態創建出類來，也就是說，動態語言本身支持運行期動態創建類，這和靜態語言有非常大的不同，要在靜態語言運行期創建類，必須構造源代碼字符串再調用編譯器，或者借助一些工具生成字節碼實現，本質上都是動態編譯，非常復雜。

metaclass

除了使用 type() 動態創建類以外，要控制類的創建行為，還可以使用 metaclass。

metaclass 直譯為元類，簡單的解釋就是:

當我們定義了類以后，就可以根據這個類創建出實例，所以：先定義類，然后創建實例。

但是如果我們想創建出類呢？那就必須根據 metaclass 創建出類，所以：先定義 metaclass ，然后創建類。

連接起來就是：先定義metaclass ，就可以創建類，最后創建實例。

所以，metaclass 允許你創建類或者修改類。換句話說，你可以把類看出是 metatclass 創建出來的實例。

metaclass 是 Python 面向對象里最難理解，也是最難使用的魔術代碼。支持正常情況下，我們不會碰到。

我們先看一個簡單的例子，這個metaclass 的類名總是 Metaclass 結尾，以便清楚地表示這是一個 metaclass：

# metaclass 是創建類，所以必須從 type 類型派生classListMetaclass(type):

def __new__(cls, name, bases, attrs):

attrs['add'] =lambda self, value: self.paaned(value)returntype.__new__(cls, name, bases, attrs)classMyList(list):

__etaclass__= ListMetaclass # 指示使用ListMetaclass 來定制類

當我們寫下 __metaclass__ = ListMetaclass 語句時，魔術就生效了，它指示 Python 解釋器在創建 MyList 時，要通過ListMetaclass.__new__() 來創建，在此，我們可以修改類的定義，比如加上新的方法，然后，返回修改后的定義。

__new__() 方法接收到的參數依次是：

當前準備創建的類的對象。

類的名字。

類繼承的父類集合。

類的方法集合

測試一下 MyList 是否可以調用 add() 方法：

L=MyList()

L.add(1)

print L # [1]

而普通的 list 沒有 add() 方法

l =list()

l.add()

Traceback (most recent call last):

File"", line 1, in AttributeError:'list' object has no attribute 'add'

動態修改有什么意義？ 直接在MyList 定義中寫上 add() 方法不是更加簡單嗎？ 正常情況先，確實應該直接寫，通過metaclass 修改純屬變態。

但是，總會遇到需要通過 metaclass 修改類的定義的。

ORM 就是一個典型的例子

ORM 全稱 'Object Relational Mapping ' 即對象-關系映射，就是把關系數據庫的一行映射為一個對象，也就是一個類對應一個表，這樣，寫代碼更簡單，不用直接操作 SQL 語句。

要編寫一個 ORM 框架，所有的類都只能動態定義，因為只有使用者才能根據表的結構定義出對應的類來。

實例：編寫 ORM 框架

編寫底層模塊的第一步，就是先把調用接口寫出了。比如，使用者如果使用這個ORM框架，想定義一個 User 類來操作對應的數據庫表 User。

classUser(Model):

# 定義類的屬性到列的映射

id= IntegerField('id')

name= StringField('username')

email= StringField('email')

password= StringField('password')

# 創建一個實例

u= User(id=123, name='Michael', email='xxx@qq.com', password='pwd')

# 保存到數據庫

u.save()

其中，父類 Model 和屬性類型 StringField 、IntegerField 是由ORM框架提供的，剩下的魔術方法比如 save() 全部由 metaclass 自動完成。雖然 metaclass 的編寫會比較復雜，但ORM 的使用者用起來卻異常簡單。

現在，我們就按照上面的接口來實現 ORM

首先來定義 Field 類，它負責保存數據庫表的字段名和字段類型：

class Field(object):

def __init__(self, name, column_type):

self.name=name

self.column_type=column_type

def __str__(self):return '<%s:%s>' % (self.__class__.__name__, self.name)

在 Field 的基礎上，進一步定義各種類型的 Field ，比如 StringFielf、IntegerField 等等：

classStringField(Field):

def __init__(self, name):

super(StringField, self).__init__(name,'varchar(100)')classIntegerField(Field):

def __init__(self, name):

super(IntaegerField, self).__init__(name,'bigint')

下一步，就是編寫最復雜的 ModelMateclass 了：

classModelMetaclass(type):

def __new__(cls, name, bases, attrs):if name=='Model':returntype.__new__(cls, name, bases, attrs)

mappings=dict()for k, v inattrs.iteritems():ifisinstance(v, Field):

print('Fund mapping: %s==>%s' %(k, v))

mappings[k]=vfor k inmappings.iterkeys():

attrs.pop(k)

attrs['__table__'] =name # 假設表名和類名一致

attrs['__mappings__'] =mappings # 保存屬性和列的映射關系return type.__new__(cls, name, bases, attrs)

以及基類 Model：

classModel(dict):

__metaclass__=ModelMetaclass

def __init__(slef,**kw):

super(Model, self).__init__(**kw)

def __getattr(self, key):try:returnself[key]

except KeyError:

raise AttributeError(r"'model' object has no

attribute '%s' "% key)

def __setattr__(self, key, value):

self[key]=value

def save(self):

fields=[]params =[]

args=[]for k, v inself.__mappings__.iteritems():

fields.append(v.name)params.append('?')

args.append(getattr(self, k, None))

sql= 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))

print('SQL: %s' %sql)

print('ARGS: %s' % str(args))

當用戶定義一個 class User(Model) 時， Python 解釋器首先在當前類 User 的定義中查找 __metaclass__ ，如果沒有找到，就繼續在父類 Model 中查找 __metaclass__ 。找到了，就使用 Model 中定義的 __metaclass__ 的ModelMetaclass 來創建 User 類，也就是說， metaclass 可以隱式地繼承到子類，但子類自己卻感覺不到。

在 ModelMetaclass 中，一共做了幾件事情：

排除掉對 Model 類的修改。

在當前類（比如User）中查找定義的類所有屬性，如果找到一個 Field 屬性，就把它保存到一個 __mappings__ 的 dict 中，同時從類屬性中刪除該 Field 屬性，否則，容易造成運行時錯誤

把表名保存到 __table__ 中，這里簡化為表名默認為類名。

在 Model 類中，就可以定義各種操作數據庫的方法，比如 save(), delete(), find(), update() 等等。

編寫測試代碼：

u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')

u.save()

# 輸出如下

Found model: User

Found mapping: email==> Found mapping: password==> Found mapping: id==> Found mapping: name==> SQL: insert into User (password,email,username,uid) values (?,?,?,?)

ARGS: ['my-pwd', 'test@orm.org', 'Michael', 12345]

最后解釋一下類屬性和實例屬性。直接在class中定義的是類屬性：

class Student(object):

name= 'Student'

實例屬性必須通過實例來綁定，比如self.name = 'xxx'。來測試一下：

>>># 創建實例s：>>> s =Student()>>># 打印name屬性，因為實例并沒有name屬性，所以會繼續查找class的name屬性：>>>print(s.name)

Student>>># 這和調用Student.name是一樣的：>>>print(Student.name)

Student>>># 給實例綁定name屬性：>>> s.name = 'Michael'

>>># 由于實例屬性優先級比類屬性高，因此，它會屏蔽掉類的name屬性：>>>print(s.name)

Michael>>># 但是類屬性并未消失，用Student.name仍然可以訪問：>>>print(Student.name)

Student>>># 如果刪除實例的name屬性：>>>del s.name>>># 再次調用s.name，由于實例的name屬性沒有找到，類的name屬性就顯示出來了：>>>print(s.name)

Student

因此，在編寫程序的時候，千萬不要把實例屬

性和類屬性使用相同的名字。

在我們編寫的ORM中，ModelMetaclass會刪除掉User類的所有類屬性，目的就是避免造成混淆。

摘抄至https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001386820064557c69858840b4c48d2b8411bc2ea9099ba000

總結

以上是生活随笔為你收集整理的python if高级用法_Python高级用法总结--元类的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。