Functions, part 2

Make a day10 folder for today’s files, open it in your editor, and run each script from its terminal, as on earlier days.

On Day 9 you wrote your own functions: def, parameters, return. Every function you wrote needed exactly as many arguments as it had parameters, given in exactly the right order. The built-in functions you have used since Day 1 are more flexible than that. round(7.6) and round(7.6, 1) both work. enumerate(word) counts from 0 and enumerate(word, 1) counts from 1. max takes two numbers, five numbers, or a whole list. Today you learn how to give your own functions that flexibility, and then something new: handing a function to another function, so you can tell sorted(), min(), and max() how to compare things. By the end of the day you will be able to read the first line of any function in the Python documentation and know how to call it.

Day 9’s functions always needed every argument. Suppose you write a greeting function and nearly every call says “Hello”. Typing "Hello" in every call is repetitive, and leaving it out is an error. What you want is an argument the caller can leave out, with a sensible value used in its place. round already works like this: with no second argument it rounds to a whole number.

Recall from Day 9 that a parameter is a name in the function’s definition and an argument is the value you hand over in a call. A parameter can be given a default value: a value written in the def line with =, which Python uses whenever the call leaves that argument out.

def name(required, optional=default_value):

• required has no default, so every call must supply it. It is a required parameter.
• optional=default_value has a default, so a call may leave it out. It is an optional parameter.
• There are no spaces around the = in a parameter list. That is the PEP 8 style for defaults (and for keyword arguments in 10.2), and it helps you tell a default apart from an ordinary assignment.

def greet(name, greeting="Hello"):
    """Return a greeting for name."""
    return f"{greeting}, {name}!"


print(greet("Ana"))
print(greet("Ben", "Welcome"))

Hello, Ana!
Welcome, Ben!

Now change what the default is: a number rather than a string, used in a calculation.

def power(base, exponent=2):
    """Return base raised to exponent. With no exponent, square it."""
    return base ** exponent


print(power(5))
print(power(2, 10))
print(power(10, 0))

25
1024
1

power(5) uses the default exponent 2, giving 5 squared. power(2, 10) gives 2 to the power 10. power(10, 0) is worth a look: the caller passed 0, a value that is falsy (Day 4), but Python still uses it. A default is used only when the argument is missing, never because the value passed looks empty.

def greet(greeting="Hello", name):
    """Return a greeting for name."""
    return f"{greeting}, {name}!"


print(greet("Ana"))

  File ".../day10/default_first.py", line 1
    def greet(greeting="Hello", name):
                                ^^^^
SyntaxError: parameter without a default follows parameter with a default

def ticket(event, seats=1, price=12.5):
    """Return a line describing a ticket order."""
    total = seats * price
    return f"{event}: {seats} x {price} = {total}"


print(ticket("Concert"))
print(ticket("Play", 3))
print(ticket("Film", 2, 8))

Concert: 1 x 12.5 = 12.5
Play: 3 x 12.5 = 37.5
Film: 2 x 8 = 16

So far every argument has been matched to a parameter by its position: first argument to first parameter, second to second. That works for one or two parameters. With three similar ones it becomes easy to put them in the wrong order, and Python cannot notice, because a string is a string.

def make_badge(name, role, team):
    """Return the text for a name badge."""
    return f"{name} | {role} | {team}"


print(make_badge("Ana", "Captain", "Blue"))
print(make_badge("Ana", "Blue", "Captain"))
print(make_badge(team="Blue", name="Ana", role="Captain"))

Ana | Captain | Blue
Ana | Blue | Captain
Ana | Captain | Blue

An argument matched by its place in the call is a positional argument. Day 6 met one other kind, reverse=True in sorted: a keyword argument, written as parameter_name=value in a call. A keyword argument is matched by name, so its position does not matter. Keyword arguments also make a call easier to read, because each value says what it is for.

Keyword arguments really pay off with defaults. In this coffee order, both size and milk are optional. With positional arguments alone, there would be no way to choose the milk without also typing the size, because milk comes second. A keyword argument can skip over a default:

def order(drink, size="medium", milk="whole"):
    """Return a description of a coffee order."""
    return f"A {size} {drink} with {milk} milk"


print(order("latte"))
print(order("latte", "large"))
print(order("latte", milk="oat"))
print(order("mocha", milk="oat", size="small"))

A medium latte with whole milk
A large latte with whole milk
A medium latte with oat milk
A small mocha with oat milk

• order("latte") uses both defaults.
• order("latte", "large") fills size by position.
• order("latte", milk="oat") fills drink by position, skips size (it keeps its default), and sets milk by name.
• The last call gives two keyword arguments in the “wrong” order, which is fine: names, not places, decide where they go.

You have been close to keyword arguments since Day 1. print has two optional parameters that change what it does: sep, the text put between the values (a space by default), and end, the text put after them (a newline by default). You can only set them by keyword:

print("2026", "10", "15", sep="-")
print("a", "b", "c", sep="")
print("Loading", end="")
print("...", end="")
print(" done")

