Functions
Contents
Functions¶
Definition¶
We use def to define a function, and return to pass back a value:
def double(x):
return x * 2
print(double(5), double([5]), double("five"))
10 [5, 5] fivefive
Default Parameters¶
We can specify default values for parameters:
def jeeves(name="Sir"):
return "Very good, {}".format(name)
jeeves()
'Very good, Sir'
jeeves("James")
'Very good, James'
If you have some parameters with defaults, and some without, those with defaults must go later.
If you have multiple default arguments, you can specify neither, one or both:
def jeeves(greeting="Very good", name="Sir"):
return "{}, {}".format(greeting, name)
jeeves()
'Very good, Sir'
jeeves("Hello")
'Hello, Sir'
jeeves(name="James")
'Very good, James'
jeeves(greeting="Suits you")
'Suits you, Sir'
jeeves("Hello", "Sailor")
'Hello, Sailor'
Side effects¶
Functions can do things to change their mutable arguments,
so return is optional.
This is pretty awful style, in general, functions should normally be side-effect free.
Here is a contrived example of a function that makes plausible use of a side-effect
def double_inplace(vec):
vec[:] = [element * 2 for element in vec]
z = list(range(4))
double_inplace(z)
print(z)
[0, 2, 4, 6]
letters = ["a", "b", "c", "d", "e", "f", "g"]
letters[:] = []
In this example, we’re using [:] to access into the same list, and write it’s data.
vec = [element*2 for element in vec]
would just move a local label, not change the input.
But I’d usually just write this as a function which returned the output:
def double(vec):
return [element * 2 for element in vec]
Let’s remind ourselves of the behaviour for modifying lists in-place using [:] with a simple array:
x = 5
x = 7
x = ["a", "b", "c"]
y = x
x
['a', 'b', 'c']
x[:] = ["Hooray!", "Yippee"]
y
['Hooray!', 'Yippee']
Early Return¶
Return without arguments can be used to exit early from a function
Here’s a slightly more plausibly useful function-with-side-effects to extend a list with a specified padding datum.
def extend(to, vec, pad):
if len(vec) >= to:
return # Exit early, list is already long enough.
vec[:] = vec + [pad] * (to - len(vec))
x = list(range(3))
extend(6, x, "a")
print(x)
[0, 1, 2, 'a', 'a', 'a']
z = list(range(9))
extend(6, z, "a")
print(z)
[0, 1, 2, 3, 4, 5, 6, 7, 8]
Unpacking arguments¶
def arrow(before, after):
return str(before) + " -> " + str(after)
arrow(1, 3)
'1 -> 3'
If a function that takes multiple arguments is given an iterable object prepended with ‘*’, each element of that object is taken in turn and used to fill the function’s arguments one-by-one.
x = [1, -1]
arrow(*x)
'1 -> -1'
This can be quite powerful:
charges = {"neutron": 0, "proton": 1, "electron": -1}
for particle in charges.items():
print(arrow(*particle))
neutron -> 0
proton -> 1
electron -> -1
Sequence Arguments¶
Similiarly, if a * is used in the definition of a function, multiple
arguments are absorbed into a list inside the function:
def doubler(*sequence):
return [x * 2 for x in sequence]
doubler(1, 2, 3)
[2, 4, 6]
doubler(5, 2, "Wow!")
[10, 4, 'Wow!Wow!']
Keyword Arguments¶
If two asterisks are used, named arguments are supplied inside the function as a dictionary:
def arrowify(**args):
for key, value in args.items():
print(key + " -> " + value)
arrowify(neutron="n", proton="p", electron="e")
neutron -> n
proton -> p
electron -> e
These different approaches can be mixed:
def somefunc(a, b, *args, **kwargs):
print("A:", a)
print("B:", b)
print("args:", args)
print("keyword args", kwargs)
somefunc(1, 2, 3, 4, 5, fish="Haddock")
A: 1
B: 2
args: (3, 4, 5)
keyword args {'fish': 'Haddock'}