Language

Functions

Functions are values. Pass them, return them, store them and compose them.

def

def add(a, b):
  return a + b

print(add(3, 4))

{}

Output

Default arguments

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

print(greet("world"))
print(greet("world", "Hi"))

{}

Hello, world!
Hi, world!

Output

Keyword arguments

def f(x, y, z):
  return x * 100 + y * 10 + z

print(f(1, 2, 3))
print(f(x=1, z=3, y=2))
print(f(1, z=3, y=2))

{}

123
123
123

Output

Variadic parameters

A function without *args rejects extra positional arguments with TypeError. The two variadic forms collect what the declared parameters do not take.

*args collects extra positional arguments into a tuple.
**kwargs collects extra keyword arguments into a dict.

def total(*nums):
  return sum(nums)

print(total(1, 2, 3))
print(total(*[10, 20, 30]))

{}

6
60

Output

def opts(**kwargs):
  return sorted(kwargs.items())

print(opts(host="api", port=443))

{}

[('host', 'api'), ('port', 443)]

Output

Keyword-only parameters

A bare * marks the following parameters as keyword-only. They must be passed by name. A positional argument that would reach them raises TypeError.

def connect(host, *, port=80, secure=False):
  return f"{host}:{port} secure={secure}"

print(connect("api"))
print(connect("api", port=443, secure=True))

try:
  connect("api", 443) # positional can't fill a keyword-only param
except TypeError:
  print("rejected")

{}

api:80 secure=False
api:443 secure=True
rejected

Output

Argument unpacking at the call site

def f(a, b, c):
  return a + b + c

print(f(*[1, 2, 3]))
print(f(*[1, 2], 3))
print(f(**{"a": 1, "b": 2, "c": 3}))
print(f(1, **{"b": 2, "c": 3}))

{}

Output

lambda

A lambda is an anonymous function. Its body is a single expression.

double = lambda x: x * 2
print(double(21))

add = lambda a, b: a + b
print(add(3, 4))

# With defaults
greet = lambda name, msg="Hi": f"{msg}, {name}"
print(greet("world"))

{}

42
7
Hi, world

Output

Functions as values

A function can sit in a list or a dict, travel as an argument and come back as a result.

ops = [abs, hex, str]
print([f(-3) for f in ops])

{}

[3, '-0x3', '-3']

Output

A dict of functions replaces a switch statement.

handlers = {
  "add": lambda a, b: a + b,
  "mul": lambda a, b: a * b,
  "max": max,
}

print(handlers["add"](3, 4))
print(handlers["mul"](3, 4))
print(handlers["max"](3, 4))

{}

7
12
4

Output

A higher-order function takes or returns a function.

def apply(f, x):
  return f(x)

print(apply(lambda n: n * n, 5))
print(apply(abs, -10))

def make_adder(n):
  return lambda x: x + n

add5 = make_adder(5)
add10 = make_adder(10)
print(add5(3))
print(add10(3))

{}

Output

Closures

An inner function captures the variables of its enclosing scope by reference.

def counter():
  count = 0
  def step():
    nonlocal count
    count += 1
    return count
  return step

tick = counter()
print(tick())
print(tick())
print(tick())

{}

1
2
3

Output

Capture is by reference. Every lambda made in a loop sees the same loop variable. Bind the current value through a default argument.

def make_adders(n):
  return [lambda x, i=i: x + i for i in range(n)]

add0, add1, add2 = make_adders(3)
print(add0(10), add1(10), add2(10))

{}

10 11 12

Output

global and nonlocal

Assignment inside a function creates a local unless declared otherwise.

nonlocal name rebinds the variable of the nearest enclosing function. The counter closure above relies on it.
global name rebinds the module-level variable.

total = 0

def bump(n):
  global total
  total += n

bump(3)
bump(4)
print(total)

{}

Output

Reading an outer variable needs no declaration. Only rebinding does.

BASE = 10

def add_base(n):
  return n + BASE

print(add_base(5))

{}

Output

Recursion

def factorial(n):
  if n < 2:
    return 1
  return n * factorial(n - 1)

print(factorial(10))

{}

Output

# Mutual recursion
def is_even(n):
  return True if n == 0 else is_odd(n - 1)

def is_odd(n):
  return False if n == 0 else is_even(n - 1)

print(is_even(10), is_odd(10))

{}

True False

Output

A pure function called again with the same immutable positional arguments can return a cached result without running its body. Design lists when the cache applies.

Generators

A function containing yield produces its sequence lazily. Pull values with next() or iterate with for.

def squares(n):
  for i in range(n):
    yield i * i

for x in squares(5):
  print(x)

{}

Output

def gen():
  yield 1
  yield 2

g = gen()
print(next(g))
print(next(g))

{}

1
2

Output

# Materialize a generator
def naturals(limit):
  n = 1
  while n <= limit:
    yield n
    n += 1

print(list(naturals(5)))

{}

[1, 2, 3, 4, 5]

Output

yield from

yield from delegates to another generator or any iterable.

def nums():
  yield from range(3)
  yield from [10, 20]

print(list(nums()))

{}

[0, 1, 2, 10, 20]

Output

yield from is also an expression. It evaluates to the return value of the subgenerator. A generator can pass a result back to the one that delegates to it.

def sub():
  yield 1
  yield 2
  return 'done'

def outer():
  result = yield from sub()
  print('returned', result)

print(list(outer()))

{}

returned done
[1, 2]

Output

Generators are one-way producers. gen.send(value), gen.throw(exc) and gen.close() are not exposed. For flow in both directions, use the cooperative scheduler and pass values through arguments and return values.

Generator expressions

A generator expression is a generator written inline. It computes each value when asked and can be read once.

print(sum(x * x for x in range(5)))
squares = (x * x for x in range(3))
print(next(squares), list(squares), list(squares))

{}

30
0 [1, 4] []

Output

Decorators

A decorator wraps another callable. It applies to functions and to classes.

def trace(f):
  def wrapped(*args):
    print(f"calling with {args}")
    return f(*args)
  return wrapped

@trace
def add(a, b):
  return a + b

print(add(3, 4))

{}

calling with (3, 4)
7

Output

Stacked decorators apply bottom-up.

def double_result(f):
  return lambda *a: f(*a) * 2

def add_one(f):
  return lambda *a: f(*a) + 1

@double_result
@add_one
def base(x):
  return x

# base(5) -> add_one -> 6 -> double_result -> 12
print(base(5))

{}

Output

A parameterized decorator is a factory. The outer function takes the decorator arguments and returns the actual decorator. The wrapped function captures both scopes.

def repeat(n):
  def decorator(fn):
    def wrapped(x):
      for i in range(n):
        fn(x)
    return wrapped
  return decorator

@repeat(3)
def greet(name):
  print(f"hi {name}")

greet("world")

{}

hi world
hi world
hi world

Output

Function attributes

Functions carry writable attributes, like any object. Decorators use them for metadata.

getattr, hasattr, setattr and delattr work on them.
An assigned __name__ wins over the declared one.

def sma(source, length):
  return sum(source) / length

sma.window = 10
print(sma.window)
print(getattr(sma, "missing", "n/a"))

def tag(fn):
  fn.tagged = True
  return fn

@tag
def step():
  pass
print(step.tagged)

{}

10
n/a
True

Output

ClassesInheritance, properties and the dunder protocol.BuiltinsThe builtin functions and what each one returns.