What is a clean Pythonic way to have multiple constructors in Python

Question

I can t find a definitive answer for this  As far as I know  you can t have multiple   init   functions in a Python class  So how do I solve this problem  Suppose I have a class called Cheese with the number of holes property  How can I have two ways of creating cheese objects     One that takes a number of holes like this  parmesan   Cheese num holes   15  And one that takes no arguments and just randomizes the number of holes property  gouda   Cheese    I can think of only one way to do this  but this seems clunky  class Cheese        def   init   self  num holes   0           if  num holes    0                 Randomize number of holes         else              number of holes   num holes  What do you say  Is there another way

User · Answer

The best answer is the one above about default arguments, but I had fun writing this, and it certainly does fit the bill for "multiple constructors". Use at your own risk.

What about the new method.

"Typical implementations create a new instance of the class by invoking the superclass’s new() method using super(currentclass, cls).new(cls[, ...]) with appropriate arguments and then modifying the newly-created instance as necessary before returning it."

So you can have the new method modify your class definition by attaching the appropriate constructor method.

class Cheese(object):
    def __new__(cls, *args, **kwargs):

        obj = super(Cheese, cls).__new__(cls)
        num_holes = kwargs.get('num_holes', random_holes())

        if num_holes == 0:
            cls.__init__ = cls.foomethod
        else:
            cls.__init__ = cls.barmethod

        return obj

    def foomethod(self, *args, **kwargs):
        print "foomethod called as __init__ for Cheese"

    def barmethod(self, *args, **kwargs):
        print "barmethod called as __init__ for Cheese"

if __name__ == "__main__":
    parm = Cheese(num_holes=5)

User · Answer

class Cheese      def   init   self   args    kwargs              A user-friendly initialiser for the general-purpose constructor                               def  init parmesan self   args    kwargs              A special initialiser for Parmesan cheese                               def  init gauda self   args    kwargs              A special initialiser for Gauda cheese                                classmethod     def make parmesan cls   args    kwargs           new   cls   new   cls          new  init parmesan  args    kwargs          return new       classmethod     def make gauda cls   args    kwargs           new   cls   new   cls          new  init gauda  args    kwargs          return new

User · Answer

This is a pretty clean way I guess and tricky class A object       def   init   self  e  f  g            self   dict   update  k  v for k v in locals   items   if k   self        def bc self           print self f    k   A e 5  f 6  g 12  k bc      gt  gt  gt 6

User · Answer

Why do you think your solution is  clunky   Personally I would prefer one constructor with default values over multiple overloaded constructors in situations like yours  Python does not support method overloading anyway    def   init   self  num holes None       if num holes is None            Construct a gouda     else            custom cheese       common initialization   For really complex cases with lots of different constructors  it might be cleaner to use different factory functions instead    classmethod def create gouda cls       c   Cheese                 return c   classmethod def create cheddar cls               In your cheese example you might want to use a Gouda subclass of Cheese though

User · Answer

Actually None is much better for  magic  values   class Cheese        def   init   self  num holes   None           if num holes is None                    Now if you want complete freedom of adding more parameters   class Cheese        def   init   self   args    kwargs            args -- tuple of anonymous arguments          kwargs -- dictionary of named arguments         self num holes   kwargs get  num holes  random holes      To better explain the concept of  args and   kwargs  you can actually change these names    def f  args    kwargs      print  args     args    kwargs     kwargs   gt  gt  gt  f  a   args     a     kwargs       gt  gt  gt  f ar  a   args       kwargs     ar    a    gt  gt  gt  f 1 2 param 3  args    1  2   kwargs     param   3    http   docs python org reference expressions html calls

User · Answer

Use num holes None as a default  instead  Then check for whether num holes is None  and if so  randomize  That s what I generally see  anyway   More radically different construction methods may warrant a classmethod that returns an instance of cls

User · Answer

Using num holes None as the default is fine if you are going to have just   init     If you want multiple  independent  constructors   you can provide these as class methods  These are usually called factory methods   In this case you could have the default for num holes be 0   class Cheese object       def   init   self  num holes 0            defaults to a solid cheese          self number of holes   num holes       classmethod     def random cls           return cls randint 0  100         classmethod     def slightly holey cls           return cls randint 0  33         classmethod     def very holey cls           return cls randint 66  100     Now create object like this   gouda   Cheese   emmentaler   Cheese random   leerdammer   Cheese slightly holey

User · Answer

All of these answers are excellent if you want to use optional parameters  but another Pythonic possibility is to use a classmethod to generate a factory-style pseudo-constructor   def   init   self  num holes        do stuff with the number   classmethod def fromRandom cls      return cls    some-random-number

