# python – How to overload __init__ method based on argument type?

## The Question :

347 people think this question is useful

Let’s say I have a class that has a member called data which is a list.

I want to be able to initialize the class with, for example, a filename (which contains data to initialize the list) or with an actual list.

What’s your technique for doing this?

Do you just check the type by looking at __class__?

Is there some trick I might be missing?

• Possible duplicate of What is a clean, pythonic way to have multiple constructors in Python?
• @And or vice versa? (I mean this is the older question)
• @Wolf I won’t say which is the better topic between the two, but older questions often get closed as dupes of newer ones when the newer one is better quality/has better answers/covers the topic in a more broadly applicable way.

468 people think this answer is useful

A much neater way to get ‘alternate constructors’ is to use classmethods. For instance:

>>> class MyData:
...     def __init__(self, data):
...         "Initialize MyData from a sequence"
...         self.data = data
...
...     @classmethod
...     def fromfilename(cls, filename):
...         "Initialize MyData from a file"
...         return cls(data)
...
...     @classmethod
...         "Initialize MyData from a dict's items"
...
>>> MyData([1, 2, 3]).data
[1, 2, 3]
>>> MyData.fromfilename("/tmp/foobar").data
['foo\n', 'bar\n', 'baz\n']
>>> MyData.fromdict({"spam": "ham"}).data
[('spam', 'ham')]



The reason it’s neater is that there is no doubt about what type is expected, and you aren’t forced to guess at what the caller intended for you to do with the datatype it gave you. The problem with isinstance(x, basestring) is that there is no way for the caller to tell you, for instance, that even though the type is not a basestring, you should treat it as a string (and not another sequence.) And perhaps the caller would like to use the same type for different purposes, sometimes as a single item, and sometimes as a sequence of items. Being explicit takes all doubt away and leads to more robust and clearer code.

39 people think this answer is useful

Excellent question. I’ve tackled this problem as well, and while I agree that “factories” (class-method constructors) are a good method, I would like to suggest another, which I’ve also found very useful:

Here’s a sample (this is a read method and not a constructor, but the idea is the same):

def read(self, str=None, filename=None, addr=0):
""" Read binary data and return a store object. The data
store is also saved in the interal 'data' attribute.

The data can either be taken from a string (str
argument) or a file (provide a filename, which will
be read in binary mode). If both are provided, the str
will be used. If neither is provided, an ArgumentError
is raised.
"""
if str is None:
if filename is None:
raise ArgumentError('Please supply a string or a filename')

file = open(filename, 'rb')
file.close()
...
... # rest of code



The key idea is here is using Python’s excellent support for named arguments to implement this. Now, if I want to read the data from a file, I say:

obj.read(filename="blob.txt")



And to read it from a string, I say:

obj.read(str="\x34\x55")



This way the user has just a single method to call. Handling it inside, as you saw, is not overly complex

20 people think this answer is useful

with python3, you can use Implementing Multiple Dispatch with Function Annotations as Python Cookbook wrote:

import time

class Date(metaclass=MultipleMeta):
def __init__(self, year:int, month:int, day:int):
self.year = year
self.month = month
self.day = day

def __init__(self):
t = time.localtime()
self.__init__(t.tm_year, t.tm_mon, t.tm_mday)



and it works like:

>>> d = Date(2012, 12, 21)
>>> d.year
2012
>>> e = Date()
>>> e.year
2018



13 people think this answer is useful

Quick and dirty fix

class MyData:
def __init__(string=None,list=None):
if string is not None:
#do stuff
elif list is not None:
#do other stuff
else:
#make data empty



Then you can call it with

MyData(astring)
MyData(None, alist)
MyData()



9 people think this answer is useful

A better way would be to use isinstance and type conversion. If I’m understanding you right, you want this:

def __init__ (self, filename):
if isinstance (filename, basestring):
# filename is a string
else:
# try to convert to a list
self.path = list (filename)



4 people think this answer is useful

You should use isinstance

isinstance(...)
isinstance(object, class-or-type-or-tuple) -> bool

Return whether an object is an instance of a class or of a subclass thereof.
With a type as second argument, return whether that is the object's type.
The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for
isinstance(x, A) or isinstance(x, B) or ... (etc.).



2 people think this answer is useful

You probably want the isinstance builtin function:

self.data = data if isinstance(data, list) else self.parse(data)



-1 people think this answer is useful

OK, great. I just tossed together this example with a tuple, not a filename, but that’s easy. Thanks all.

class MyData:
def __init__(self, data):
self.myList = []
if isinstance(data, tuple):
for i in data:
self.myList.append(i)
else:
self.myList = data

def GetData(self):
print self.myList



a = [1,2]

b = (2,3)

c = MyData(a)

d = MyData(b)

c.GetData()

d.GetData()

[1, 2]

[2, 3]

-1 people think this answer is useful

Why don’t you go even more pythonic?

class AutoList:
def __init__(self, inp):
try:                        ## Assume an opened-file...
except AttributeError:
try:                    ## Assume an existent filename...
with open(inp, 'r') as fd:
except:
self.data = inp     ## Who cares what that might be?



-1 people think this answer is useful

My preferred solution is:

class MyClass:
_data = []
__init__(self,data=None):
# do init stuff
if not data: return
self._data = list(data) # list() copies the list, instead of pointing to it.



Then invoke it with either MyClass() or MyClass([1,2,3]).

Hope that helps. Happy Coding!