午夜国产狂喷潮在线观看|国产AⅤ精品一区二区久久|中文字幕AV中文字幕|国产看片高清在线

類(lèi)和對(duì)象

類(lèi)和函數(shù)一樣都是Python中的對(duì)象。當(dāng)一個(gè)類(lèi)定義完成之后，Python將創(chuàng)建一個(gè)“類(lèi)對(duì)象”并將其賦值給一個(gè)同名變量。類(lèi)是type類(lèi)型的對(duì)象(是不是有點(diǎn)拗口？)。

類(lèi)對(duì)象是可調(diào)用的(callable，實(shí)現(xiàn)了 __call__方法)，并且調(diào)用它能夠創(chuàng)建類(lèi)的對(duì)象。你可以將類(lèi)當(dāng)做其他對(duì)象那么處理。例如，你能夠給它們的屬性賦值，你能夠?qū)⑺鼈冑x值給一個(gè)變量，你可以在任何可調(diào)用對(duì)象能夠用的地方使用它們，比如在一個(gè)map中。事實(shí)上當(dāng)你在使用map(str, [1,2,3])的時(shí)候，是將一個(gè)整數(shù)類(lèi)型的list轉(zhuǎn)換為字符串類(lèi)型的list，因?yàn)閟tr是一個(gè)類(lèi)。可以看看下面的代碼：

>>> class C(object):

... def __init__(self, s):

... print s

...

>>> myclass = C

>>> type(C)

<type 'type'>

>>> type(myclass)

<type 'type'>

>>> myclass(2)

<__main__.C object at 0x10e2bea50>

>>> map(myclass, [1,2,3])

[<__main__.C object at 0x10e2be9d0>, <__main__.C object at 0x10e2bead0>, <__main__.C object at 0x10e2beb10>]

>>> map(C, [1,2,3])

[<__main__.C object at 0x10e2be950>, <__main__.C object at 0x10e2beb50>, <__main__.C object at 0x10e2beb90>]

>>> C.test_attribute = True

>>> myclass.test_attribute

True

正因如此，Python中的“class”關(guān)鍵字不像其他語(yǔ)言(例如C++)那樣必須出現(xiàn)在代碼main scope中。在Python中，它能夠在一個(gè)函數(shù)中嵌套出現(xiàn)，舉個(gè)例子，我們能夠這樣在函數(shù)運(yùn)行的過(guò)程中動(dòng)態(tài)的創(chuàng)建類(lèi)?？创a：

>>> def make_class(class_name):

... class C(object):

... def print_class_name(self):

... print class_name

... C.__name__ = class_name

... return C

...

>>> C1, C2 = map(make_class, ["C1", "C2"])

>>> c1, c2 = C1(), C2()

>>> c1.print_class_name()

C1

>>> c2.print_class_name()

C2

>>> type(c1)

<class '__main__.C1'>

>>> type(c2)

<class '__main__.C2'>

>>> c1.print_class_name.__closure__

(<cell at 0x10ab6dbe8: str object at 0x10ab71530>,)

請(qǐng)注意，在這里通過(guò)make_class創(chuàng)建的兩個(gè)類(lèi)是不同的對(duì)象，因此通過(guò)它們創(chuàng)建的對(duì)象就不屬于同一個(gè)類(lèi)型。正如我們?cè)谘b飾器中做的那樣，我們?cè)陬?lèi)被創(chuàng)建之后手動(dòng)設(shè)置了類(lèi)名。同樣也請(qǐng)注意所創(chuàng)建類(lèi)的print_class_name方法在一個(gè)closure cell中捕捉到了類(lèi)的closure和class_name。如果你對(duì)closure的概念還不是很清楚，那么最好去看看前篇，復(fù)習(xí)一下closures和decorators相關(guān)的內(nèi)容。

Metaclasses

