Arguments in depth

Position decides

A taxi charges a starting fare plus 12 birr per kilometre (lesson 1.2). This version takes the distance first, then the starting fare. Predict:

def taxi_fare(km, base):
    return base + km * 12

print(taxi_fare(10, 15))

135

Python doesn't guess which number is which. A positional argumentpositional argumentAn argument matched to a parameter by its place in the call: the first argument to the first parameter, and so on. goes to the parameter in the same place, so swapping them changes the answer:

def taxi_fare(km, base):
    return base + km * 12

print(taxi_fare(10, 15))
print(taxi_fare(15, 10))

Arguments by name

You can also name the parameter in the call. A keyword argumentkeyword argumentAn argument written as name=value in the call. It goes to the parameter with that name, wherever it is. goes to the parameter with that name, so its place doesn't matter, and the call says what each number means:

def taxi_fare(km, base):
    return base + km * 12

print(taxi_fare(base=15, km=10))
print(taxi_fare(10, base=15))

The second call mixes both. That works when the positional arguments come first. The other way round, Python can't tell which place 15 is meant for:

Every parameter needs exactly one value. Leave one out, or give one too many, and the error names the function and counts for you:

Default values

Most prices use the standard 15% VAT, so make that the rate unless the call says otherwise. rate=0.15 in the def gives rate a default valuedefault valueA value written in the def, like rate=0.15. The parameter gets it whenever a call leaves that argument out.:

def vat(price, rate=0.15):
    return price * (1 + rate)

print(vat(1000))
print(vat(1000, rate=0.05))

The first call leaves rate out, so it's 0.15. The second passes 0.05 (an example rate), which replaces the default for that call only. Parameters with defaults come after the ones without.

A default that remembers

A default value is made once, when def runs, not at each call. For a number that never matters, because a number can't change. For a list, it does. Predict:

def add(item, items=[]):
    items.append(item)
    return items

print(add(1))
print(add(2))

[1]
[1, 2]

Step through it. The default list is kept with the function, so it's there before any call, and it stays after each call ends:

Both calls' items refer to one list, and so do first and second. That's lesson 4.8 again: one list with several names, so a change through one name shows through all of them. The only surprise is when the list was made: once, when def ran. The fix is to use None as the default and make a new list inside the call, which runs every time:

def add(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add(1))
print(add(2))

Use None as the default for any list, dict, or set.

Two markers you'll see in documentation

Python's documentation writes sorted as sorted(iterable, /, *, key=None, reverse=False). The two markers are rules about how to pass arguments. Parameters before a / must be positional: you can't write sorted(iterable=...). Parameters after a * must be keyword arguments: reverse only works as reverse=True.

print(sorted([2, 3, 1], reverse=True))

Your own functions can use them too. A / after price makes it positional only:

You won't need either marker for a long time, but now you can read them.