I read here and here that Python methods can be aliased using =.
However, when I try it on the __init__ method, it doesn't seem to work.
class MyClass:
def __init__(self):
print("Hi mum!")
new_name = __init__
a = MyClass()
b = MyClass.new_name()
The b = MyClass.new_name() causes this error:
TypeError: __init__() missing 1 required positional argument: 'self'
Why does this not work? And how should I alias __init__ correctly?
__init__ is not a constructor. __new__ is. __init__ is an instance method that performs initialization on an instance after it is constructed by the static method __new__. The reason why both __new__ and __init__ are called when you call the class with MyClass() is because it is what the __call__ method of the type, or metaclass, of MyClass, does.
So if you want to properly alias the constructor of a class you can alias the __call__ method of its metaclass:
class AliasedConstructor(type):
new_name = type.__call__
class MyClass(metaclass=AliasedConstructor):
def __init__(self):
print("Hi mum!")
MyClass.new_name()
Alternatively, you can make the alias a classmethod descriptor that binds type.__call__ to the current class:
class MyClass:
def __init__(self):
print("Hi mum!")
new_name = classmethod(type.__call__)
Both approaches would output:
Hi mum!
MyClass(), that the __call__ method of the metaclass is called. I've updated my answer to do away from a metaclass. +1 to your answer too.The __init__ method was aliased. But __init__ is not a constructor to begin with.
You could probably do:
MyClass.new_name = MyClass.__call__
If you want things to "just work".
This is assuming your class doesn't define a __call__ method that would shadow type.__call__.
But this is rather weird to begin with, IMO. Just define a classmethod.
new_namestatic or class method that returns newMyClassobject.__init__method expects the positional argumentself, as you can see by it's definition. When you call thenew_namemethod explicitly from the class, there is no positional argument passed, like there is implicitly when instantiating a new objectnew_namea static method seems inconvenient because if the parameters of__init__change, then I also have to update the parameters ofnew_name, and the arguments toMyClass(...)insidenew_name.__new__method of a class to create an instance without it automatically calling the__init__method. So you could do something likeb = MyClass.new_name(MyClass.__new__(MyClass)). You'll have to modify the__init__method to returnselfthough, so thatbpoints to the instance created