如果類(lèi)是能夠制造對(duì)象的對(duì)象，那制造類(lèi)的對(duì)象又該叫做什么呢(相信我，這并不是一個(gè)先有雞還是先有蛋的問(wèn)題)？答案是元類(lèi)(Metaclasses)。大部分常見(jiàn)的基礎(chǔ)元類(lèi)都是type。當(dāng)輸入一個(gè)參數(shù)時(shí)，type將簡(jiǎn)單的返回輸入對(duì)象的類(lèi)型，這就不涉及元類(lèi)。然而當(dāng)輸入三個(gè)參數(shù)時(shí)，type將扮演元類(lèi)的角色，基于輸入?yún)?shù)創(chuàng)建一個(gè)類(lèi)并返回。輸入?yún)?shù)相當(dāng)簡(jiǎn)單：類(lèi)名，父類(lèi)及其參數(shù)的字典。后面兩者可以為空，來(lái)看一個(gè)例子：

>>> MyClass = type("MyClass", (object,), {"my_attribute": 0})

>>> type(MyClass)

<type 'type'>

>>> o = MyClass()

>>> o.my_attribute

0

特別注意第二個(gè)參數(shù)是一個(gè)tuple(語(yǔ)法看起來(lái)很奇怪，以逗號(hào)結(jié)尾)。如果你需要在類(lèi)中安排一個(gè)方法，那么創(chuàng)建一個(gè)函數(shù)并且將其以屬性的方式傳遞作為第三個(gè)參數(shù)，像這樣：

>>> def myclass_init(self, my_attr):

... self.my_attribute = my_attr

...

>>> MyClass = type("MyClass", (object,), {"my_attribute": 0, "__init__": myclass_init})

>>> o = MyClass("Test")

>>> o.my_attribute

'Test'

>>> o.__init__

<bound method MyClass.myclass_init of <__main__.MyClass object at 0x10ab72150>>

我們可以通過(guò)一個(gè)可調(diào)用對(duì)象(函數(shù)或是類(lèi))來(lái)自定義元類(lèi)，這個(gè)對(duì)象需要三個(gè)輸入?yún)?shù)并返回一個(gè)對(duì)象。這樣一個(gè)元類(lèi)在一個(gè)類(lèi)上實(shí)現(xiàn)只要定義了它的__metaclass__屬性。第一個(gè)例子，讓我們做一些有趣的事情看看我們能夠用元類(lèi)做些什么：

>>> def mymetaclass(name, parents, attributes):

... return "Hello"

...

>>> class C(object):

... __metaclass__ = mymetaclass

...

>>> print C

Hello

>>> type(C)

<type 'str'>

請(qǐng)注意以上的代碼，C只是簡(jiǎn)單地將一個(gè)變量引用指向了字符串“Hello”。當(dāng)然了，沒(méi)人會(huì)在實(shí)際中寫(xiě)這樣的代碼，這只是為了演示元類(lèi)的用法而舉的一個(gè)簡(jiǎn)單例子。接下來(lái)我們來(lái)做一些更有用的操作。在本系列的第二部分我們?cè)吹饺绾问褂醚b飾器類(lèi)來(lái)記錄目標(biāo)類(lèi)每個(gè)方法的輸出，現(xiàn)在我們來(lái)做同樣的事情，不過(guò)這一次我們使用元類(lèi)。我們借用之前的裝飾器定義：

def log_everything_metaclass(class_name, parents, attributes):

print "Creating class", class_name

myattributes = {}

for name, attr in attributes.items():

myattributes[name] = attr

if hasattr(attr, '__call__'):

myattributes[name] = logged("%b %d %Y - %H:%M:%S",

class_name + ".")(attr)

return type(class_name, parents, myattributes)

class C(object):

__metaclass__ = log_everything_metaclass

def __init__(self, x):

self.x = x

def print_x(self):

print self.x

# Usage:

print "Starting object creation"

c = C("Test")

c.print_x()

# Output:

Creating class C

Starting object creation

- Running 'C.__init__' on Aug 05 2013 - 13:50:58