2026-10-15
abc
Loading... done

Line 1 joins its three values with - instead of a space. Line 2 uses the empty string, so nothing goes between them. Lines 3 and 4 use end="", so print does not move to a new line, and the next print carries on where it stopped. Line 5 ends normally, finishing the line.

def order(drink, size="medium", milk="whole"):
    """Return a description of a coffee order."""
    return f"A {size} {drink} with {milk} milk"


print(order(size="large", "latte"))

SyntaxError: positional argument follows keyword argument

def order(drink, size="medium", milk="whole"):
    """Return a description of a coffee order."""
    return f"A {size} {drink} with {milk} milk"


print(order("latte", drink="tea"))

TypeError: order() got multiple values for argument 'drink'

def describe(animal, sound="no sound", legs=4):
    """Return a sentence about an animal."""
    return f"The {animal} has {legs} legs and makes {sound}."


print(describe("bird", legs=2))

Defaults look simple, but one kind of default hides a famous bug. Imagine a shopping cart function: add an item to a cart and return the cart, and if no cart is given, start an empty one. An empty list looks like the obvious default.

Before you see the bug, recall Day 6: b = a does not copy a list. It makes a second name for the same list, so a change made through one name shows through the other. Keep that in mind.

def add_item(item, cart=[]):
    """Add item to cart and return the cart."""
    cart.append(item)
    return cart


first = add_item("apple")
print(first)
second = add_item("bread")
print(second)
print(first is second)

['apple']
['apple', 'bread']
True

The fix is to use a default that cannot be changed, None (“no cart given”), and make the new list inside the function, where the code runs on every call:

def add_item(item, cart=None):
    """Add item to cart and return the cart. With no cart, start a new one."""
    if cart is None:
        cart = []
    cart.append(item)
    return cart


first = add_item("apple")
second = add_item("bread")
print(first)
print(second)
print(first is second)
groceries = ["eggs"]
add_item("milk", groceries)
print(groceries)

['apple']
['bread']
False
['eggs', 'milk']

Lines 3 and 4 run on every call. When cart is None, line 4 makes a brand-new empty list for this call only, so first and second are now different lists. The last three lines show that passing your own list still works: "milk" is added to groceries itself.

Why are "Hello", 2, and 12.5 safe defaults when a list is not? Strings and numbers are immutable: nothing can change them in place, so sharing one is harmless. Lists, dictionaries, and sets are mutable: they can change in place, so a shared one carries changes from call to call. A mutable default argument is a default value that is a list, dictionary, or set.

def tally(word, counts={}):
    """Count one more use of word and return the counts."""
    counts[word] = counts.get(word, 0) + 1
    return counts


print(tally("yes"))
print(tally("no"))
print(tally("yes", {}))
print(tally("yes"))

{'yes': 1}
{'yes': 1, 'no': 1}
{'yes': 1}
{'yes': 2, 'no': 1}

Day 9 asked you to write a function that takes a list of numbers. That works, but the caller has to build a list first. max(3, 9, 4) does not need a list: it takes as many numbers as you give it. How can your own function do that, when you cannot know how many parameters to write?

Recall Day 7’s starred unpacking: in first, *rest = items, the star means “collect everything left over”. A star in front of a parameter means the same thing for a call. A parameter written as *args collects all the leftover positional arguments into a tuple. The name after the star can be anything (*scores, *prices); args, short for arguments, is the name programmers use when there is no better one.

def average(*scores):
    """Return the average of any number of scores."""
    print("scores is", scores)
    return sum(scores) / len(scores)


print(average(85, 90, 78))
print(average(100, 60))
print(average(72))

scores is (85, 90, 78)
84.33333333333333
scores is (100, 60)
80.0
scores is (72,)
72.0

A *args parameter can come after ordinary parameters. The ordinary ones are filled first, from the left, and the star collects whatever is left, which may be nothing at all:

def report(title, *scores):
    """Print a title and a count, then each score on its own line."""
    print(f"{title}: {len(scores)} scores")
    for score in scores:
        print("-", score)


report("Quiz 1", 8, 10, 7)
report("Quiz 2")

Quiz 1: 3 scores
- 8
- 10
- 7
Quiz 2: 0 scores

"Quiz 1" fills title, and the three numbers go into scores. report("Quiz 2") fills title and leaves nothing over, so scores is the empty tuple (): len gives 0 and the for loop runs zero times. An empty *args tuple can catch you out, though. Call average (without its print line) with no arguments, and it divides by len(()), which is 0:

def average(*scores):
    """Return the average of any number of scores."""
    return sum(scores) / len(scores)


print(average())

ZeroDivisionError: division by zero

This is Day 6’s empty-list average again. A real version should check the length first, as biggest_gap does in the question below.

The star works the other way round in a call. If your numbers are already in a list, * in front of the list spreads its items out as separate positional arguments. This is called unpacking the list into the call:

def average(*scores):
    """Return the average of any number of scores."""
    return sum(scores) / len(scores)


