Using the __call__ method of a metaclass instead of __new__?

The direct answer to your question is: when you want to do more than just customize instance creation, or when you want to separate what the class does from how it's created.

See my answer to Creating a singleton in Python and the associated discussion.

There are several advantages.

1. It allows you to separate what the class does from the details of how it's created. The metaclass and class are each responsible for one thing.

2. You can write the code once in a metaclass, and use it for customizing several classes' call behavior without worrying about multiple inheritance.

3. Subclasses can override behavior in their __new__ method, but __call__ on a metaclass doesn't have to even call __new__ at all.

4. If there is setup work, you can do it in the __new__ method of the metaclass, and it only happens once, instead of every time the class is called.

There are certainly lots of cases where customizing __new__ works just as well if you're not worried about the single responsibility principle.

But there are other use cases that have to happen earlier, when the class is created, rather than when the instance is created. It's when these come in to play that a metaclass is necessary. See What are your (concrete) use-cases for metaclasses in Python? for lots of great examples.

The subtle differences become a bit more visible when you carefully observe the execution order of these methods.

class Meta_1(type):    def __call__(cls, *a, **kw):        print "entering Meta_1.__call__()"        rv = super(Meta_1, cls).__call__(*a, **kw)        print "exiting Meta_1.__call__()"        return rvclass Class_1(object):    __metaclass__ = Meta_1    def __new__(cls, *a, **kw):        print "entering Class_1.__new__()"        rv = super(Class_1, cls).__new__(cls, *a, **kw)        print "exiting Class_1.__new__()"        return rv    def __init__(self, *a, **kw):        print "executing Class_1.__init__()"        super(Class_1,self).__init__(*a, **kw)

Note that the code above doesn't actually do anything other than log what we're doing. Each method defers to its parent implementation i.e. its default. So beside logging it's effectively as if you had simply declared things as follows:

class Meta_1(type): passclass Class_1(object):    __metaclass__ = Meta_1

And now let's create an instance of Class_1

c = Class_1()# entering Meta_1.__call__()# entering Class_1.__new__()# exiting Class_1.__new__()# executing Class_1.__init__()# exiting Meta_1.__call__()

Therefore if type is the parent of Meta_1 we can imagine a pseudo implementation of type.__call__() as such:

class type:    def __call__(cls, *args, **kwarg):        # ... a few things could possibly be done to cls here... maybe... or maybe not...        # then we call cls.__new__() to get a new object        obj = cls.__new__(cls, *args, **kwargs)        # ... a few things done to obj here... maybe... or not...        # then we call obj.__init__()        obj.__init__(*args, **kwargs)        # ... maybe a few more things done to obj here        # then we return obj        return obj

Notice from the call order above that Meta_1.__call__() (or in this case type.__call__()) is given the opportunity to influence whether or not calls to Class_1.__new__() and Class_1.__init__() are eventually made. Over the course of its execution Meta_1.__call__() could return an object that hasn't even been touched by either. Take for example this approach to the singleton pattern:

class Meta_2(type):    __Class_2_singleton__ = None    def __call__(cls, *a, **kw):        # if the singleton isn't present, create and register it        if not Meta_2.__Class_2_singleton__:            print "entering Meta_2.__call__()"            Meta_2.__Class_2_singleton__ = super(Meta_2, cls).__call__(*a, **kw)            print "exiting Meta_2.__call__()"        else:            print ("Class_2 singleton returning from Meta_2.__call__(), "                    "super(Meta_2, cls).__call__() skipped")        # return singleton instance        return Meta_2.__Class_2_singleton__class Class_2(object):    __metaclass__ = Meta_2    def __new__(cls, *a, **kw):        print "entering Class_2.__new__()"        rv = super(Class_2, cls).__new__(cls, *a, **kw)        print "exiting Class_2.__new__()"        return rv    def __init__(self, *a, **kw):        print "executing Class_2.__init__()"        super(Class_2, self).__init__(*a, **kw)

Let's observe what happens when repeatedly trying to create an object of type Class_2

a = Class_2()# entering Meta_2.__call__()# entering Class_2.__new__()# exiting Class_2.__new__()# executing Class_2.__init__()# exiting Meta_2.__call__()b = Class_2()# Class_2 singleton returning from Meta_2.__call__(), super(Meta_2, cls).__call__() skippedc = Class_2()# Class_2 singleton returning from Meta_2.__call__(), super(Meta_2, cls).__call__() skippedprint a is b is cTrue

Now observe this implementation using a class' __new__() method to try to accomplish the same thing.

import randomclass Class_3(object):    __Class_3_singleton__ = None    def __new__(cls, *a, **kw):        # if singleton not present create and save it        if not Class_3.__Class_3_singleton__:            print "entering Class_3.__new__()"            Class_3.__Class_3_singleton__ = rv = super(Class_3, cls).__new__(cls, *a, **kw)            rv.random1 = random.random()            rv.random2 = random.random()            print "exiting Class_3.__new__()"        else:            print ("Class_3 singleton returning from Class_3.__new__(), "                   "super(Class_3, cls).__new__() skipped")        return Class_3.__Class_3_singleton__     def __init__(self, *a, **kw):        print "executing Class_3.__init__()"        print "random1 is still {random1}".format(random1=self.random1)        # unfortunately if self.__init__() has some property altering actions        # they will affect our singleton each time we try to create an instance         self.random2 = random.random()        print "random2 is now {random2}".format(random2=self.random2)        super(Class_3, self).__init__(*a, **kw)

Notice that the above implementation even though successfully registering a singleton on the class, does not prevent __init__() from being called, this happens implicitly in type.__call__() (type being the default metaclass if none is specified). This could lead to some undesired effects:

a = Class_3()# entering Class_3.__new__()# exiting Class_3.__new__()# executing Class_3.__init__()# random1 is still 0.282724600824# random2 is now 0.739298365475b = Class_3()# Class_3 singleton returning from Class_3.__new__(), super(Class_3, cls).__new__() skipped# executing Class_3.__init__()# random1 is still 0.282724600824# random2 is now 0.247361634396c = Class_3()# Class_3 singleton returning from Class_3.__new__(), super(Class_3, cls).__new__() skipped# executing Class_3.__init__()# random1 is still 0.282724600824# random2 is now 0.436144427555d = Class_3()# Class_3 singleton returning from Class_3.__new__(), super(Class_3, cls).__new__() skipped# executing Class_3.__init__()# random1 is still 0.282724600824# random2 is now 0.167298405242print a is b is c is d# True

One difference is that by defining a metaclass __call__ method you are demanding that it gets called before any of the class's or subclasses's __new__ methods get an opportunity to be called.

class MetaFoo(type):    def __call__(cls,*args,**kwargs):        print('MetaFoo: {c},{a},{k}'.format(c=cls,a=args,k=kwargs))class Foo(object):    __metaclass__=MetaFooclass SubFoo(Foo):    def __new__(self,*args,**kwargs):        # This never gets called        print('Foo.__new__: {a},{k}'.format(a=args,k=kwargs)) sub=SubFoo() foo=Foo() # MetaFoo: <class '__main__.SubFoo'>, (),{} # MetaFoo: <class '__main__.Foo'>, (),{}

Notice that SubFoo.__new__ never gets called. In contrast, if you define Foo.__new__ without a metaclass, you allow subclasses to override Foo.__new__.

Of course, you could define MetaFoo.__call__ to call cls.__new__, but that's up to you. By refusing to do so, you can prevent subclasses from having their __new__ method called.

I don't see a compelling advantage to using a metaclass here. And since "Simple is better than complex", I'd recommend using __new__.