- Finished 'C.__init__', execution time = 0.000s

- Running 'C.print_x' on Aug 05 2013 - 13:50:58

Test

- Finished 'C.print_x', execution time = 0.000s

如你所見(jiàn)，類(lèi)裝飾器與元類(lèi)有著很多共同點(diǎn)。事實(shí)上，任何能夠用類(lèi)裝飾器完成的功能都能夠用元類(lèi)來(lái)實(shí)現(xiàn)。類(lèi)裝飾器有著很簡(jiǎn)單的語(yǔ)法結(jié)構(gòu)易于閱讀，所以提倡使用。但就元類(lèi)而言，它能夠做的更多，因?yàn)樗陬?lèi)被創(chuàng)建之前就運(yùn)行了，而類(lèi)裝飾器則是在類(lèi)創(chuàng)建之后才運(yùn)行的。記住這點(diǎn)，讓我們來(lái)同時(shí)運(yùn)行一下兩者，請(qǐng)注意運(yùn)行的先后順序：

def my_metaclass(class_name, parents, attributes):

print "In metaclass, creating the class."

return type(class_name, parents, attributes)

def my_class_decorator(class_):

print "In decorator, chance to modify the class."

return class_

@my_class_decorator

class C(object):

__metaclass__ = my_metaclass

def __init__(self):

print "Creating object."

c = C()

# Output:

In metaclass, creating the class.

In decorator, chance to modify the class.

Creating object.

元類(lèi)的一個(gè)實(shí)際用例

讓我們來(lái)考慮一個(gè)更有用的實(shí)例。假設(shè)我們正在構(gòu)思一個(gè)類(lèi)集合來(lái)處理MP3音樂(lè)文件中使用到的ID3v2標(biāo)簽Wikipedia。簡(jiǎn)而言之，標(biāo)簽由幀(frames)組成，而每幀通過(guò)一個(gè)四字符的識(shí)別碼(identifier)進(jìn)行標(biāo)記。舉個(gè)例子，TOPE標(biāo)識(shí)了原作者幀，TOAL標(biāo)識(shí)了原專(zhuān)輯名稱(chēng)等。如果我們希望為每個(gè)幀類(lèi)型寫(xiě)一個(gè)單獨(dú)的類(lèi)，并且允許ID3v2標(biāo)簽庫(kù)用戶(hù)自定義他們自己的幀類(lèi)。那么我們可以使用元類(lèi)來(lái)實(shí)現(xiàn)一個(gè)類(lèi)工廠模式，具體實(shí)現(xiàn)方式可以這樣：

frametype_class_dict = {}

class ID3v2FrameClassFactory(object):

def __new__(cls, class_name, parents, attributes):

print "Creating class", class_name

# Here we could add some helper methods or attributes to c

c = type(class_name, parents, attributes)

if attributes['frame_identifier']:

frametype_class_dict[attributes['frame_identifier']] = c

return c

@staticmethod

def get_class_from_frame_identifier(frame_identifier):

return frametype_class_dict.get(frame_identifier)

class ID3v2Frame(object):

frame_identifier = None

__metaclass__ = ID3v2FrameClassFactory

pass

class ID3v2TitleFrame(ID3v2Frame):

__metaclass__ = ID3v2FrameClassFactory

frame_identifier = "TIT2"

class ID3v2CommentFrame(ID3v2Frame):

__metaclass__ = ID3v2FrameClassFactory

frame_identifier = "COMM"

title_class = ID3v2FrameClassFactory.get_class_from_frame_identifier('TIT2')

comment_class = ID3v2FrameClassFactory.get_class_from_frame_identifier('COMM')

print title_class

print comment_class

# Output:

Creating class ID3v2Frame

Creating class ID3v2TitleFrame

Creating class ID3v2CommentFrame

<class '__main__.ID3v2TitleFrame'>

<class '__main__.ID3v2CommentFrame'>

