Advanced Functions

Sometimes you do not know how many arguments a function will receive. Python provides two special syntax features - *args and **kwargs - that allow functions to accept any number of arguments. These are essential for writing flexible, reusable code.

Using *args

The *args parameter collects any number of positional arguments into a tuple. The name "args" is a convention; you can use any name after the asterisk. Inside the function, args behaves like a regular tuple - you can iterate over it, check its length, or access elements by index.

def sum_all(*args):
    """Sum any number of arguments."""
    total = 0
    for num in args:
        total += num
    return total

print(sum_all(1, 2))           # Output: 3
print(sum_all(1, 2, 3, 4, 5))  # Output: 15
print(sum_all(10))             # Output: 10

# Combine with regular parameters
def greet(greeting, *names):
    for name in names:
        print(f"{greeting}, {name}!")

Using **kwargs

The **kwargs parameter collects any number of keyword arguments into a dictionary. This is useful for functions that need to accept arbitrary named options, configuration settings, or metadata. The keys become strings matching the argument names, and the values are the passed values.

def build_profile(**kwargs):
    """Build a user profile from keyword arguments."""
    for key, value in kwargs.items():
        print(f"{key}: {value}")

build_profile(name="Alice", age=25, city="NYC")
# Output:
# name: Alice
# age: 25
# city: NYC

# Combine all parameter types
def complex_func(required, *args, **kwargs):
    print(f"Required: {required}")
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

Unpacking with * and **

You can also use * and ** to unpack sequences and dictionaries when calling functions.

# Unpack a list as positional arguments
numbers = [1, 2, 3, 4, 5]
print(sum_all(*numbers))  # Same as sum_all(1, 2, 3, 4, 5)

# Unpack a dict as keyword arguments
user_data = {"name": "Bob", "age": 30, "job": "Developer"}
build_profile(**user_data)

# Combine both
def create_message(template, *values, **options):
    msg = template.format(*values)
    if options.get("uppercase"):
        msg = msg.upper()
    return msg

def multiply_all(*args):
    result = 1
    for num in args:
        result *= num
    return result

print(multiply_all(2, 3))         # Output: 6
print(multiply_all(2, 3, 4))      # Output: 24
print(multiply_all(1, 2, 3, 4, 5)) # Output: 120

def make_tag(tag, **kwargs):
    attrs = " ".join(f'{k}="{v}"' for k, v in kwargs.items())
    if attrs:
        return f"<{tag} {attrs}>"
    return f"<{tag}>"

print(make_tag("div", id="main", class_="container"))
# Output: 

print(make_tag("img", src="photo.jpg", alt="Photo"))
# Output: 

def log_message(level, *args, **kwargs):
    message = " ".join(str(a) for a in args)
    meta = " | ".join(f"{k}={v}" for k, v in kwargs.items())
    if meta:
        print(f"[{level}] {message} ({meta})")
    else:
        print(f"[{level}] {message}")

log_message("INFO", "User", "logged", "in", user="alice")
# Output: [INFO] User logged in (user=alice)
log_message("ERROR", "Connection", "failed", code=500, retry=True)
# Output: [ERROR] Connection failed (code=500 | retry=True)

def merge_dicts(*dicts):
    result = {}
    for d in dicts:
        result.update(d)
    return result

# Test
d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}
d3 = {"c": 5, "d": 6}

print(merge_dicts(d1, d2))       # {'a': 1, 'b': 3, 'c': 4}
print(merge_dicts(d1, d2, d3))   # {'a': 1, 'b': 3, 'c': 5, 'd': 6}

Lambda functions are small, anonymous functions defined in a single line. They are useful for short operations, especially when passing functions as arguments to other functions like map(), filter(), and sorted().

def square(x):
    return x ** 2

square = lambda x: x ** 2

Basic Lambda

Lambda functions can replace simple one-line functions. They are often assigned to variables or passed directly to other functions.

# Regular function
def square(x):
    return x ** 2

# Equivalent lambda
square = lambda x: x ** 2

print(square(5))  # Output: 25

# Lambda with multiple parameters
add = lambda a, b: a + b
print(add(3, 4))  # Output: 7

# Lambda in-line (no variable)
print((lambda x: x * 2)(10))  # Output: 20

Lambda with Built-in Functions

Lambdas shine when used with functions like map(), filter(), and sorted() that take a function as an argument.

# sorted() with lambda key
students = [("Alice", 85), ("Bob", 92), ("Carol", 78)]
by_score = sorted(students, key=lambda s: s[1], reverse=True)
print(by_score)  # [('Bob', 92), ('Alice', 85), ('Carol', 78)]

