Python Functions Explained: Syntax, Parameters & Best Practices

def function_name(parameters):
    """Optional docstring describing the function."""
    # function body
    return value   # optional

def greet(name):
    """Return a personalised greeting string."""
    return f"Hello, {name}! Welcome to Python."
# Call the function
message = greet("Priya")
print(message)   # Hello, Priya! Welcome to Python.
# Functions without a return statement return None implicitly
def say_hello():
    print("Hello!")
result = say_hello()   # prints Hello!
print(result)          # None

def power(base, exponent=2):
    """Raise base to exponent. Default exponent is 2 (square)."""
    return base ** exponent
print(power(3))       # 9   — uses default exponent
print(power(3, 3))    # 27  — overrides default
print(power(2, 10))   # 1024

def create_profile(name, age, city="Unknown", role="User"):
    return {"name": name, "age": age, "city": city, "role": role}
# Keyword arguments — order does not matter
p = create_profile(age=28, name="Alice", role="Admin")
print(p)   # {'name': 'Alice', 'age': 28, 'city': 'Unknown', 'role': 'Admin'}

def total(*numbers):
    """Sum any number of arguments."""
    return sum(numbers)
print(total(1, 2, 3))          # 6
print(total(10, 20, 30, 40))   # 100
# Unpack a list into *args at the call site
values = [5, 15, 25]
print(total(*values))          # 45

def display_info(**details):
    """Print any number of key-value pairs."""
    for key, value in details.items():
        print(f"  {key}: {value}")
display_info(name="Bob", language="Python", version=3.12)
# name: Bob
# language: Python
# version: 3.12
# Unpack a dict into **kwargs at the call site
config = {"host": "localhost", "port": 5432}
display_info(**config)

# Order rule: positional, *args, keyword-only, **kwargs
def full_example(a, b, *args, flag=False, **kwargs):
    print(f"a={a}, b={b}")
    print(f"extra positionals: {args}")
    print(f"flag={flag}")
    print(f"keyword extras: {kwargs}")
full_example(1, 2, 3, 4, flag=True, x=10, y=20)
# a=1, b=2
# extra positionals: (3, 4)
# flag=True
# keyword extras: {'x': 10, 'y': 20}

def min_max(numbers):
    """Return both the minimum and maximum of a list."""
    return min(numbers), max(numbers)   # returns a tuple
low, high = min_max([4, 1, 9, 2, 7])
print(f"Min: {low}, Max: {high}")   # Min: 1, Max: 9

def divide(a: float, b: float) -> float:
    if b == 0:
        return None   # early return — guard clause
    return a / b
print(divide(10, 2))   # 5.0
print(divide(10, 0))   # None

from typing import Optional, List, Dict, Tuple, Union
def calculate_average(numbers: List[float]) -> Optional[float]:
    """Return the mean of a list, or None if the list is empty."""
    if not numbers:
        return None
    return sum(numbers) / len(numbers)
def parse_record(raw: str) -> Dict[str, str]:
    """Split 'key=value,...' string into a dictionary."""
    return dict(pair.split('=') for pair in raw.split(','))
def clamp(value: float, lo: float, hi: float) -> float:
    """Clamp value between lo and hi inclusive."""
    return max(lo, min(value, hi))
print(clamp(15, 0, 10))   # 10
print(clamp(-5, 0, 10))   # 0
print(clamp(7,  0, 10))   # 7

x = "global"   # Global scope
def outer():
    x = "enclosing"   # Enclosing scope
    def inner():
        x = "local"   # Local scope
        print(x)      # local
    inner()
    print(x)          # enclosing
outer()
print(x)              # global

counter = 0
def increment():
    global counter        # declare intent to modify the global
    counter += 1
increment()
increment()
print(counter)   # 2
# nonlocal — modify an enclosing (but not global) variable
def make_counter():
    count = 0
    def step():
        nonlocal count
        count += 1
        return count
    return step
c = make_counter()
print(c(), c(), c())   # 1 2 3

# lambda parameters: expression
square = lambda x: x ** 2
print(square(5))   # 25
add = lambda a, b: a + b
print(add(3, 7))   # 10

students = [
    {"name": "Alice", "grade": 88},
    {"name": "Bob",   "grade": 95},
    {"name": "Carol", "grade": 72},
]
# Sort by grade descending
ranked = sorted(students, key=lambda s: s["grade"], reverse=True)
for s in ranked:
    print(s["name"], s["grade"])
# Bob 95 / Alice 88 / Carol 72
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
# map — apply function to each item
squares = list(map(lambda n: n**2, numbers))
print(squares)   # [1, 4, 9, 16, 25, 36, 49, 64]
# filter — keep items where function returns True
evens = list(filter(lambda n: n % 2 == 0, numbers))
print(evens)   # [2, 4, 6, 8]

