问题
From my understanding the __call__ method inside a class implements the function call operator, for example:
class Foo:
def __init__(self):
print("I'm inside the __init__ method")
def __call__(self):
print("I'm inside the __call__ method")
x = Foo() #outputs "I'm inside the __init__ method"
x() #outputs "I'm inside the __call__ method"
However, I'm going through the Python Cookbook and the writer defined a metaclass to control instance creation so that you can't instantiate an object directly. This is how he did it:
class NoInstance(type):
def __call__(self, *args, **kwargs):
raise TypeError("Can't instantaite class directly")
class Spam(metaclass=NoInstance):
@staticmethod
def grok(x):
print("Spam.grok")
Spam.grok(42) #outputs "Spam.grok"
s = Spam() #outputs TypeError: Can't instantaite class directly
However, what I don't get is how s() wasn't called, yet it's __call__ method was called. How does this work?
回答1:
Metaclasses implement how the class will behave (not the instance). So when you look at the instance creation:
x = Foo()
This literally "calls" the class Foo. That's why __call__ of the metaclass is invoked before the __new__ and __init__ methods of your class initialize the instance.
As @Take_Care_ pointed out in the comments one great ressource on metaclasses is ionelmc's blog post about "Understanding Python metaclasses". One image in that blog post directly applies to your situation:
The image is directly copied from the blog post.
回答2:
A class is simply an instance of its metaclass. Since the metaclass defines __call__(), calling the instance of the metaclass, i.e. the class, as a function, i.e. as a constructor, will invoke it.
来源：https://stackoverflow.com/questions/45536595/understanding-call-with-metaclasses