# filter() with lambda
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4, 6, 8, 10]

# map() with lambda
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)  # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

is_even = lambda x: x % 2 == 0

print(is_even(4))  # Output: True
print(is_even(7))  # Output: False

people = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
    {"name": "Carol", "age": 35}
]

by_age = sorted(people, key=lambda p: p["age"])
print(by_age)
# [{'name': 'Bob', 'age': 25}, 
#  {'name': 'Alice', 'age': 30}, 
#  {'name': 'Carol', 'age': 35}]

numbers = list(range(1, 11))

# Filter odd numbers, then square them
odds = filter(lambda x: x % 2 != 0, numbers)
squared_odds = list(map(lambda x: x ** 2, odds))

print(squared_odds)  # [1, 9, 25, 49, 81]

grade = lambda score: "Pass" if score >= 60 else "Fail"

print(grade(75))  # Output: Pass
print(grade(45))  # Output: Fail
print(grade(60))  # Output: Pass

# Using with map
scores = [85, 42, 67, 55, 90]
results = list(map(grade, scores))
print(results)  # ['Pass', 'Fail', 'Pass', 'Fail', 'Pass']

Decorators are functions that wrap other functions to extend their behavior without modifying their code. They are one of Python's most powerful features, enabling clean separation of concerns and reusable functionality like logging, timing, authentication, and caching.

Creating a Decorator

A decorator is a function that takes a function as input and returns a new function that usually calls the original.

def my_decorator(func):
    def wrapper():
        print("Before the function")
        func()
        print("After the function")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()
# Output:
# Before the function
# Hello!
# After the function

Decorators with Arguments

To create decorators that work with functions taking arguments, use *args and **kwargs to pass through all parameters.

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start:.4f} seconds")
        return result
    return wrapper

@timer
def slow_function(n):
    total = sum(range(n))
    return total

result = slow_function(1000000)
# Output: slow_function took 0.0312 seconds

Common Decorator Use Cases

Decorators are used for logging, authentication, caching, validation, and more. Here is a practical logging decorator.

def log_calls(func):
    def wrapper(*args, **kwargs):
        args_str = ", ".join(repr(a) for a in args)
        kwargs_str = ", ".join(f"{k}={v!r}" for k, v in kwargs.items())
        all_args = ", ".join(filter(None, [args_str, kwargs_str]))
        print(f"Calling {func.__name__}({all_args})")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result!r}")
        return result
    return wrapper

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

add(3, 5)
# Calling add(3, 5)
# add returned 8

def add_greeting(func):
    def wrapper():
        print("Hello!")
        func()
    return wrapper

@add_greeting
def introduce():
    print("Nice to meet you.")

introduce()
# Output:
# Hello!
# Nice to meet you.

def double_result(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result * 2
    return wrapper

@double_result
def get_number(n):
    return n

print(get_number(5))   # Output: 10
print(get_number(21))  # Output: 42

def retry(func):
    def wrapper(*args, **kwargs):
        for attempt in range(1, 4):
            try:
                print(f"Attempt {attempt}")
                return func(*args, **kwargs)
            except Exception as e:
                if attempt == 3:
                    raise
                print(f"Failed: {e}, retrying...")
    return wrapper

@retry
def risky_operation():
    import random
    if random.random() < 0.7:
        raise ValueError("Random failure!")
    return "Success!"

def count_calls(func):
    def wrapper(*args, **kwargs):
        wrapper.calls += 1
        print(f"{func.__name__} called {wrapper.calls} times")
        return func(*args, **kwargs)
    wrapper.calls = 0
    return wrapper

@count_calls
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")  # say_hello called 1 times \n Hello, Alice!
say_hello("Bob")    # say_hello called 2 times \n Hello, Bob!
print(say_hello.calls)  # 2

# Select options above

Higher-order functions are functions that take other functions as arguments or return functions as results. This powerful concept enables functional programming patterns in Python, making code more modular, reusable, and expressive.

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

apply(str.upper, "hello")  # "HELLO"

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

add5 = make_adder(5)  # Returns a function

Functions as Arguments

In Python, functions are first-class objects. You can pass them as arguments to other functions just like any other value.

def apply_operation(func, x, y):
    """Apply any two-argument function to x and y."""
    return func(x, y)

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

def multiply(a, b):
    return a * b

print(apply_operation(add, 5, 3))       # Output: 8
print(apply_operation(multiply, 5, 3))  # Output: 15

Built-in Higher-Order Functions

Python provides several built-in higher-order functions that operate on iterables using a function you provide.

# map() applies a function to each element
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# filter() keeps elements where function returns True
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4]