當(dāng)然了，以上的代碼同樣可以用類(lèi)裝飾器來(lái)完成，以下是對(duì)應(yīng)代碼：

frametype_class_dict = {}

class ID3v2FrameClass(object):

def __init__(self, frame_id):

self.frame_id = frame_id

def __call__(self, cls):

print "Decorating class", cls.__name__

# Here we could add some helper methods or attributes to c

if self.frame_id:

frametype_class_dict[self.frame_id] = cls

return cls

@staticmethod

def get_class_from_frame_identifier(frame_identifier):

return frametype_class_dict.get(frame_identifier)

@ID3v2FrameClass(None)

class ID3v2Frame(object):

pass

@ID3v2FrameClass("TIT2")

class ID3v2TitleFrame(ID3v2Frame):

pass

@ID3v2FrameClass("COMM")

class ID3v2CommentFrame(ID3v2Frame):

pass

title_class = ID3v2FrameClass.get_class_from_frame_identifier('TIT2')

comment_class = ID3v2FrameClass.get_class_from_frame_identifier('COMM')

print title_class

print comment_class

Decorating class ID3v2Frame

Decorating class ID3v2TitleFrame

Decorating class ID3v2CommentFrame

<class '__main__.ID3v2TitleFrame'>

<class '__main__.ID3v2CommentFrame'>

如你所見(jiàn)，我們可以直接給裝飾器傳遞參數(shù)，而元類(lèi)卻不能。給元類(lèi)傳遞參數(shù)必須通過(guò)屬性。正因如此，這里裝飾器的解決方案更為清晰，同時(shí)也更容易維護(hù)。然而，同時(shí)也需要注意當(dāng)裝飾器被調(diào)用的時(shí)候，類(lèi)已經(jīng)建立完畢，這意味著此時(shí)就不能夠修改其屬性了。例如，一旦類(lèi)建立完成，你就不能夠修改__doc__。來(lái)看實(shí)際例子：

>>> def mydecorator(cls):

... cls.__doc__ = "Test!"

... return cls

...

>>> @mydecorator

... class C(object):

... """Docstring to be replaced with Test!"""

... pass

...

Traceback (most recent call last):

File "<stdin>", line 2, in <module>

File "<stdin>", line 2, in mydecorator

AttributeError: attribute '__doc__' of 'type' objects is not writable

>>> def mymetaclass(cls, parents, attrs):

... attrs['__doc__'] = 'Test!'

... return type(cls, parents, attrs)

...

>>> class D(object):

... """Docstring to be replaced with Test!"""

... __metaclass__ = mymetaclass

...

>>> D.__doc__

'Test!'

通過(guò)type生成元類(lèi)

正如我們所說(shuō)，最基本的元類(lèi)就是type并且類(lèi)通常都是type類(lèi)型。那么問(wèn)題很自然來(lái)了，type類(lèi)型本身是一種什么類(lèi)型呢？答案也是type。這也就是說(shuō)type就是它自身的元類(lèi)。雖然聽(tīng)起來(lái)有點(diǎn)詭異，但這在Python解釋器層面而言是可行的。

type自身就是一個(gè)類(lèi)，并且我們可以從它繼承出新類(lèi)。這些生成的類(lèi)也能作為元類(lèi)，并且使用它們的類(lèi)可以得到跟使用type一樣的類(lèi)型。來(lái)看以下的例子：

>>> class meta(type):

... def __new__(cls, class_name, parents, attributes):

... print "meta.__new__"

... return super(meta, cls).__new__(cls, class_name, parents, attributes)

... def __call__(self, *args, **kwargs):

... print "meta.__call__"

... return super(meta, self).__call__(*args, **kwargs)

...

>>> class C(object):

... __metaclass__ = meta

...

meta.__new__

>>> c = C()

meta.__call__

>>> type(C)

<class '__main__.meta'>

