什麼是類的本身是對象？

Question

我剛剛閱讀了關於Python類文檔，它說，在Python中「類本身就是對象」。它與C＃或Java類有什麼不同？ 與C＃或Java相比，這種類型有什麼優點和缺點？

Answer 1

主要區別在於它們意味着您可以輕鬆地將該類作爲對象進行操作。 Java中有相同的工具，您可以使用Class的方法獲取有關對象類的信息。在Python，Ruby和Smalltalk等語言中，語言的動態性更強，可以讓您「打開」課程並對其進行更改，有時也稱爲「猴子修補」。我個人並不認爲差異是一件大事，但我相信我們可以開始一場良好的宗教戰爭。

Answer 2

在Python中，類是對象，您可以將它們分配給變量，將它們傳遞給函數等，就像任何其他對象一樣。例如

>>> t = type(10) 
>>> t 
<type 'int'> 
>>> len(t.__dict__) 
55 
>>> t() # construct an int 
0 
>>> t(10) 
10 

Java有Class對象，其提供關於一類的一些信息，但不能代替明確的類名稱的使用它們。他們不是真正的階級，只是階級信息結構。

Class C = x.getClass(); 
new C(); // won't work 

Answer 3

在C＃和Java中，類不是對象。它們是類型，就是這些語言是靜態類型的。當然，你可以得到一個代表特定類的對象 - 但這不同於類本身。

在Python中看起來像一個類實際上也是一個對象。

它exlpained here好多比我能永遠做:)

Answer 4

聲明一個類只是聲明一個變量：

class foo(object): 
    def bar(self): pass 
print foo # <class '__main__.foo'> 

它們可以被分配並存儲就像任何變量：

class foo(object): 
    pass 
class bar(object): 
    pass 
baz = bar # simple variable assignment 
items = [foo, bar] 
my_foo = items[0]() # creates a foo 
for x in (foo, bar): # create one of each type 
    print x() 

並作爲變量傳遞：

class foo(object): 
    def __init__(self): 
     print "created foo" 
def func(f): 
    f() 

func(foo) 

他們可以通過功能，包括基本類列表中創建：

def func(base_class, var): 
    class cls(base_class): 
     def g(self): 
      print var 
    return cls 

class my_base(object): 
    def f(self): print "hello" 

new_class = func(my_base, 10) 
obj = new_class() 
obj.f() # hello 
obj.g() # 10 

相反，而在Java類中有一個代表他們，如對象。 String.class，類名稱本身 - String - 不是一個對象，不能作爲一個操作。這是靜態類型語言所固有的。

Answer 5

類是對象，因爲它們可以像任何對象一樣在Python代碼中進行操作。其他人已經展示瞭如何將它們傳遞給函數，以便像任何對象一樣對它們進行操作。這裏是你將如何做到這一點：

class Foo(object): 
    pass 

f = Foo() 

f.a = "a" # assigns attribute on instance f 
Foo.b = "b" # assigns attribute on class Foo, and thus on all instances including f 

print f.a, f.b 

其次，像所有的對象，類在運行時實例化。也就是說，類定義是代碼執行而不是編譯在任何運行之前的結構。這意味着類可以「烘烤」僅在程序運行時才知道的事物，例如環境變量或用戶輸入。當這個類被聲明並且成爲這個類的一部分時，這些被評估一次。這與C＃等編譯語言不同，它需要這種行爲以不同的方式實現。

最後，類，像任何對象一樣，都是從類中構建的。就像一個對象是從一個類構建的一樣，一個類也是由一個特殊的類構建的，這個類稱爲一個元類（）。你可以編寫你自己的元類來改變如何定義類。

Answer 6

類是對象的另一個優點是，對象可以在運行時改變他們的階級：

>>> class MyClass(object): 
...  def foo(self): 
...   print "Yo There! I'm a MyCLass-Object!" 
... 
>>> class YourClass(object): 
...  def foo(self): 
...   print "Guess what?! I'm a YourClass-Object!" 
... 
>>> o = MyClass() 
>>> o.foo() 
Yo There! I'm a MyCLass-Object! 
>>> o.__class__ = YourClass 
>>> o.foo() 
Guess what?! I'm a YourClass-Object! 

對象有一個特殊的屬性__class__指向類的，他們是一個實例。這是可能的，因爲類是它自己的對象，因此可以綁定到像__class__這樣的屬性。

Answer 7

由於此問題有一個Smalltalk標記，因此此答案來自Smalltalk觀點。在面向對象的編程中，事情通過消息傳遞完成。您向對象發送消息，如果對象理解該消息，則執行相應的方法並返回一個值。但是，如何創建對象呢？如果引入了特殊的語法來創建對象，這將破壞基於消息傳遞的簡單語法。這是語言發生了什麼樣的Java：

p = new Point(10, 20); // Creates a new Point object with the help of a special keyword - new. 
p.draw(); // Sends the message `draw` to the Point object. 

由於它是從上面的代碼看出，語言有兩種方式做事情 - 一個命令式和麪向其他對象。相比之下，Smalltalk中有僅基於消息傳遞一致的語法：

p := Point new: 10 y: 20. 
p draw. 

這裏new是一個消息發送到一個單獨的對象稱爲Point這是一個Metaclass的一個實例。除了爲語言提供一致的計算模型之外，元類還允許動態修改類。例如，下面的語句將添加一個新的實例變量，Point類，而不需要重新編譯或VM重新啓動：

Point addInstVarName: 'z'. 

關於這一問題的最好的閱讀是The Art of the Metaobject Protocol。