prices = [100, 250, 75, 400, 30]
# Apply a 10% discount to all prices
discounted = list(map(lambda p: round(p * 0.90, 2), prices))
print(discounted)   # [90.0, 225.0, 67.5, 360.0, 27.0]
# Equivalent list comprehension (often preferred for readability)
discounted = [round(p * 0.90, 2) for p in prices]
# Keep only items over 100
expensive = list(filter(lambda p: p > 100, prices))
print(expensive)   # [250, 400]

from functools import reduce
# Multiply all numbers together
product = reduce(lambda acc, x: acc * x, [1, 2, 3, 4, 5])
print(product)   # 120
# Flatten a list of lists
nested = [[1, 2], [3, 4], [5, 6]]
flat = reduce(lambda acc, lst: acc + lst, nested, [])
print(flat)   # [1, 2, 3, 4, 5, 6]

def apply_twice(func, value):
    """Apply func to value, then apply func to the result."""
    return func(func(value))
print(apply_twice(lambda x: x * 2, 3))    # 12  (3 -> 6 -> 12)
print(apply_twice(lambda x: x + 10, 5))   # 25  (5 -> 15 -> 25)
def make_multiplier(factor):
    """Return a function that multiplies its argument by factor."""
    def multiplier(x):
        return x * factor
    return multiplier        # return a function
double = make_multiplier(2)
triple = make_multiplier(3)
print(double(5))   # 10
print(triple(5))   # 15

def make_adder(n):
    """Return a function that adds n to its argument."""
    def adder(x):
        return x + n   # 'n' is captured from the enclosing scope
    return adder
add5  = make_adder(5)
add10 = make_adder(10)
print(add5(3))    # 8
print(add10(3))   # 13
# Each closure has its own independent copy of 'n'
print(add5.__closure__[0].cell_contents)    # 5
print(add10.__closure__[0].cell_contents)   # 10

def make_memoised(func):
    cache = {}   # captured in closure
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper
def slow_square(n):
    import time; time.sleep(0.01)   # simulate slow computation
    return n * n
fast_square = make_memoised(slow_square)
print(fast_square(9))   # computed  -> 81
print(fast_square(9))   # from cache -> 81 (instant)

import time
import functools
def timer(func):
    """Measure and print how long func takes to run."""
    @functools.wraps(func)   # preserves metadata of the wrapped function
    def wrapper(*args, **kwargs):
        start  = time.perf_counter()
        result = func(*args, **kwargs)
        end    = time.perf_counter()
        print(f"{func.__name__} took {end - start:.4f}s")
        return result
    return wrapper
@timer
def compute_sum(n):
    return sum(range(n))
# @timer is equivalent to: compute_sum = timer(compute_sum)
print(compute_sum(1_000_000))
# compute_sum took 0.0312s
# 499999500000

def repeat(times):
    """Call the decorated function 'times' times."""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator
@repeat(times=3)
def greet(name):
    print(f"Hello, {name}!")
greet("World")
# Hello, World!
# Hello, World!
# Hello, World!

def countdown(n):
    """Yield numbers from n down to 1."""
    while n > 0:
        yield n       # pause here and send n to caller
        n -= 1
for num in countdown(5):
    print(num, end=" ")   # 5 4 3 2 1
# Generators are lazy — values are produced only when requested
gen = countdown(3)
print(next(gen))   # 3
print(next(gen))   # 2
print(next(gen))   # 1
# print(next(gen)) # StopIteration — exhausted

def fibonacci():
    """Yield Fibonacci numbers indefinitely."""
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b
# Take only the first 10
fib = fibonacci()
first_10 = [next(fib) for _ in range(10)]
print(first_10)   # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

import sys
# List — holds all values in memory
squares_list = [x**2 for x in range(1_000_000)]
print(sys.getsizeof(squares_list), "bytes")   # ~8 MB
# Generator — holds only the current state
squares_gen = (x**2 for x in range(1_000_000))   # generator expression
print(sys.getsizeof(squares_gen), "bytes")    # ~112 bytes

def factorial(n: int) -> int:
    """Return n! recursively."""
    if n <= 1:           # base case
        return 1
    return n * factorial(n - 1)   # recursive case
print(factorial(5))    # 120
print(factorial(10))   # 3628800
def flatten(lst):
    """Recursively flatten a nested list of any depth."""
    result = []
    for item in lst:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result
nested = [1, [2, [3, 4], 5], [6, 7]]
print(flatten(nested))   # [1, 2, 3, 4, 5, 6, 7]