marks = [70, 80, 90]
print(average(*marks))
print(*marks)
print(marks)

80.0
70 80 90
[70, 80, 90]

average(*marks) is the same as average(70, 80, 90). print(*marks) is the same as print(70, 80, 90), which prints the three values separated by spaces, while print(marks) prints one value, the list itself.

def average(*scores):
    """Return the average of any number of scores."""
    return sum(scores) / len(scores)


marks = [70, 80, 90]
print(average(marks))

TypeError: unsupported operand type(s) for +: 'int' and 'list'

def biggest_gap(label, *values):
    """Return the label and the gap between the largest and smallest value."""
    if len(values) < 2:
        return f"{label}: need two values"
    return f"{label}: {max(values) - min(values)}"


print(biggest_gap("Temps", 12, 19, 7, 15))
print(biggest_gap("Single", 4))
print(biggest_gap(3, 9))

Temps: 12
Single: need two values
3: need two values

*args collects extra positional arguments. Sometimes you want extra keyword arguments instead: a profile function where one person has an age and a city, and another has a club and a favorite color, and you cannot list every possible detail as a parameter.

A parameter written as **kwargs (two stars) collects all the leftover keyword arguments into a dictionary (Day 8). Each keyword becomes a key, as a string, and the value after = becomes its value. kwargs is short for keyword arguments; again, any name works.

def make_profile(name, **details):
    """Print a profile: the name, then each detail given by keyword."""
    print("details is", details)
    print(f"Profile: {name}")
    for field, value in details.items():
        print(f"  {field}: {value}")


make_profile("Ana", age=15, city="Lima", club="Chess")
make_profile("Ben")

details is {'age': 15, 'city': 'Lima', 'club': 'Chess'}
Profile: Ana
  age: 15
  city: Lima
  club: Chess
details is {}
Profile: Ben

Two stars also work in a call: ** in front of a dictionary unpacks it into keyword arguments, one per key. This is handy when the settings are stored in a dictionary:

def order(drink, size="medium", milk="whole"):
    """Return a description of a coffee order."""
    return f"A {size} {drink} with {milk} milk"


usual = {"size": "large", "milk": "oat"}
print(order("latte", **usual))
print(order("mocha", **usual))

A large latte with oat milk
A large mocha with oat milk

order("latte", **usual) is the same as order("latte", size="large", milk="oat"). Each key must be the name of a parameter.

Keyword-only parameters

A *args parameter swallows every leftover positional argument. So what about a parameter written after it? It can never be filled by position: the star got there first. It can only be set by keyword. A parameter that can only be given by keyword is a keyword-only parameter. That sounds like a limitation, but it is often exactly what you want:

def total_price(*prices, discount=0):
    """Add up any number of prices, then take off a discount (0.1 is 10%)."""
    subtotal = sum(prices)
    return subtotal - subtotal * discount


print(total_price(20, 30, 50))
print(total_price(20, 30, 50, discount=0.1))
print(total_price(20, 30, 50, 0.1))

100
90.0
100.1

• The first call has no discount, so discount is its default 0, and the total is 100.
• The second sets discount=0.1 by keyword: 10% off 100 is 90.0.
• The third shows why the rule is useful. The caller meant 0.1 as the discount, but it was positional, so it went into prices as a fourth price: 100.1. Because discount is keyword-only, a reader of the call total_price(20, 30, 50, discount=0.1) can see at once which number is the discount.

All the kinds of parameter can appear in one def, but only in this order: ordinary parameters, then ones with defaults, then *args, then keyword-only ones, then **kwargs last. This program uses all five, with short names because only the mechanics matter here:

def show(a, b=2, *args, c=3, **kwargs):
    print(a, b, args, c, kwargs)


show(1)
show(1, 5, 6, 7, c=8, d=9)

1 2 () 3 {}
1 5 (6, 7) 8 {'d': 9}

Python fills positions from the left (a, then b), the star takes the rest (6 and 7), keywords that match a parameter go there (c=8), and keywords that match nothing go into the dictionary (d=9).

def make_profile(name, **details):
    """Print a profile: the name, then each detail given by keyword."""
    print(f"Profile: {name}")
    for field, value in details.items():
        print(f"  {field}: {value}")


make_profile("Ana", "Lima")

TypeError: make_profile() takes 1 positional argument but 2 were given

def describe_pizza(size, *toppings, crust="thin", **extras):
    print(f"{size} pizza, {crust} crust")
    print("Toppings:", toppings)
    print("Extras:", extras)


describe_pizza("Large", "olives", "peppers", sauce="spicy", crust="thick")

Large pizza, thick crust
Toppings: ('olives', 'peppers')
Extras: {'sauce': 'spicy'}

Here is a new kind of problem. You have an announce function that prints a message. Sometimes the message should be shouted, sometimes whispered, and next week someone will want a third style. You could add a style parameter holding a string and a long if chain inside announce, and edit that chain every time a style is added. It would be better if the caller could hand over the styling itself: a piece of behavior, not a piece of data.

