Provides an alternative constructor that returns a new instance when called on the class or a subclass.

Expresses the intent to create an instance via a named constructor, improving code readability and intent.

When a class needs alternative constructors that convey specific construction intent (e.g., from_file, from_string) beyond the primary __init__ signature.

Used in class definitions where alternative constructors are desired, such as factory methods, alternative constructors, or factory patterns.

@classmethod\n\ndef create(cls):\n return cls()

@classmethod\n\ndef create(cls):\n return cls()

cls: the class on which the method is invoked (automatically bound by @classmethod)

• @classmethod
• __init__
• alternative constructors
• factory methods
• @staticmethod

• __init__ (direct instantiation)
• @staticmethod factory functions
• module-level factory functions
• __new__ overrides

Using @classmethod without the cls parameter, causing a TypeError due to missing first argument (cause: forgetting cls; consequence: TypeError when calling). Using self instead of cls inside the method, causing the method to receive an instance rather than the class (cause: confusion with instance methods; consequence: AttributeError or incorrect behavior). Omitting the return statement, causing the method to return None implicitly (cause: missing return; consequence: caller receives None). Calling the method on an instance (obj.create()) which still works but defeats the intent of an alternative constructor (cause: misunderstanding of classmethod binding; consequence: confusing API). Overriding __init__ incorrectly when attempting to customize construction, leading to unexpected initialization (cause: conflating __init__ with factory; consequence: partially initialized objects).

__init__: instance initializer called after object creation, unlike create which returns a new instance. @staticmethod: defines a method that receives neither cls nor self, suitable for utility functions not tied to the class. __new__: low‑level instance creation method that controls object creation before __init__. Factory function: module‑level function that creates instances, not bound to a class. Metaclass __call__: controls class instantiation at the metaclass level.

Coming from Java: may expect static factory methods to be declared with the static keyword; in Python, use @classmethod to receive the class as first argument → use @classmethod and cls parameter. Coming from JavaScript: may try to use the class constructor directly with new Class() and forget alternative constructors; in Python, use ClassName.create() for named constructors. Coming from Ruby: may expect class methods to be defined with self.method; in Python, use @classmethod decorator.

• classmethod
• factory method
• alternative constructor
• factory pattern

(1) When not to use: when simple __init__ suffices and an alternative constructor adds unnecessary complexity. (2) Performance: negligible overhead; method call cost is minimal compared to object creation. (3) Boundary conditions: subclassing works polymorphically—calling SubClass.create() returns an instance of SubClass due to cls binding, enabling polymorphic factories.

Enables expressive, intent‑revealing constructors that improve code readability and reduce reliance on comment‑heavy __init__ overloads.

Think of @classmethod create as a factory method that calls the class itself to build an instance, like a dedicated worker hired by the class to build new workers.

Consider using @dataclass with factory functions or overriding __new__ for more complex instance construction logic.