# reduce() accumulates values (from functools)
from functools import reduce
total = reduce(lambda acc, x: acc + x, numbers, 0)
print(total)  # 15

Functions Returning Functions

A higher-order function can also return a new function. This pattern is useful for creating specialized or configured functions.

def make_multiplier(n):
    """Return a function that multiplies by n."""
    def multiplier(x):
        return x * n
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))  # Output: 10
print(triple(5))  # Output: 15
print(double(triple(4)))  # Output: 24

def apply_to_all(func, items):
    result = []
    for item in items:
        result.append(func(item))
    return result

# Test
numbers = [1, 2, 3, 4, 5]
print(apply_to_all(lambda x: x * 2, numbers))  # [2, 4, 6, 8, 10]
print(apply_to_all(str.upper, ["a", "b", "c"]))  # ['A', 'B', 'C']

def make_power(n):
    def power(x):
        return x ** n
    return power

square = make_power(2)
cube = make_power(3)

print(square(4))  # Output: 16
print(cube(3))    # Output: 27
print(make_power(4)(2))  # Output: 16

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

# Test
add_one = lambda x: x + 1
double = lambda x: x * 2

add_then_double = compose(double, add_one)  # double(add_one(x))
double_then_add = compose(add_one, double)  # add_one(double(x))

print(add_then_double(5))  # (5+1)*2 = 12
print(double_then_add(5))  # (5*2)+1 = 11

def pipeline(*funcs):
    def apply(x):
        result = x
        for func in funcs:
            result = func(result)
        return result
    return apply

# Test
add_one = lambda x: x + 1
double = lambda x: x * 2
square = lambda x: x ** 2

process = pipeline(add_one, double, square)
print(process(3))  # ((3+1)*2)**2 = 64

A closure is a function that remembers values from its enclosing scope even after that scope has finished executing. Closures are the mechanism behind decorators, function factories, and data hiding in Python.

Understanding Closures

When an inner function references a variable from an outer function, Python keeps that variable alive in the closure, allowing the inner function to access it later. This happens automatically when you define a nested function.

def outer(message):
    # message is in outer's local scope
    
    def inner():
        # inner "closes over" message
        print(message)
    
    return inner

greet = outer("Hello, World!")
greet()  # Output: Hello, World!

# message is still accessible even though outer() has returned
farewell = outer("Goodbye!")
farewell()  # Output: Goodbye!

Practical Closure Example

Closures are useful for creating functions with private state that persists across calls.

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

counter1 = make_counter()
print(counter1())  # Output: 1
print(counter1())  # Output: 2

counter2 = make_counter(100)
print(counter2())  # Output: 101
print(counter1())  # Output: 3 (independent state)

Closures vs Classes

Closures can sometimes replace simple classes when you need to maintain state with a single method.

# Using a closure
def make_accumulator(initial=0):
    total = initial
    def add(value):
        nonlocal total
        total += value
        return total
    return add

acc = make_accumulator(10)
print(acc(5))   # Output: 15
print(acc(3))   # Output: 18

# Equivalent class approach
class Accumulator:
    def __init__(self, initial=0):
        self.total = initial
    def add(self, value):
        self.total += value
        return self.total

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

hello = make_greeter("Hello")
hi = make_greeter("Hi")

print(hello("Alice"))  # Output: Hello, Alice!
print(hi("Bob"))       # Output: Hi, Bob!

def make_averager():
    numbers = []
    
    def add(value):
        numbers.append(value)
        return sum(numbers) / len(numbers)
    
    return add

avg = make_averager()
print(avg(10))  # Output: 10.0
print(avg(20))  # Output: 15.0
print(avg(30))  # Output: 20.0

def memoize(func):
    cache = {}
    
    def memoized(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    
    return memoized

@memoize
def slow_add(a, b):
    print(f"Computing {a} + {b}...")
    return a + b

print(slow_add(2, 3))  # Computing 2 + 3... then 5
print(slow_add(2, 3))  # Just 5 (cached)
print(slow_add(4, 5))  # Computing 4 + 5... then 9

def make_rate_limiter(max_calls):
    calls = 0
    
    def check():
        nonlocal calls
        if calls < max_calls:
            calls += 1
            return True
        return False
    
    return check

limiter = make_rate_limiter(3)
print(limiter())  # True (call 1)
print(limiter())  # True (call 2)
print(limiter())  # True (call 3)
print(limiter())  # False (exceeded limit)
print(limiter())  # False