Python allows this because a function is a value, like a number or a list. def shout(...) does two things: it builds a function object, and it stores it in the name shout, just as count = 0 stores 0 in count. The name without parentheses refers to the function itself. Adding parentheses calls it.

>>> def shout(text):
...     return text.upper() + "!"
...
>>> type(shout)
<class 'function'>
>>> yell = shout
>>> yell("fire drill")
'FIRE DRILL!'
>>> shout("fire drill")
'FIRE DRILL!'
>>> len
<built-in function len>
>>> measure = len
>>> measure("hello")
5

• type(shout) shows the function is a value of type function.
• yell = shout has no parentheses, so nothing is called. It makes yell a second name for the same function, exactly like b = a with a list. yell("fire drill") and shout("fire drill") call the same code.
• Built-in functions are values too. len without parentheses is the function itself, and measure = len gives it a second name.

Because a function is a value, you can pass it as an argument. The parameter then holds a function, and the code inside can call it with parentheses:

def shout(text):
    return text.upper() + "!"


def whisper(text):
    return text.lower() + "..."


def announce(message, style):
    """Print message after passing it through the style function."""
    print(style(message))


announce("Class Starts Now", shout)
announce("Class Starts Now", whisper)

CLASS STARTS NOW!
class starts now...

A function that takes another function as an argument (or returns one) is called a higher-order function. Here is a second one that varies something different: the passed-in function returns True or False, and the higher-order function uses it to decide what to count. This is the counter pattern from Day 5 with the test left blank for the caller to fill in:

def count_if(items, test):
    """Return how many items make test(item) True."""
    count = 0
    for item in items:
        if test(item):
            count += 1
    return count


def is_even(number):
    return number % 2 == 0


def is_big(number):
    return number > 50


numbers = [12, 75, 33, 90, 48]
print(count_if(numbers, is_even))
print(count_if(numbers, is_big))

3
2

Inside count_if, line 5 calls test(item) for each number. With is_even, that is True for 12, 90, and 48, so the count is 3. With is_big, it is True for 75 and 90, so the count is 2. One loop, written once, counts anything you can write a test for.

def shout(text):
    return text.upper() + "!"


def announce(message, style):
    """Print message after passing it through the style function."""
    print(style(message))


announce("Class Starts Now", shout())

TypeError: shout() missing 1 required positional argument: 'text'

count_if is useful, but every test needs its own def: is_even, is_big, and next is_between_30_and_60. Each is one line of real work, used once, with two blank lines around it. For tiny one-use functions, that is a lot of ceremony.

A lambda expression builds a small function right where you need it, without a def and without a name:

lambda parameters: expression

• lambda is a keyword. The parameters come next, separated by commas, then a colon.
• After the colon is one expression. When the function is called, Python works out that expression and returns its value automatically. There is no return keyword.
• The whole thing is an expression whose value is a function, so it can go anywhere a value can: as an argument, in a list, after =.

lambda n: n * 2 means the same as:

def double(n):
    return n * 2

except that the lambda version has no name of its own.

>>> double = lambda n: n * 2
>>> double(21)
42
>>> type(double)
<class 'function'>
>>> (lambda price, quantity: price * quantity)(2.5, 4)
10.0

The first line stores a lambda in a name so you can try it: double(21) is 42, and type shows it is an ordinary function. The last line builds a two-parameter lambda and calls it at once with (2.5, 4), giving 10.0. Both are for seeing how lambdas work. In real code, PEP 8 says: if you want a name, use def. The place where lambdas belong is as an argument:

def count_if(items, test):
    """Return how many items make test(item) True."""
    count = 0
    for item in items:
        if test(item):
            count += 1
    return count


numbers = [12, 75, 33, 90, 48]
print(count_if(numbers, lambda n: n % 2 == 0))
print(count_if(numbers, lambda n: n > 50))
print(count_if(numbers, lambda n: 30 <= n <= 60))

3
2
2

The expression after the colon can be any expression, including a conditional expression from Day 4:

def announce(message, style):
    """Print message after passing it through the style function."""
    print(style(message))


announce("Lunch is served", lambda text: text[:8] + "...")
announce("Lunch is served", lambda text: f"** {text} **")
announce("Hi all", lambda text: text if len(text) <= 8 else text[:8] + "...")

Lunch is...
** Lunch is served **
Hi all

The first lambda keeps the first 8 characters and adds dots. The second wraps the text in stars with an f-string. The third chooses: if the text is at most 8 characters, return it unchanged; otherwise shorten it. "Hi all" has 6 characters, so it comes back as it was.

def count_if(items, test):
    """Return how many items make test(item) True."""
    count = 0
    for item in items:
        if test(item):
            count += 1
    return count


print(count_if([12, 75, 33], lambda n: return n > 50))

SyntaxError: invalid syntax

def apply_to_each(words, change):
    """Return a new list holding change(word) for each word."""
    result = []
    for word in words:
        result.append(change(word))
    return result


