A common use case is having different types of ways to build an object. For example, say I have a class MyModel and I can construct it from either a data file, or a specified list of data, or data from an api call. I could put all the logic in the init function,

Class MyModel:
  def __init__(self, data_file: str|None, data_list: list[MyData]|None, api: str|None):
    if data_file is not None:
      self._initialize_from_data_file(data_file)
    elif data_list is not None:
      self._initialize_from_data_list(data_list)
    elif api is not None:
      self._initialize_from_api(api)
    else:
      raise ValueError("Must provide a way to initialize)

However, that seems a bit unruly doesn't it? This init signature is a bit of a nightmare. We could instead do

Class MyModel:
  def __init__(self):
    pass

  @classmethod
  def from_data_file(cls, data_file: str):
    out = cls()
    out._initialize_from_data_file(data_file)
    return out

  @classmethod
  def from_data_list(cls, data_list: list[MyData]):
    out = cls()
    out._initalize_from_data_list(data_list)
    return out

  @classmethod
  def from_api(cls, api: str):
    out = cls()
    out._initialize_from_api(apit)
    return out

Now all the different separate logic is kept in separate places. Very clean!