Right now I have this class:
class foo():
def __init__(self):
self.l = []
Right now, I can set a variable to foo without an argument in the parameter because it doesn't take one, but how can I allow this continue to take no required parameters, but also put in a list if I wanted into foo()? Example:
>>> f = foo([1,2,3]) #would be legal and
>>> f = foo() # would be legal
def __init__(self, items=None):
if items is None: items = []
self.l = items
In response to @Eastsun's edit, I propose a different structure to __init__
def __init__(self, items=()):
''' Accepts any iterable
The appropriate TypeError will be raised if items is not iterable '''
self.l = list(items)
Note that lowercase l is a bad name, it can be confused with 1
def __init__(self, items=None):
self.l = items or []
Or
def __init__(self, items=None):
self.l = items if items else []
Edit in response to Dougal's comment.
(I have been learning Python about two weeks, so here is just my personal opinion. Correct me if I am wrong.)
In a programming language like python, it is hard to prevent someone passing an unwanted type of object to your function or method.
In my idea, the security way to assure the __init__ always work is like this:
def __init__(self, items = None):
if isinstance(items, Iterable):
self.l = list(items)
elif items is None:
self.l = []
else:
raise TypeError('items must be iterable')
Note: the above method always make a shallow copy if items is already a list.
is None.xs = numpy.array([1]); ys = numpy.array([]); zs = ys or xs, it seems worked fine.numpy.array([1, 1]) or True. You happened to pick the one example where it does work. :)class foo():
def __init__(self, items=[]):
self.l = items
a = foo(); b = foo(); a.l.append(1). Then b.l == [1]. Mutable objects as default arguments are a Bad Idea™ unless you're absolutely sure it's okay.items