Basics.
%python
>>>def func(x): print x
... >>>func("spam")
spam >>>func(42)
42 >>>func([1, 2, 3])
[1, 2, 3] >>>func({'food': 'spam'})
{'food': 'spam'}
Arguments.
Here’s what one solution looks like. You have to use
print
to see results in the test calls, because a
file isn’t the same as code typed interactively; Python
doesn’t echo the results of expression statements.
%cat mod.py
def adder(x, y): return x + y print adder(2, 3) print adder('spam', 'eggs') print adder(['a', 'b'], ['c', 'd']) %python mod.py
5 spameggs ['a', 'b', 'c', 'd']
varargs. Two
alternative adder
functions are shown in the
following code. The hard part here is figuring out how to initialize
an accumulator to an empty value of whatever type is passed in. In
the first solution, we use manual type testing to look for an integer
and an empty slice of the first argument (assumed to be a sequence)
otherwise. In the second solution, we just use the first argument to
initialize and scan items 2 and beyond. The second solution is better
(and frankly, comes from students in a Python course, who were
frustrated with trying to understand the first solution). Both of
these assume all arguments are the same type and neither works on
dictionaries; as we saw in Chapter 2,
+
doesn’t work on mixed types or
dictionaries. We could add a type test and special code to add
dictionaries too, but that’s extra credit.
%cat adders.py
def adder1(*args): print 'adder1', if type(args[0]) == type(0): # integer? sum = 0 # init to zero else: # else sequence: sum = args[0][:0] # use empty slice of arg1 for arg in args: sum = sum + arg return sum def adder2(*args): print 'adder2', sum = args[0] # init to arg1 for next in args[1:]: sum = sum + next # add items 2..N return sum for func in (adder1, adder2): print func(2, 3, 4) print func('spam', 'eggs', 'toast') print func(['a', 'b'], ['c', 'd'], ['e', 'f']) %python adders.py
adder1 9 adder1 spameggstoast adder1 ['a', 'b', 'c', 'd', 'e', 'f'] adder2 9 adder2 spameggstoast adder2 ['a', 'b', 'c', 'd', 'e', 'f']
Keywords. Here is
our solution to the first part of this one. To iterate over keyword
arguments, use a **args
for in the function header
and use a loop like: for x in args.keys(): use args[x]
%cat mod.py
def adder(good=1, bad=2, ugly=3): return good + bad + ugly print adder() print adder(5) print adder(5, 6) print adder(5, 6, 7) print adder(ugly=7, good=6, bad=5) %python mod.py
6 10 14 18 18
and 6. Here are our solutions to
Exercises 5 and 6, but Guido has already made them superfluous;
Python 1.5 includes new dictionary methods, to do things like copying
and adding (merging) dictionaries. See Python’s library manual
or the Python Pocket Reference for more details.
X[:]
doesn’t work for dictionaries, since
they’re not sequences (see Chapter 2).
Notice that if we assign (e = d
) rather than copy,
we generate a reference to a shared dictionary object; changing
d
changes e
too.
%cat dict.py
def copyDict(old): new = {} for key in old.keys(): new[key] = old[key] return new def addDict(d1, d2): new = {} for key in d1.keys(): new[key] = d1[key] for key in d2.keys(): new[key] = d2[key] return new %python
>>>from dict import *
>>>d = {1:1, 2:2}
>>>e = copyDict(d)
>>>d[2] = '?'
>>>d
{1: 1, 2: '?'} >>>e
{1: 1, 2: 2} >>>x = {1:1}
>>>y = {2:2}
>>>z = addDict(x, y)
>>>z
{1: 1, 2: 2}
More argument matching examples. Here is the sort of interaction you should get, along with comments that explain the matching that goes on:
def f1(a, b): print a, b # normal args def f2(a, *b): print a, b # positional varargs def f3(a, **b): print a, b # keyword varargs def f4(a, *b, **c): print a, b, c # mixed modes def f5(a, b=2, c=3): print a, b, c # defaults def f6(a, b=2, *c): print a, b, c # defaults + positional varargs %python
>>>f1(1, 2)
# matched by position (order matters) 1 2 >>>f1(b=2, a=1)
# matched by name (order doesn't matter) 1 2 >>>f2(1, 2, 3)
# extra positionals collected in a tuple 1 (2, 3) >>>f3(1, x=2, y=3)
# extra keywords collected in a dictionary 1 {'x': 2, 'y': 3} >>>f4(1, 2, 3, x=2, y=3)
# extra of both kinds 1 (2, 3) {'x': 2, 'y': 3}>>> f5(1)
# both defaults kick in 1 2 3>>> f5(1, 4)
# only one default used 1 4 3>>> f6(1)
# one argument: matches "a" 1 2 ()>>> f6(1, 3, 4)
# extra positional collected 1 3 (4,)