Advanced Functions & Parameters Masterclass

# Positional vs Keyword Arguments

# Positional arguments - order matters
def greet(name, age):
    print(name, age)

greet("Alice", 25)

# Keyword arguments - order doesn't matter
greet(name="Alex", age=20)
greet(age=20, name="Alex")

# Keyword arguments improve:
# ✔ clarity
# ✔ safety
# ✔ order-independent calls
# ✔ API design

def create_user(role="guest"):  # String is immutable - safe!
    return {"role": role}

print(create_user())        # {'role': 'guest'}
print(create_user("admin")) # {'role': 'admin'}

def add_item(item, items=[]):  # ❌ List created ONCE when function defined!
    items.append(item)
    return items

print(add_item(1))  # [1] - looks fine...
print(add_item(2))  # [1, 2] - WAIT, where did 1 come from?!
print(add_item(3))  # [1, 2, 3] - They all share the SAME list!

def add_item(item, items=None):  # ✅ None is safe
    if items is None:
        items = []  # Create NEW list each time
    items.append(item)
    return items

print(add_item(1))  # [1]
print(add_item(2))  # [2] - Fresh list each time!
print(add_item(3))  # [3] - Each call is independent

def total(*numbers):  # *numbers catches ALL positional args
    print(f"Received: {numbers}")  # It's a tuple!
    return sum(numbers)

print(total(1, 2, 3))         # Can pass 3 args
print(total(5, 10, 15, 20))   # Or 4 args
print(total(100))             # Or just 1!

def build_user(**info):  # **info catches ALL keyword args
    print(f"Received: {info}")  # It's a dictionary!
    return info

user = build_user(name="Alex", age=20, role="admin")
print(user)  # {'name': 'Alex', 'age': 20, 'role': 'admin'}

nums = [1, 2, 3]
print(*nums)  # 1 2 3

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

print(add(*nums))

data = {"x": 1, "y": 2}

def show(x, y):
    print(x, y)

show(**data)

def apply(fn, value):
    return fn(value)

print(apply(lambda n: n*n, 5))  # 25

def double(x):
    return x * 2

print(apply(double, 10))  # 20

users = [{"name": "Alex", "age": 20}, {"name": "Sam", "age": 30}]
sorted_users = sorted(users, key=lambda u: u["age"])
print(sorted_users)

def counter():
    count = 0  # This is the "backpack" variable
    
    def inc():
        nonlocal count  # ← "I want to MODIFY count, not create a new one"
        count += 1
        return count
    
    return inc  # Return the inner function (with its backpack!)

# Create a counter - it remembers its own count
c = counter()
print(c())  # 1 - count is remembered!
print(c())  # 2 - still remembering!
print(c())  # 3 - it persists!

# Create another counter - it has its OWN backpack
c2 = coun
...

def logger(fn):
    def wrapper(*args, **kwargs):
        print("Calling:", fn.__name__)
        return fn(*args, **kwargs)
    return wrapper

@logger
def greet():
    print("Hello!")

greet()

def multiply_by(n):
    def inner(x):
        return n * x
    return inner

double = multiply_by(2)
triple = multiply_by(3)
print(double(10))  # 20
print(triple(10))  # 30

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

print(factorial(5))  # 120

from functools import lru_cache

@lru_cache(maxsize=None)  # ← This one line adds caching!
def fib(n):
    if n < 2: 
        return n
    return fib(n-1) + fib(n-2)

# Without @lru_cache, fib(30) would take forever
# With it, it's instant!
print(fib(30))  # 832040 - calculated instantly!
print(fib(50))  # 12586269025 - still instant!

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

print(add(5, 3))

x = 0
def inc():
    global x
    x += 1

inc()
print(x)

from contextlib import contextmanager

@contextmanager
def timer():
    import time
    start = time.time()
    yield
    print(f"Elapsed: {time.time() - start}s")

with timer():
    sum(range(1000000))

import time

def rate_limit(max_calls, interval):
    calls = []

    def decorator(fn):
        def wrapper(*args, **kwargs):
            nonlocal calls
            now = time.time()

            calls = [t for t in calls if now - t < interval]

            if len(calls) >= max_calls:
                raise Exception("Rate limit exceeded")

            calls.append(now)
            return fn(*args, **kwargs)
        return wrapper
    return decorator

@rate_limit(3, 5)
def fetch_data():
    pri
...

def multiply(a):      # First call: pass 'a'
    def inner(b):     # Second call: pass 'b'
        return a * b  # Use both!
    return inner

# Create specialized functions
double = multiply(2)  # "Lock in" 2 as first argument
triple = multiply(3)  # "Lock in" 3 as first argument

print(double(10))  # 20 (2 * 10)
print(triple(10))  # 30 (3 * 10)

from functools import partial

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

# Pre-fill exponent=2 → creates a "square" function
square = partial(power, exponent=2)

# Pre-fill exponent=3 → creates a "cube" function  
cube = partial(power, exponent=3)

print(square(5))  # 25 (5²)
print(cube(5))    # 125 (5³)

def hello(name: str) -> str:
    return f"Hello {name}"