words = ["tea", "coffee", "juice"]
print(apply_to_each(words, lambda w: w[0].upper() + w[1:]))
print(apply_to_each(words, lambda w: len(w)))
print(apply_to_each(words, lambda w: w if len(w) > 3 else w * 2))

['Tea', 'Coffee', 'Juice']
[3, 6, 5]
['teatea', 'coffee', 'juice']

Day 6 sorted lists with sorted(), which returns a new sorted list, and sort(), which sorts a list in place. Both put items in their natural order: numbers from smallest to largest, and strings alphabetically, with capitals before small letters (Day 4). But often you want a different order: words by length, names ignoring capitals, students by score. You need a way to tell sorted what to compare.

Both have an optional keyword argument key, which takes a function. Python calls that function once on each item and sorts the items by the values it returns. Those returned values are called the sort keys. The items themselves are not changed: only their order is.

>>> words = ["pear", "Fig", "banana", "kiwi", "apple"]
>>> sorted(words)
['Fig', 'apple', 'banana', 'kiwi', 'pear']
>>> sorted(words, key=len)
['Fig', 'pear', 'kiwi', 'apple', 'banana']
>>> sorted(words, key=str.lower)
['apple', 'banana', 'Fig', 'kiwi', 'pear']
>>> sorted(words, key=len, reverse=True)
['banana', 'apple', 'pear', 'kiwi', 'Fig']
>>> words
['pear', 'Fig', 'banana', 'kiwi', 'apple']
>>> words.sort(key=len)
>>> words
['Fig', 'pear', 'kiwi', 'apple', 'banana']

Look again at pear and kiwi. Both have length 4, a tie. In the result, pear is before kiwi, just as it was in the original list. That is a guarantee, not luck: Python’s sort is stable, meaning items with equal keys keep their original order. Even with reverse=True, the tied pear and kiwi stay in their original order.

The key function can be a lambda, which is how you sort a list of dictionaries (Day 8) by one field:

students = [
    {"name": "Maya", "grade": 10, "score": 88},
    {"name": "Leo", "grade": 9, "score": 95},
    {"name": "Ava", "grade": 10, "score": 95},
    {"name": "Sam", "grade": 9, "score": 72},
]

by_score = sorted(students, key=lambda student: student["score"], reverse=True)
for student in by_score:
    print(student["name"], student["score"])

Leo 95
Ava 95
Maya 88
Sam 72

For each student dictionary, the lambda returns student["score"], so the list is sorted by score, highest first because of reverse=True. Leo and Ava tie on 95, and Leo was earlier in the original list, so stability keeps him first.

Sorting by one field, then another

What if ties should be broken by a second field, say by grade and then, within each grade, by name? A key can be a tuple (Day 7), and Python compares tuples item by item: first items first, and only if those are equal, the second items.

>>> (9, "Sam") < (10, "Ava")
True
>>> (10, "Ava") < (10, "Maya")
True
>>> (9, "Leo") < (9, "Sam")
True

(9, "Sam") is less than (10, "Ava") because 9 is less than 10; the names are never looked at. (10, "Ava") and (10, "Maya") tie on 10, so the names decide. So a key that returns (grade, name) sorts by grade, and by name within a grade:

students = [
    {"name": "Maya", "grade": 10, "score": 88},
    {"name": "Leo", "grade": 9, "score": 95},
    {"name": "Ava", "grade": 10, "score": 95},
    {"name": "Sam", "grade": 9, "score": 72},
]

by_grade_then_name = sorted(
    students, key=lambda student: (student["grade"], student["name"])
)
for student in by_grade_then_name:
    print(student["grade"], student["name"])

9 Leo
9 Sam
10 Ava
10 Maya

words = ["pear", "fig", "banana"]
print(sorted(words, key=len()))

TypeError: len() takes exactly one argument (0 given)

scores = [("Ben", 95), ("Ana", 82), ("Dee", 70), ("Cal", 82)]
print(sorted(scores))
print(sorted(scores, key=lambda pair: pair[1]))
print(sorted(scores, key=lambda pair: pair[1], reverse=True))

[('Ana', 82), ('Ben', 95), ('Cal', 82), ('Dee', 70)]
[('Dee', 70), ('Ana', 82), ('Cal', 82), ('Ben', 95)]
[('Ben', 95), ('Ana', 82), ('Cal', 82), ('Dee', 70)]

Day 6 used min and max to find the smallest and largest number in a list. Like sorted, they compare items in their natural order, and like sorted, they accept a key function to compare something else. With a key, max returns the item whose key is largest, not the key itself.

>>> words = ["pear", "banana", "fig", "cherry"]
>>> max(words)
'pear'
>>> max(words, key=len)
'banana'
>>> min(words, key=len)
'fig'
>>> len(max(words, key=len))
6