請(qǐng)注意當(dāng)類(lèi)創(chuàng)建對(duì)象時(shí)，元類(lèi)的__call__函數(shù)就被調(diào)用，進(jìn)而調(diào)用type.__call__創(chuàng)建對(duì)象。在下一節(jié)，我們將把上面的內(nèi)容融合在一起。

要點(diǎn)集合

假定一個(gè)類(lèi)C自己的元類(lèi)為my_metaclass并被裝飾器my_class_decorator裝飾。并且，假定my_metaclass本身就是一個(gè)類(lèi)，從type生成。讓我們將上面提到的內(nèi)容融合到一起做一個(gè)總結(jié)來(lái)顯示C類(lèi)以及它的對(duì)象都是怎么被創(chuàng)建的。首先，讓我們來(lái)看看代碼：

class my_metaclass(type):

def __new__(cls, class_name, parents, attributes):

print "- my_metaclass.__new__ - Creating class instance of type", cls

return super(my_metaclass, cls).__new__(cls,

class_name,

parents,

attributes)

def __init__(self, class_name, parents, attributes):

print "- my_metaclass.__init__ - Initializing the class instance", self

super(my_metaclass, self).__init__(self)

def __call__(self, *args, **kwargs):

print "- my_metaclass.__call__ - Creating object of type ", self

return super(my_metaclass, self).__call__(*args, **kwargs)

def my_class_decorator(cls):

print "- my_class_decorator - Chance to modify the class", cls

return cls

@my_class_decorator

class C(object):

__metaclass__ = my_metaclass

def __new__(cls):

print "- C.__new__ - Creating object."

return super(C, cls).__new__(cls)

def __init__(self):

print "- C.__init__ - Initializing object."

c = C()

print "Object c =", c

現(xiàn)在，你可以花幾分鐘時(shí)間測(cè)試一下你的理解，并且猜一猜打印輸出的順序。

首先，讓我們來(lái)看看Python的解釋器是如何閱讀這部分代碼的，然后我們會(huì)對(duì)應(yīng)輸出來(lái)加深我們的理解。

1. Python首先看類(lèi)聲明，準(zhǔn)備三個(gè)傳遞給元類(lèi)的參數(shù)。這三個(gè)參數(shù)分別為類(lèi)名(class_name)，父類(lèi)(parent)以及屬性列表(attributs)。

2. Python會(huì)檢查_(kāi)_metaclass__屬性，如果設(shè)置了此屬性，它將調(diào)用metaclass，傳遞三個(gè)參數(shù)，并且返回一個(gè)類(lèi)。

3. 在這個(gè)例子中，metaclass自身就是一個(gè)類(lèi)，所以調(diào)用它的過(guò)程類(lèi)似創(chuàng)建一個(gè)新類(lèi)。這就意味著my_metaclass.__new__將首先被調(diào)用，輸入四個(gè)參數(shù)，這將新建一個(gè)metaclass類(lèi)的實(shí)例。然后這個(gè)實(shí)例的my_metaclass.__init__將被調(diào)用調(diào)用結(jié)果是作為一個(gè)新的類(lèi)對(duì)象返回。所以此時(shí)C將被設(shè)置成這個(gè)類(lèi)對(duì)象。

4. 接下來(lái)Python將查看所有裝飾了此類(lèi)的裝飾器。在這個(gè)例子中，只有一個(gè)裝飾器。Python將調(diào)用這個(gè)裝飾器，將從元類(lèi)哪里得到的類(lèi)傳遞給它作為參數(shù)。然后這個(gè)類(lèi)將被裝飾器返回的對(duì)象所替代。

5. 裝飾器返回的類(lèi)類(lèi)型與元類(lèi)設(shè)置的相同。

6. 當(dāng)類(lèi)被調(diào)用創(chuàng)建一個(gè)新的對(duì)象實(shí)例時(shí)，因?yàn)轭?lèi)的類(lèi)型是metaclass，因此Python將會(huì)調(diào)用元類(lèi)的__call__方法。在這個(gè)例子中，my_metaclass.__call__只是簡(jiǎn)單的調(diào)用了type.__call__，目的是創(chuàng)建一個(gè)傳遞給它的類(lèi)的對(duì)象實(shí)例。

