class 方法如何成为替代构造函数，因为它们只返回我们的对象？ 在 python

Question

The purpose of constructors is to initialize the state of the object. init in python much behaves like a constructor in python as it initialize the state of the objects. But I read that classmethods are also used as alternative constructors. How? I am not getting this point. How classmethods acts as constructors? See the code below:

class ABC:
   def __init___(self,name)
       self.name=name
   @classmethod
   def from_string(cls,name):
       return cls(name)     # Here classmethod "from_string"  just returns me an object.So 
                            # How can we say that this class method act as constructor? as it
                            # just gives me an object. And the purpose of constructor is not
                            # create an object but to initialize the state of object. Please
                            # clarify this confusion. Thanks
                              

Answer 1

What is meant by "alternative constructor" is best illustrated:

>>> from datetime import datetime
>>> datetime(2020, 1, 1)
datetime.datetime(2020, 1, 1, 0, 0)
>>> datetime.now()
datetime.datetime(2022, 9, 1, 14, 50, 43, 536862)

You can either instantiate the class with datetime(...) and pass it the required arguments, or you use datetime.now() which also simply gives you an instance of the datetime class, but fills in the values with the current time. It's an alternative way to construct/instantiate the class with different functionality than the main constructor has.

Answer 2

Not all languages make a distinction between construction and initialization. Python does. __new__ creates an object (usually, by delegating to an inherited __new__ ; object.__new__ is the only way to really create a new object) or returns an existing object. __init__ receives that object as an argument to further initialize it. (Whether __init__ gets called depends on whether cls.__new__ returns an instance of cls ; it isn't required to, but usually does.)

A class method is used to implement an alternate constructor because it can behave much like __new__ . It receives the class and some other arguments, and in this scenario returns an object, usually by calling the __new__ method (indirectly, by calling the class) with arguments derived from its own.

Here's a simple example:

class A:
    # trivial constructor: it just defers to super().__new__
    # You could leave this undefined.
    def __new__(cls, a):
        return super().__new__(cls)

    def __init__(self, a):
        self.a = a

    @classmethod
    def from_pair(cls, x, y):
        return cls(x + y)

a1 = A(6)
a2 = A.from_pair(2, 4)

Both a1 and a2 produce instances of A whose a attribute is 6 . The from_pair class method acts as an alternate constructor in that it creates an instance of A , but hides the details of how the two arguments are used to do so.