• max(words) compares alphabetically: 'pear' comes last.
• max(words, key=len) compares lengths. banana and cherry both have 6 letters. When there is a tie, max and min return the first one, so the result is 'banana'.
• min(words, key=len) gives the shortest word, 'fig'.
• max returns the word, not its length. If you want the length, measure the word it returns: len(max(words, key=len)) is 6.

products = [
    {"name": "pen", "price": 1.5},
    {"name": "notebook", "price": 3.25},
    {"name": "eraser", "price": 0.75},
]
cheapest = min(products, key=lambda product: product["price"])
print(cheapest)
print(f"Cheapest: {cheapest['name']} at ${cheapest['price']:.2f}")

prices = {"pen": 1.5, "notebook": 3.25, "eraser": 0.75}
print(max(prices))
print(max(prices, key=prices.get))

{'name': 'eraser', 'price': 0.75}
Cheapest: eraser at $0.75
pen
notebook

scores = []
best = max(scores)
print("Best score:", best)

ValueError: max() iterable argument is empty

scores = []
best = max(scores, default=None)
print("Best score:", best)

Best score: None

words = ["kiwi", "plum", "fig", "lime", "pear"]
print(max(words, key=len))
print(min(words, key=len))
print(max(words, key=lambda word: word[-1]))

kiwi
fig
pear

You now know every kind of parameter, which means you can read the documentation for any function. The first line of a function’s definition, its name and parameter list, is its signature. It tells you everything about how to call it: which arguments are required, which are optional and what their defaults are, and which must be given by position or by keyword. The Python documentation shows a signature at the top of each function’s entry. Here are some you have used:

round(number, ndigits=None)
enumerate(iterable, start=0)
print(*objects, sep=' ', end='\n', file=None, flush=False)
sorted(iterable, /, *, key=None, reverse=False)
max(iterable, /, *, default, key=None)

Most of this you can already read. round has a required number and an optional ndigits. enumerate has an optional start that defaults to 0, which is how enumerate(word, 1) worked on Day 5. print has *objects, so it takes any number of values, followed by keyword-only parameters with defaults: sep is a space and end is a newline, exactly as you saw in 10.2. Two markers are new:

• A bare * with no name after it means: every parameter after this point is keyword-only. It works like *args without collecting anything. In sorted, key and reverse come after the *, so they must be given by keyword.
• A / means: every parameter before this point is positional-only, so it can never be given by keyword. In sorted, iterable is before the /, so you write sorted(words), never sorted(iterable=words).

You can use both markers in your own functions:

def split_bill(total, /, people=2, *, tip=0.15):
    """Return each person's share of total, with a tip added."""
    return round(total * (1 + tip) / people, 2)


print(split_bill(60))
print(split_bill(60, 3))
print(split_bill(60, people=4, tip=0.2))

34.5
23.0
18.0

The markers are enforced. Break them, and Python says which rule you broke:

def split_bill(total, /, people=2, *, tip=0.15):
    """Return each person's share of total, with a tip added."""
    return round(total * (1 + tip) / people, 2)


print(split_bill(total=60))

TypeError: split_bill() got some positional-only arguments passed as keyword arguments: 'total'

def split_bill(total, /, people=2, *, tip=0.15):
    """Return each person's share of total, with a tip added."""
    return round(total * (1 + tip) / people, 2)


print(split_bill(60, 3, 0.2))

TypeError: split_bill() takes from 1 to 2 positional arguments but 3 were given

The second message says “1 to 2” because only total and people can be filled by position. The third value, meant as the tip, had nowhere to go. The same rules apply to the built-in functions:

>>> sorted([3, 1, 2], reverse=True)
[3, 2, 1]
>>> sorted([3, 1, 2], None, True)
Traceback (most recent call last):
  ...
TypeError: sorted expected 1 argument, got 3
>>> "a,b,c".split(",", maxsplit=1)
['a', 'b,c']
>>> round(3.14159, ndigits=2)
3.14
>>> len(obj="abc")
Traceback (most recent call last):
  ...
TypeError: len() takes no keyword arguments

• sorted([3, 1, 2], reverse=True) follows the signature: the list by position, reverse by keyword.
• sorted([3, 1, 2], None, True) tries to give key and reverse by position. They are after the *, so sorted accepts only 1 positional argument.
• str.split(sep=None, maxsplit=-1) has no markers, so maxsplit=1 can be given by keyword. It stops after one split.
• round(number, ndigits=None) also has no markers, so ndigits=2 works by keyword.
• len takes its one argument by position only, so len(obj="abc") is an error.

Why do these markers exist? Positional-only parameters let the function’s author rename them later without breaking anyone’s code, since no call can use the name. Keyword-only parameters protect calls like total_price from 10.5, where a value in the wrong place would be silently misused, and they make calls such as sorted(scores, reverse=True) say what they mean.

Older entries in the documentation sometimes use square brackets for optional arguments, as in range(start, stop[, step]): the part in brackets may be left out. The brackets are notation for the reader, not Python you type.

resize(image, /, width, height=None, *, keep_ratio=True)

