Functions, Arguments & Scope¶

def full_signature(
    pos_only_a, pos_only_b, /,   # positional-only (zone 1)
    normal_c, normal_d,          # positional-or-keyword (zone 2)
    *args,                       # var-positional (zone 3)
    kw_only_e, kw_only_f=10,     # keyword-only (zone 4)
    **kwargs                     # var-keyword (zone 5)
):
    print(f"pos_only : {pos_only_a}, {pos_only_b}")
    print(f"normal   : {normal_c}, {normal_d}")
    print(f"args     : {args}")
    print(f"kw_only  : {kw_only_e}, {kw_only_f}")
    print(f"kwargs   : {kwargs}")

full_signature(1, 2, 3, 4, 5, 6, kw_only_e=99, color="red")

# This would FAIL – pos_only_a cannot be passed by name:
# full_signature(pos_only_a=1, pos_only_b=2, normal_c=3, normal_d=4, kw_only_e=9)

# ❌ Classic bug
def append_item_bad(item, lst=[]):
    lst.append(item)
    return lst

print(append_item_bad("a"))   # ['a']
print(append_item_bad("b"))   # ['a', 'b']  ← shared state!
print(append_item_bad("c"))   # ['a', 'b', 'c']

# ✅ Correct pattern: sentinel None, create inside body
def append_item_good(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

print(append_item_good("a"))  # ['a']
print(append_item_good("b"))  # ['b']  ← fresh list every time

# Inspect the shared default object
print(append_item_bad.__defaults__)   # (['a', 'b', 'c'],)

x = "global"          # G

def outer():
    x = "enclosing"   # E (from inner's perspective)

    def inner():
        x = "local"   # L
        print(x)      # → 'local'

    inner()
    print(x)          # → 'enclosing'

outer()
print(x)              # → 'global'
print(len)            # → built-in len function (B layer)

# global: reach up to module scope
counter = 0

def increment():
    global counter       # without this, Python creates a local 'counter'
    counter += 1

increment(); increment()
print(counter)   # 2

# nonlocal: reach up to nearest enclosing function scope (not global)
def make_counter():
    count = 0

    def tick():
        nonlocal count   # bind to enclosing 'count', not module
        count += 1
        return count

    return tick

c = make_counter()
print(c(), c(), c())   # 1 2 3

# nonlocal vs global: key difference
x = 100
def outer2():
    x = 200
    def inner2():
        nonlocal x       # reaches outer2's x=200, NOT module x=100
        x += 1
        print(x)         # 201
    inner2()
    print(x)             # 201

outer2()
print(x)                 # still 100 – module x untouched

import math

# Store in a variable
my_sqrt = math.sqrt
print(my_sqrt(16))   # 4.0

# Store in a list / dict (dispatch table)
ops = {
    "add": lambda a, b: a + b,
    "mul": lambda a, b: a * b,
    "pow": pow,
}
print(ops["pow"](2, 10))   # 1024

# Higher-order: pass as argument
def apply_twice(fn, value):
    return fn(fn(value))

print(apply_twice(lambda x: x * 3, 2))   # 18

# Higher-order: return from function
def multiplier(n):
    def mult(x):
        return x * n
    return mult

triple = multiplier(3)
print(triple(7))   # 21
print(type(triple))   # <class 'function'>

from typing import Optional

def parse_price(raw: str, currency: str = "USD") -> Optional[float]:
    """Convert a price string like '$12.99' to a float."""
    cleaned = raw.lstrip("$£€")
    try:
        return float(cleaned)
    except ValueError:
        return None

# Annotations are stored on the function object
print(parse_price.__annotations__)
# {'raw': <class 'str'>, 'currency': <class 'str'>, 'return': typing.Optional[float]}

# Inspect module gives richer introspection
import inspect
sig = inspect.signature(parse_price)
for name, param in sig.parameters.items():
    print(f"  {name}: default={param.default!r}, annotation={param.annotation}")

from functools import partial

def power(base, exponent):
    return base ** exponent

# Freeze the exponent, create specialised functions
square = partial(power, exponent=2)
cube   = partial(power, exponent=3)

print(square(5))   # 25
print(cube(4))     # 64

# Practical: freeze a logging function's level
import logging
logging.basicConfig(level=logging.DEBUG)
debug = partial(logging.log, logging.DEBUG)
warn  = partial(logging.log, logging.WARNING)

debug("Cache miss for key=%s", "user:42")
warn("Rate limit reached for IP=%s", "10.0.0.1")

# partial preserves the original function for introspection
print(square.func)       # <function power at ...>
print(square.keywords)   # {'exponent': 2}