将int []转换为short []，反之亦然(Converting int[] to short[] and vice versa)

 
 
 有人可以帮助我理解为什么在Python中，即使没有除self之外的构造函数参数，也需要用括号实例化一个类。 
 
 
 原因很简单：当你实例化一个对象时，你实际上正在调用它的类（它本身就是一个对象），并用()调用对象。 
 
 在Python中， 一切都是一流的对象 ，甚至是类（和函数！）本身。 为了使一个类成为第一类对象，它遵循这个类需要它自己的类（ 元类 ）来定义它的行为。 我们称之为“元类”类的类，以避免在讨论类和类时产生混淆。 
 
 回答你的问题的第二部分：当你使用MainViewController而不是MainViewController()时，发生了“事情”，因为MainViewController 是一个完整的对象 ，就像任何其他对象一样。 
 
 所以你可能会问：什么是MainViewController对象的类 - 实际上是元类？ 
 
 
 如你所知，你可以像这样创建一个类： 
 
class MyClass: 
    pass
 
 当你这样做时，你实际上正在创建一个名为type的元类的新实例。 
 
 请注意，您可以通过这种方式创建相同的类; 下面和上面几乎没有区别： 
 
MyClass = type('MyClass', (object,), {}) 
 
 
 type元类是所有类的基本元类。 所有的python“新风格的类”（不再是“新”了，因为它们是在python 2.1中实现的，我相信）是类type ： 
 
print(type(MyClass)) # type
print(type(list)) # type
print(type(int)) # type
# Note that above, type is being used as a "function" (it's really just a callable)
 
 有趣的是， type甚至是它自己的元类： 
 
print(type(type)) # type
 
 所以重申：类MyClass实际上是一个type的实例。 接下来， 调用该类将导致运行其元类的__call__方法。 
 
 当你这样做时： 
 
obj = MyClass()
 
 ...您正在调用 MyClass ，结果（在后台）运行方法type.__call__() 。 
 
 所有用户定义的类都是这种情况，顺便说一句; 如果在类中包含__call__方法，则可以调用您的类，并且在调用类实例时执行__call__方法： 
 
class MyCallable():
    def __call__(self):
        print("You rang?") 

my_instance = MyCallable()
my_instance() # You rang?
 
 你可以看到这在行动。 如果通过子type创建自己的元类，那么当创建基于自定义元类的类实例时，可能会导致发生这种情况。 例如： 
 
class MyMeta(type):
    def __call__(self, *args, **kwargs):
        print "call: {} {} {}".format(self, args, kwargs)
        return super().__call__(*args, **kwargs)

# Python 3: 

class MyClass(metaclass = MyMeta):
    pass

# Python 2: 

class MyClass():
    __metaclass__ = MyMeta
    pass
 
 现在，当您执行MyClass() ，您可以看到MyMeta的__call__方法发生在其他任何事情之前（包括__new__之前和__init__之前）。 

 
 
Can someone please help me understand why in Python you need to instantiate a class with parenthesis even if there are no constructor arguments other than self.
 
 
The reason is simple: when you instantiate an object, you are actually calling its class (which is itself an object), and you call objects using (). 
 
In python, everything is a first-class object, even classes (and functions!) themselves. In order for a class to be a first class object, it follows that the class needs its own class (metaclass) to define its behavior. We call the class of a class "metaclass" so as to avoid confusion when talking about classes and classes of classes. 
 
To answer the second part of your question: "things" were happening when you used MainViewController instead of MainViewController() because MainViewController is a full-fledged object, just like any other object. 
 
So you might ask: what is the class - actually the metaclass - of the MainViewController object? 
 
 
As you know, you can create a class like this: 
 
class MyClass: 
    pass
 
When you do this, you are in actuality creating a new instance of the metaclass known as type. 
 
Note that you can create the same class this way; there is literally no difference between the below and the above: 
 
MyClass = type('MyClass', (object,), {}) 
 
 
The type metaclass is the base metaclass of all classes. All python "new style classes" (not so "new" anymore since they were implemented in python 2.1, I believe) are of the class type:
 
print(type(MyClass)) # type
print(type(list)) # type
print(type(int)) # type
# Note that above, type is being used as a "function" (it's really just a callable)
 
Interestingly enough, type is even its own metaclass:
 
print(type(type)) # type
 
So to reiterate: the class MyClass is actually an instantiation of type. It follows, then, that calling the class results in running the __call__ method of its metaclass. 
 
When you do: 
 
obj = MyClass()
 
...you are calling MyClass, which results (in the background) in running the method type.__call__(). 
 
This is the case with all user defined classes, btw; if you include the __call__ method in your class, your class is callable, and the __call__ method is executed when you call class instances: 
 
class MyCallable():
    def __call__(self):
        print("You rang?") 

my_instance = MyCallable()
my_instance() # You rang?
 
You can see this in action. If you create your own metaclass by subclassing type, you can cause things to happen when an instance of the class based on your custom metaclass is created. For example: 
 
class MyMeta(type):
    def __call__(self, *args, **kwargs):
        print "call: {} {} {}".format(self, args, kwargs)
        return super().__call__(*args, **kwargs)

# Python 3: 

class MyClass(metaclass = MyMeta):
    pass

# Python 2: 

class MyClass():
    __metaclass__ = MyMeta
    pass
 
Now when you do MyClass(), you can see that the __call__ method of MyMeta happens before anything else (including before __new__ AND before __init__).