def resize(image, /, width, height=None, *, keep_ratio=True):
    """Pretend to resize an image and describe what would happen."""
    return f"{image}: width {width}, height {height}, keep ratio {keep_ratio}"


print(resize("cat.png", 300, 200, False))

TypeError: resize() takes from 2 to 3 positional arguments but 4 were given

def resize(image, /, width, height=None, *, keep_ratio=True):
    """Pretend to resize an image and describe what would happen."""
    return f"{image}: width {width}, height {height}, keep ratio {keep_ratio}"


print(resize("cat.png", 300))
print(resize("cat.png", width=300, keep_ratio=False))
print(resize("cat.png", 300, 200))

cat.png: width 300, height None, keep ratio True
cat.png: width 300, height None, keep ratio False
cat.png: width 300, height 200, keep ratio True

A game club keeps a leaderboard. Players are dictionaries with a name, points, and wins. The program adds players with any stats they have, ranks them by any field, and prints the top few.

def add_player(players, name, **stats):
    """Add a player to players. Points and wins start at 0 unless given."""
    player = {"name": name, "points": 0, "wins": 0}
    for field, value in stats.items():
        player[field] = value
    players.append(player)


def rank(players, *, by="points", best_first=True):
    """Return a new list of players ordered by one field."""
    return sorted(players, key=lambda player: player[by], reverse=best_first)


def show(players, title="Leaderboard", limit=None):
    """Print a numbered list of players, at most limit of them if given."""
    print(title)
    if limit is not None:
        players = players[:limit]
    for place, player in enumerate(players, 1):
        points = player["points"]
        wins = player["wins"]
        print(f"{place}. {player['name']}: {points} points, {wins} wins")


players = []
add_player(players, "Ana", points=42, wins=3)
add_player(players, "Ben", points=55, wins=2)
add_player(players, "Cal", wins=4, points=42)
add_player(players, "Dee")

show(rank(players))
show(rank(players, by="wins"), title="Most wins", limit=2)
show(rank(players, by="name", best_first=False), "A to Z")
top = max(players, key=lambda player: player["points"])
print("Top scorer:", top["name"])

Leaderboard
1. Ben: 55 points, 2 wins
2. Ana: 42 points, 3 wins
3. Cal: 42 points, 4 wins
4. Dee: 0 points, 0 wins
Most wins
1. Cal: 42 points, 4 wins
2. Ana: 42 points, 3 wins
A to Z
1. Ana: 42 points, 3 wins
2. Ben: 55 points, 2 wins
3. Cal: 42 points, 4 wins
4. Dee: 0 points, 0 wins
Top scorer: Ben

Each function uses today’s ideas:

Follow the three show calls:

• show(rank(players)) uses every default: ranked by points, best first, title Leaderboard, no limit. Ana and Cal tie on 42; Ana was added first, so the stable sort keeps her first.
• show(rank(players, by="wins"), title="Most wins", limit=2) ranks by wins and shows only two rows. players[:limit] (Day 6 slicing) makes a shorter list inside show; the caller’s list is untouched.
• show(rank(players, by="name", best_first=False), "A to Z") sorts names alphabetically, smallest first, and passes the title by position.

Because by and best_first are keyword-only, a call reads rank(players, by="wins") rather than the puzzling rank(players, "wins", True).

Today’s errors are almost all TypeErrors about how arguments match parameters. When you see one, read the end of the message:

Exact wording can differ in older Python versions; the error type and the idea stay the same. The mutable default trap gives no error message at all, which is what makes it dangerous: look for =[] or ={} in a def line.

• Default values make parameters optional; required parameters come first. Keyword arguments (name=value) are matched by name, so they can be in any order and can skip defaults; in a call, positional arguments come first.
• A default is made once, when def runs, so a list or dictionary default is shared by every call. Use None and create the new value inside the function.
• A *args parameter collects extra positional arguments into a tuple, and a **kwargs parameter collects extra keyword arguments into a dictionary; in a call, one or two stars spread a list or dictionary out. Parameters after *args or a bare * are keyword-only; parameters before / are positional-only.
• A function is a value: its name without parentheses can be stored or passed to a higher-order function, and a lambda writes a short one-expression function in place.
• sorted, sort, min, and max take a key function and compare by what it returns; sorted and sort also take reverse=True, and the sort is stable.

Do these in your day10 folder. Type each program yourself, run it, and only then open the answer.

def describe_trip(city, days=3, transport="train"):
    """Return a one-line trip plan."""
    return f"{days} days in {city}, travelling by {transport}"


print(describe_trip("Lisbon"))
print(describe_trip("Lisbon", 5))
print(describe_trip("Lisbon", 5, "plane"))
print(describe_trip(city="Rome", transport="bus"))
print(describe_trip("Oslo", transport="ferry", days=2))

3 days in Lisbon, travelling by train
5 days in Lisbon, travelling by train
5 days in Lisbon, travelling by plane
3 days in Rome, travelling by bus
2 days in Oslo, travelling by ferry

