Functions

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

def

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

print(add(3, 4))

cmd + enter

Output

Default arguments

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

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

cmd + enter

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))

cmd + enter

123
123
123

Output

Variadic parameters

*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]))

cmd + enter

6
60

Output

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

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

cmd + enter

[('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, as does any positional argument beyond the declared parameters when there is no *args.

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")

cmd + enter

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}))

cmd + enter

Output

lambda

An anonymous function. The 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"))

cmd + enter

42
7
Hi, world

Output

First-class functions

Store functions in data structures and pass them as arguments.

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

cmd + enter

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

Output

# Functions as dict values; replaces switch/case
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))

cmd + enter

7
12
4

Output

Function attributes

Functions carry writable attributes, like any object. getattr / hasattr / setattr / delattr work on them, and an assigned __name__ wins over the declared one. Decorators use these for metadata.

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)

cmd + enter

10
n/a
True

Output

Higher-order functions

Functions that take or return functions.

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

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

cmd + enter

25
10

Output

# Returning a function
def make_adder(n):
  return lambda x: x + n

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

print(add5(3))
print(add10(3))

cmd + enter

8
13

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())

cmd + enter

1
2
3

Output

Because capture is by reference, every lambda 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))

cmd + enter

10 11 12

Output

global and nonlocal

Assignment inside a function creates a local unless declared otherwise. nonlocal name rebinds the nearest enclosing function’s variable. That is the shared cell the counter closure above relies on. global name rebinds the module-level variable.

total = 0

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

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

cmd + enter

Output

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

BASE = 10

def add_base(n):
  return n + BASE

print(add_base(5))

cmd + enter

Output

Recursion

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

print(factorial(10))

cmd + enter

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))

cmd + enter

True False

Output

Pure functions are memoized after two calls with the same arguments. The VM detects purity statically (no I/O, no mutation, no raise, no yield) and confirms it at runtime. Any call that performs a side effect, including a builtin like print passed as a first-class value, marks the call impure and skips the cache, so memoization never drops an effect. Naive recursion runs at memoized cost with no source changes. See Design for the full model.

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)

cmd + enter

Output

def gen():
  yield 1
  yield 2

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

cmd + enter

1
2

Output

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

print(list(naturals(5)))

cmd + enter

[1, 2, 3, 4, 5]

Output

yield from

Delegate to another generator or any iterable.

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

print(list(nums()))

cmd + enter

[0, 1, 2, 10, 20]

Output

yield from is also an expression. It evaluates to the subgenerator’s return value, so a generator can pass a result back to its delegating caller.

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

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

print(list(outer()))

cmd + enter

returned done
[1, 2]

Output

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

Generator expressions

A generator inline.

print(sum(x * x for x in range(5)))
print(max(i for i in [3, 1, 4, 1, 5]))

cmd + enter

30
5

Output

Decorators

A decorator wraps another callable. It applies to both functions and classes (see 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))

cmd + enter

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))

cmd + enter

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")

cmd + enter

hi world
hi world
hi world

Output