Functions

def area(width, height):
    """Area of a rectangle.  ← a docstring: what the function is for."""
    return width * height

print(area(3, 4))
print(area(height=2, width=10))   # keyword arguments: order does not matter

def greet(name):
    print(f"Hi, {name}")           # prints, but returns nothing…

result = greet("Ada")
print(result)                      # …so this is None

# Functions are values: you can pass them around
ops = {"double": lambda x: x * 2, "square": lambda x: x ** 2}
print(ops["square"](7))
print(area.__doc__)

def connect(host, port=5432, timeout=30):
    return f"{host}:{port} (timeout {timeout}s)"

print(connect("db.local"))
print(connect("db.local", 6543))
print(connect("db.local", timeout=5))    # skip the middle one by name

# Keyword-only (after *) and positional-only (before /) parameters
def pay(amount, /, *, currency="USD"):
    return f"{amount} {currency}"
print(pay(100, currency="EUR"))

def log(level, *messages, **context):
    print(f"[{level}]", " ".join(str(m) for m in messages), context)

log("INFO", "user", 42, "logged in", ip="10.0.0.1", region="eu")
log("WARN")

# Unpacking in a call
nums = [3, 1, 2]
print(max(*nums))            # max(3, 1, 2)
settings = {"sep": " | ", "end": "!\n"}
print("a", "b", **settings)  # print("a", "b", sep=" | ", end="!\n")

# Forwarding everything — the decorator pattern (Module 09)
def wrapper(*args, **kwargs):
    return log(*args, **kwargs)
wrapper("DEBUG", "forwarded", via="wrapper")

x = "global"

def outer():
    x = "enclosing"
    def inner():
        nonlocal x          # refer to outer's x, not a new local
        x = "changed by inner"
    inner()
    return x

print(outer())
print(x)                    # global x untouched

counter = 0
def bump():
    global counter          # explicitly modify the module-level name
    counter += 1
bump(); bump()
print(counter)

def factorial(n):
    if n <= 1:                 # base case
        return 1
    return n * factorial(n - 1)   # shrink toward it

print(factorial(5))

# Where recursion is the natural tool: nested data
tree = {"name": "root", "children": [
    {"name": "a", "children": [{"name": "a1", "children": []}]},
    {"name": "b", "children": []},
]}

def names(node, depth=0):
    print("  " * depth + node["name"])
    for child in node["children"]:
        names(child, depth + 1)

names(tree)

import sys
print(sys.getrecursionlimit())

square = lambda x: x ** 2          # legal, but PEP 8 says use def for this
print(square(6))

# Where lambda shines: as an argument
words = ["banana", "fig", "apple", "kiwi"]
print(sorted(words, key=lambda w: len(w)))          # by length
print(sorted(words, key=lambda w: (len(w), w)))     # by length, then alphabetically
print(max(words, key=len))                          # a named function works too

rows = [{"city": "Oslo", "temp": 4}, {"city": "Cairo", "temp": 31}]
print(sorted(rows, key=lambda r: r["temp"], reverse=True)[0]["city"])

print(list(map(lambda x: x * 10, [1, 2, 3])))
print(list(filter(lambda x: x % 2 == 0, range(10))))