def show(books, heading):
    """Print a heading, then one line per book."""
    print(heading)
    for book in books:
        print(f"  {book['year']} {book['title']} ({book['author']})")


books = [
    {"title": "Dune", "author": "Herbert", "year": 1965},
    {"title": "Emma", "author": "Austen", "year": 1815},
    {"title": "Beloved", "author": "Morrison", "year": 1987},
    {"title": "Persuasion", "author": "Austen", "year": 1817},
    {"title": "Kindred", "author": "Butler", "year": 1979},
]

show(sorted(books, key=lambda book: book["title"]), "By title:")
show(sorted(books, key=lambda book: book["year"]), "By year:")
by_author = sorted(books, key=lambda book: (book["author"], book["year"]))
show(by_author, "By author, then year:")

By title:
  1987 Beloved (Morrison)
  1965 Dune (Herbert)
  1815 Emma (Austen)
  1979 Kindred (Butler)
  1817 Persuasion (Austen)
By year:
  1815 Emma (Austen)
  1817 Persuasion (Austen)
  1965 Dune (Herbert)
  1979 Kindred (Butler)
  1987 Beloved (Morrison)
By author, then year:
  1815 Emma (Austen)
  1817 Persuasion (Austen)
  1979 Kindred (Butler)
  1965 Dune (Herbert)
  1987 Beloved (Morrison)

def apply_twice(func, value):
    """Call func on value, then call func again on that result."""
    return func(func(value))


def double(number):
    return number * 2


def add_exclamation(text):
    return text + "!"


print(apply_twice(double, 5))
print(apply_twice(add_exclamation, "Hello"))
print(apply_twice(lambda n: n ** 2, 3))

20
Hello!!
81

def pack(owner, *items, bag="backpack", max_items=3):
    """Return what fits in the bag, and how many items were left out."""
    kept = items[:max_items]
    left_out = len(items) - len(kept)
    return f"{owner}'s {bag}: {', '.join(kept)} ({left_out} left out)"


print(pack("Ana", "book", "pen"))
print(pack("Ben", "map", "torch", "rope", "tent", bag="duffel"))
print(pack("Cal", "snack", "water", "hat", "gloves", max_items=2))

Ana's backpack: book, pen (0 left out)
Ben's duffel: map, torch, rope (1 left out)
Cal's backpack: snack, water (2 left out)

def log_event(event, log=[]):
    """Add event to a log and return the log."""
    log.append(event)
    return log


monday = log_event("login")
tuesday = log_event("logout")
print("Monday:", monday)
print("Tuesday:", tuesday)

Monday: ['login', 'logout']
Tuesday: ['login', 'logout']

def log_event(event, log=None):
    """Add event to a log and return the log. With no log, start a new one."""
    if log is None:
        log = []
    log.append(event)
    return log


monday = log_event("login")
tuesday = log_event("logout")
print("Monday:", monday)
print("Tuesday:", tuesday)

Monday: ['login']
Tuesday: ['logout']

>>> prices = {"tea": 2.5, "coffee": 3.0, "juice": 2.25}
>>> min(prices)
'coffee'
>>> min(prices.values())
2.25
>>> min(prices, key=prices.get)
'juice'
>>> max(prices, key=prices.get)
'coffee'

operations = {
    "double": lambda n: n * 2,
    "square": lambda n: n * n,
    "negate": lambda n: -n,
}
value = 3
for name, operation in operations.items():
    value = operation(value)
    print(name, value)

double 6
square 36
negate -36

students = [
    {"name": "Maya", "grade": 10, "score": 88},
    {"name": "Leo", "grade": 9, "score": 95},
    {"name": "Ava", "grade": 10, "score": 95},
    {"name": "Sam", "grade": 9, "score": 72},
]

by_name = sorted(students, key=lambda student: student["name"])
by_grade = sorted(by_name, key=lambda student: student["grade"])
for student in by_grade:
    print(student["grade"], student["name"])

9 Leo
9 Sam
10 Ava
10 Maya

>>> print("a", "b", "-")
a b -
>>> print("a", "b", sep="-")
a-b
>>> print("a", "b", sep="-", end="!\n")
a-b!

The official Python Tutorial covers today’s ideas in More Control Flow Tools: More on Defining Functions, including default values, keyword arguments, special parameters (/ and *), arbitrary argument lists, and lambda expressions. The Sorting Techniques guide shows more ways to use key.

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can give a parameter a default value and say which parameters must come first. Reread
• I can call a function with keyword arguments, including skipping a default. Reread
• I can explain why a list default is shared between calls and fix it with None. Reread
• I can write a function that takes any number of arguments with *args. Reread
• I can collect keyword arguments with **kwargs and explain keyword-only parameters. Reread
• I can pass a function to another function without calling it. Reread
• I can write a lambda and say when a def is better. Reread
• I can sort a list of dictionaries by one field, and by two. Reread
• I can find the item with the largest or smallest key with max and min. Reread
• I can read a signature with / and * and write a valid call. Reread