7. 下一步type.__call__通過(guò)C.__new__創(chuàng)建一個(gè)對(duì)象。

8. 最后type.__call__通過(guò)C.__new__返回的結(jié)果運(yùn)行C.__init__。

9. 返回的對(duì)象已經(jīng)準(zhǔn)備完畢。

所以基于以上的分析，我們可以看到調(diào)用的順序如下：my_metaclass.__new__首先被調(diào)用，然后是my_metaclass.__init__，然后是my_class_decorator。至此C類(lèi)已經(jīng)準(zhǔn)備完畢(返回結(jié)果就是C)。當(dāng)我們調(diào)用C來(lái)創(chuàng)建一個(gè)對(duì)象的時(shí)候，首先會(huì)調(diào)用my_metaclass.__call__(任何對(duì)象被創(chuàng)建的時(shí)候，Python都首先會(huì)去調(diào)用其類(lèi)的__call__方法)，然后C.__new__將會(huì)被type.__call__調(diào)用(my_metaclass.__call__簡(jiǎn)單調(diào)用了type.__call__)，最后是C.__init__被調(diào)用。現(xiàn)在讓我們來(lái)看看輸出：

- my_metaclass.__new__ - Creating class instance of type <class '__main__.my_metaclass'>

- my_metaclass.__init__ - Initializing the class instance <class '__main__.C'>

- my_class_decorator - Chance to modify the class <class '__main__.C'>

- my_metaclass.__call__ - Creating object of type <class '__main__.C'>

- C.__new__ - Creating object.

- C.__init__ - Initializing object.

Object c = <__main__.C object at 0x1043feb90> <class '__main__.C'>

關(guān)于元類(lèi)多說(shuō)幾句

元類(lèi)，一門(mén)強(qiáng)大而晦澀的技法。在GitHub上搜索__metaclass__得到的結(jié)果多半是指向”cookbook”或其他Python教學(xué)材料的鏈接。一些測(cè)試用例(諸如Jython中的一些測(cè)試用例)，或是其他一些寫(xiě)有__metaclass__ = type的地方只是為了確保新類(lèi)被正常使用了。坦白地說(shuō)，這些用例都沒(méi)有真正地使用元類(lèi)。過(guò)濾了下結(jié)果，我只能找到兩個(gè)地方真正使用了元類(lèi)：ABCMeta和djangoplugins。

ABCMeta是一個(gè)允許注冊(cè)抽象基類(lèi)的元類(lèi)。如果想了解多些請(qǐng)查看其官方文檔，本文將不會(huì)討論它。

對(duì)于djangoplugins而言，基本的思想是基于這篇文章article on a simple plugin framework for Python，使用元類(lèi)是為了創(chuàng)建一個(gè)插件掛載系統(tǒng)。我并沒(méi)有對(duì)其有深入的研究，不過(guò)我感覺(jué)這個(gè)功能可以使用裝飾器來(lái)實(shí)現(xiàn)。如果你有相關(guān)的想法請(qǐng)?jiān)?本文后留言。

總結(jié)筆記

通過(guò)理解元類(lèi)能夠幫助我們更深入的理解Python中類(lèi)和對(duì)象的行為，現(xiàn)實(shí)中使用它們的情況可能比文中的例子要復(fù)雜得多。大部分元類(lèi)完成的功能都可以使用裝飾器來(lái)實(shí)現(xiàn)。所以當(dāng)你的第一直覺(jué)是使用元類(lèi)來(lái)解決你的問(wèn)題，那么請(qǐng)你停下來(lái)先想想這是否必要。如果不是非要使用元類(lèi)，那么請(qǐng)三思而行。這會(huì)使你的代碼更易懂，更易調(diào)試和維護(hù)。

更多信息請(qǐng)查看IT技術(shù)專(zhuān)欄