什么是类的本身是对象？

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。