"MetaClass", "__new__", "cls" and "super" - can someone explain the mechanism exactly

Question

I have read posts like these:

1. What is a metaclass in Python?
2. What are your (concrete) use-cases for metaclasses in Python?
3. Python's Super is nifty, but you can't use it

but somehow I got confused, many confusions like

when and why i would have to do something like this

#refer link1
return super(MyType, cls).__new__(cls, name, bases, newattrs)

or

#refer link2
return super(MetaSingleton, cls).__call__(*args, **kw)

or

#refer link2
return type(self.__name__ + other.__name__, (self, other), {})

how does super work exactly?

what is class registry and unregistry in link1 and how it exactly works? (I thought it has something to do with singleton, I may be wrong, being from C background, my coding style is still a mix of functional and OO).

Can someone explain the flow of class instantiation (subclass, metaclass, super, type) and method invocation (

metaclass->__new__, metaclass->__init__, super->__new__, subclass->__init__ inherited from metaclass

) with a well commented working code (though the first link is quite close, but does not talk about cls keyword and super(..) and registry). Preferably an example with multiple inheritance.

P.S.: made the last part as code because SO formatting was converting the text metaclass->__new__ to metaclass->new

For experts here: please feel free to correct the question if there is a snag.

Answer 1

Here's the more pragmatic answer.

It rarely matters

1. "What is a metaclass in Python". Bottom line, type is the metaclass of all classes. You have almost no practical use for this.

   class X(object):
       pass
   type(X) == type
   

2. "What are your (concrete) use cases for metaclasses in Python?". Bottom line. None.

3. "Python's Super is nifty, but you can't use it". Interesting note, but little practical value. You'll never have a need for resolving complex multiple inheritance networks. It's easy to prevent this problem from arising by using an explicity Strategy design instead of multiple inheritance.

Here's my experience over the last 7 years of Python programming.

1. A class has 1 or more superclasses forming a simple chain from my class to object.

2. The concept of "class" is defined by a metaclass named type. I might want to extend the concept of "class", but so far, it's never come up in practice. Not once. type always does the right thing.

3. Using super works out really well in practice. It allows a subclass to defer to it's superclass. It happens to show up in these metaclass examples because they're extending the built-in metaclass, type.

   However, in all subclass situations, you'll make use of super to extend a superclass.

Metaclasses

The metaclass issue is this:

• Every object has a reference to it's type definition, or "class".

• A class is, itself, also an object.

• Therefore a object of type class has a reference to it's type or "class". The "class" of a "class" is a metaclass.

Since a "class" isn't a C++ run-time object, this doesn't happen in C++. It does happen in Java, Smalltalk and Python.

A metaclass defines the behavior of a class object.

• 90% of your interaction with a class is to ask the class to create a new object.

• 10% of the time, you'll be using class methods or class variables ("static" in C++ or Java parlance.)

I have found a few use cases for class-level methods. I have almost no use cases for class variables. I've never had a situation to change the way object construction works.

Answer 2

A very useful link http://cleverdevil.org/computing/78/ found it lately, so posting it for interest of all. It came on Reddit actually.