Python overload __init__

Question

How do I overload __init__() in Python? I'm used to C/C++ where the compiler can see the difference in data type, but since there are no data types in Python, how can I make sure the third method gets called instead of the second when I give a string as parameter instead of an int?

class Handle:
 def __init__(self):
 self.pid = -1
 def __init__(self, pid):
 self.pid = pid
 def __init__(self, procname):
 print(procname)
 self.pid = -1 # find pid by name

• BrenBarn: What you are doing is called "overloading", not "overriding", and (as the answers given indicate), it's not possible in Python. If you want different behavior based on argument types, you need to write a single method definition that checks the types itself explicitly.
• J. Daniel: @BrenBarn Thanks, you are right I used the wrong term.

Answer 1

In C++ you can define multiple functions/methods with the same name and different signatures. In Python, everytime you define a new function with the same name of a previously defined function, you are replacing it.

To achieve what you want, you have to use optional arguments and/or explicit checks.

Here are a few possible solutions:

class Handle:
 def __init__(self, pid=-1):
 if isinstance(pid, str):
 self.procname = pid
 self.pid = -1
 else:
 self.procname = None
 self.pid = pid

---

class Handle:
 # Both pid and procname may be specified at the same time.
 def __init__(self, pid=-1, procname=None):
 self.procname = procname
 self.pid = pid

---

class Handle:
 # Either pid or procname, not both, may be specified.
 def __init__(self, pid=-1, procname=None):
 if pid >= 0 and procname is not None:
 raise ValueError('you can specify either pid or procname, not both')
 self.procname = procname
 self.pid = pid

---

class Handle:
 def __init__(self, pid=-1):
 self.pid = pid
 # A separate constructor, with a different name,
 # because "explicit is better than implicit" and
 # "sparse is better than dense" (cit. The Zen of
 # Python).
 # In my opinion, this is the most Pythonic solution.
 @classmethod
 def from_process_name(cls, procname):
 pid = get_pid(procname)
 return cls(pid)

---

By the way, I would not recommend using -1 for "not specified". I'd rather use None.

• Kevin: Pet peeve, which you thankfully avoided: Using if x when you really mean if x is not None. The latter is more verbose but often more correct, since '', 0, empty containers, and various other things are falsey.
• Padraic Cunningham: The second last block would crash in multiple cases, comparing an int to any other type would cause a TypeError in python3 and in python2 some non int values would be considered > than 0.
• Andrea Corbellini: @PadraicCunningham: welcome to the world of duck typing :)
• Padraic Cunningham: I think a user getting a TypeError passing a value to the constructor might not be very obvious.
• Andrea Corbellini: Well, if you pass an argument of the wrong type... what exception would you expect?

Answer 2

Couldn't the PEP 443 : Single-dispatch generic functions be useful in your case ?

With something like (very basic example) :

from functools import singledispatch
class Handle:
 def __init__(self, arg=None):
 self.pid = init_from_arg(arg)
@singledispatch
def init_from_arg(arg):
 # If None or neither an integer nor a string, return None
 return None
# If the argument is an integer (ie the pid)
@init_from_arg.register(int)
def _(arg):
 return arg
# If the argument provided is a string (ie the procname)
@init_from_arg.register(str)
def _(arg):
 return get_pid_from_procname(arg)

Edit : Following the advice in comments, these functions could probably be made staticmethods, although I had trouble with them so I reverted to the code of my original answer (see edit history if needed)

• Mike Müller: You can make these functions static methods. Looks a bit cleaner.

Answer 3

Use isinstance to check the type:

class Handle:
 def __init__(self, arg):
 if isinstance(arg, str):
 self.pid = arg
 else:
 self.pid = -1

If you want to do one action or another you might be better setting the arg to None and using it based on whether it is set or not:

class Handle:
 def __init__(self, by_name=None):
 self.by_name = by_name

Then just check later if it is None:

 if self.by_name is not None:
 # find by name
 else:
 # by pid

Of if you want the user to have a choice to pass either a pid or name:

class Handle:
 def __init__(self, by_name=None,by_pid=None):
 self.by_name = by_name
 self.by_pid = by_pid

The simplest solution would be to take a single arg and move the logic wherever you call it, just because something is not None does not make it an int or string so you should also check for that or your program will error:

class Handle:
 def __init__(self, proc):
 self.proc = proc
 if not isinstance(self.proc, (int,str)):
 raise ValueError("Must be process name or pid.")
 def find_proc(self):
 if isinstance(self.proc, str):
 # find by name
 else:
 # by pid

• timgeb: We could maybe improve the author's code a little further with a default value for arg. +1
• Padraic Cunningham: @timgeb, maybe setting to None might be an idea alright