User · Answer

Those are good ideas for your implementation  but if you are presenting a cheese making interface to a user   They don t care how many holes the cheese has or what internals go into making cheese   The user of your code just wants  gouda  or  parmesean  right   So why not do this     cheese user py from cheeses import make gouda  make parmesean  gouda   make gouda   paremesean   make parmesean     And then you can use any of the methods above to actually implement the functions     cheeses py class Cheese object       def   init   self   args    kwargs            args -- tuple of anonymous arguments          kwargs -- dictionary of named arguments         self num holes   kwargs get  num holes  random holes     def make gouda        return Cheese    def make paremesean        return Cheese num holes 15    This is a good encapsulation technique  and I think it is more Pythonic   To me this way of doing things fits more in line more with duck typing   You are simply asking for a gouda object and you don t really care what class it is

User · Answer

Since my initial answer was criticised on the basis that my special-purpose constructors did not call the  unique  default constructor  I post here a modified version that honours the wishes that all constructors shall call the default one   class Cheese      def   init   self   args   initialiser   default init     kwargs              A multi-initialiser                      getattr self   initialiser   args    kwargs       def  default init self                   A user-friendly smart or general-purpose initialiser                               def  init parmesan self                   A special initialiser for Parmesan cheese                               def  init gouda self                   A special initialiser for Gouda cheese                                classmethod     def make parmesan cls   args    kwargs           return cls  args    kwargs   initialiser   init parmesan         classmethod     def make gouda cls   args    kwargs           return cls  args    kwargs   initialiser   init gouda

User · Answer

One should definitely prefer the solutions already posted  but since no one mentioned this solution yet  I think it is worth mentioning for completeness   The  classmethod approach can be modified to provide an alternative constructor which does not invoke the default constructor    init     Instead  an instance is created using   new      This could be used if the type of initialization cannot be selected based on the type of the constructor argument  and the constructors do not share code    Example   class MyClass set        def   init   self  filename           self  value   load from file filename        classmethod     def from somewhere cls  somename           obj   cls   new   cls     Does not call   init           super MyClass  obj    init        Don t forget to call any polymorphic base class initializers         obj  value   load from somewhere somename          return obj

User · Answer

This is how I solved it for a YearQuarter class I had to create  I created an   init   which is very tolerant to a wide variety of input  You use it like this   gt  gt  gt  from datetime import date  gt  gt  gt  temp1   YearQuarter year 2017  month 12   gt  gt  gt  print temp1 2017-Q4  gt  gt  gt  temp2   YearQuarter temp1   gt  gt  gt  print temp2 2017-Q4  gt  gt  gt  temp3   YearQuarter  2017  6    gt  gt  gt  print temp3 2017-Q2   gt  gt  gt  temp4   YearQuarter date 2017  1  18    gt  gt  gt  print temp4 2017-Q1  gt  gt  gt  temp5   YearQuarter year 2017  quarter   3   gt  gt  gt  print temp5 2017-Q3  And this is how the   init   and the rest of the class looks like  import datetime   class YearQuarter       def   init   self   args    kwargs           if len args     1               x        args              if isinstance x  datetime date                   self  year        int x year                  self  quarter      int x month    2    3             elif isinstance x  tuple                   year  month       x                  self  year        int year                   month             int month                   if 1  lt   month  lt   12                      self  quarter      month   2    3                 else                      raise ValueError              elif isinstance x  YearQuarter                   self  year        x  year                 self  quarter     x  quarter          elif len args     2              year  month       args              self  year        int year               month             int month               if 1  lt   month  lt   12                  self  quarter      month   2    3             else                  raise ValueError          elif kwargs               self  year        int kwargs  quot year quot                 if  quot quarter quot  in kwargs                  quarter       int kwargs  quot quarter quot                     if 1  lt   quarter  lt   4                      self  quarter       quarter                 else                      raise ValueError             elif  quot month quot  in kwargs                  month     int kwargs  quot month quot                     if 1  lt   month  lt   12                      self  quarter        month   2    3                 else                      raise ValueError      def   str   self           return   0 -Q 1   format self  year  self  quarter

User · Answer

I d use inheritance  Especially if there are going to be more differences than number of holes  Especially if Gouda will need to have different set of members then Parmesan   class Gouda Cheese       def   init   self           super Gouda    init   num holes 10    class Parmesan Cheese       def   init   self           super Parmesan    init   num holes 15

[python] What is a clean, Pythonic way to have multiple constructors in Python?

Examples related to python

Examples related to constructor