print(hello.__name__)
print(hello.__annotations__)
print(hello.__code__.co_argcount)

def modify(func):
    def wrapper(*a, **kw):
        result = func(*a, **kw)
        return f"[Modified] {result}"
    return wrapper

@modify
def greet():
    return "Hello"

print(greet())  # [Modified] Hello

def compose(f, g):
    return lambda x: f(g(x))

def increment(x): return x + 1
def double(x): return x * 2

pipeline = compose(double, increment)
print(pipeline(5))  # (5+1)*2 = 12

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, value):
        return value * self.factor

double = Multiplier(2)
print(double(10))  # 20

from functools import singledispatch

@singledispatch
def display(x):
    print("Default:", x)

@display.register(int)
def _(x):
    print("Integer:", x)

@display.register(list)
def _(x):
    print("List:", x)

display(10)
display([1,2,3])

def repeat(n):
    def wrapper(func):
        def inner(*a, **kw):
            for _ in range(n):
                func(*a, **kw)
        return inner
    return wrapper

@repeat(3)
def greet():
    print("Hello")

greet()

def safe(func):
    def wrapper(*a, **kw):
        try:
            return func(*a, **kw)
        except Exception as e:
            print("Error:", e)
    return wrapper

@safe
def risky(x):
    return 10 / x

risky(0)  # prints error instead of crashing

import time

def slow():
    sum(i*i for i in range(20000))

start = time.perf_counter()
slow()
end = time.perf_counter()

print("Time:", end - start)

def api_client(base_url):
    def make_request(endpoint):
        def call(**params):
            print("GET", base_url + endpoint, params)
        return call
    return make_request

github = api_client("https://api.github.com")
get_user = github("/users")
get_user(username="torvalds")

def select(*fields):
    return {"select": fields}

def where(**conditions):
    return {"where": conditions}

query = {**select("name", "age"), **where(id=5)}
print(query)

def serializer(fmt):
    if fmt == "json":
        import json
        return json.dumps
    if fmt == "repr":
        return repr

to_json = serializer("json")
print(to_json({"key": "value"}))

def middleware_chain(func_list):
    def call(value):
        for f in func_list:
            value = f(value)
        return value
    return call

pipeline = middleware_chain([
    lambda x: x + 1,
    lambda x: x * 5,
    str
])

print(pipeline(10))  # "55"

class Descriptor:
    def __get__(self, instance, owner):
        return "Got value"

    def __set__(self, instance, value):
        print("Set:", value)

class Demo:
    x = Descriptor()

d = Demo()
print(d.x)
d.x = 10

class Meta(type):
    def __new__(cls, name, bases, attrs):
        attrs['created_by'] = 'Meta'
        return super().__new__(cls, name, bases, attrs)

class User(metaclass=Meta):
    pass

print(User.created_by)

PLUGINS = {}

def plugin(name):
    def register(func):
        PLUGINS[name] = func
        return func
    return register

@plugin("compress")
def compress(data):
    return data[:10]

print(PLUGINS)

def rescue(default=None):
    def wrapper(func):
        def inner(*a, **kw):
            try: return func(*a, **kw)
            except: return default
        return inner
    return wrapper

@rescue(default="failed")
def risky(x):
    return 10/x

print(risky(0))  # "failed"

from functools import partial

def logistic(x, L, k, x0):
    return L / (1 + 2.71828 ** (-k*(x-x0)))

fast_logistic = partial(logistic, L=1, k=0.5)

print(fast_logistic(10, x0=5))

import time

def ttl_cache(seconds):
    def wrapper(func):
        store = {}
        def inner(*a):
            now = time.time()
            if a in store:
                value, t = store[a]
                if now - t < seconds:
                    return value
            result = func(*a)
            store[a] = (result, now)
            return result
        return inner
    return wrapper

@ttl_cache(5)
def expensive():
    return "computed"

def counter():
    n = 0
    def inner():
        nonlocal n
        n += 1
        return n
    return inner

c = counter()
print(c())  # 1
print(c())  # 2

def compose(*functions):
    def pipeline(value):
        for f in functions:
            value = f(value)
        return value
    return pipeline

clean = compose(
    lambda x: x.strip(),
    lambda x: x.lower(),
    lambda x: x.replace("!", "")
)

print(clean("  HELLO!  "))

callbacks = []

def on_event(func):
    callbacks.append(func)
    return func

@on_event
def notify():
    print("Notified!")

for f in callbacks:
    f()

def processor():
    total = 0
    while True:
        x = yield total
        total += x

p = processor()
next(p)
print(p.send(5))  # 5
print(p.send(3))  # 8

from functools import wraps
import inspect

def rename_args(**new_names):
    def wrapper(func):
        sig = inspect.signature(func)
        print("Original sig:", sig)
        return func
    return wrapper

@rename_args(x="value")
def test(x):
    pass

class Pipeline:
    def __init__(self):
        self.steps = []

    def step(self, func):
        self.steps.append(func)
        return func

    def run(self, input):
        for f in self.steps:
            input = f(input)
        return input

p = Pipeline()

@p.step
def clean(x): return x.strip()

@p.step
def lower(x): return x.lower()

print(p.run("  HELLO  "))