What Is a Function?

A function is a reusable code block designed to perform a specific task. Functions serve as fundamental building blocks in Python programs, enabling developers to organize code logically and avoid repetition.

Why Use Functions?

• Code Organization: Functions improve program structure and readability by grouping related operations
• Reduced Duplication: Define once, execute multiple times from different locations
• Maintainability: Changes made to a function automatically apply everywhere it's called
• Abstraction: Hide implementation details while exposing clean interfaces

Function Syntax and Usage

Functions must be defined before they are called. Python executes code in two distinct phases: definition phase (syntax checking only) and invocation phase (actual execution).

Basic Syntax

def function_name(param1, param2):
    """Documentation string describing function purpose"""
    # function body
    return result

Component	Description
def	Keyword that begins function definition
function_name	Identifier pointing to function's memory address; adding () executes the function
param1, param2	Arguments passed from caller to function; Python requires no type declarations
return	Sends computed value back to caller; omitting returns None

Three Ways to Define Functions

# No parameters
def display_message():
    print('notification displayed')

# With parameters
def calculate_total(amount, tax):
    return amount + tax

# Empty function (placeholder)
def placeholder():
    pass

Three Ways to Call Functions

# Statement form
def greet():
    print('hello')
greet()

# Expression form
def add(a, b):
    return a + b

result = add(5, 3)
final = add(5, 3) * 10

# As argument to another function
def get_max(x, y):
    return x if x > y else y

maximum = get_max(get_max(10, 20), 30)

Understanding the return Statement

# No return value
def process():
    print('processing')
result = process()  # None

# Single return value
def square(n):
    return n ** 2

# Multiple return values (returns tuple)
def get_stats():
    return 1, 2, 3
data = get_stats()  # (1, 2, 3)

The return statement serves two purposes: it sends values back to the caller and immediately terminates function execution.

Function Parameters

Formal vs Actual Parameters

Formal parameters (parameters) are variable names defined in the function signature. Actual parameters (arguments) are the specific values provided during invocation. When called, arguments are bound to parameters and become unavailable after the function completes.

1. Positional Parameters

Parameters defined in order from left to right. Arguments must match positionally and numerically.

def show_coordinates(x, y):
    print(f'x={x}, y={y}')

show_coordinates(10, 20)      # Valid
show_coordinates(10, 20, 30)  # Error: too many arguments
show_coordinates(10)          # Error: missing argument

2. Keyword Arguments

Pass arguments using name=value syntax, which allows reordering and explicit parameter targeting.

def configure(host, port):
    print(f'connecting to {host}:{port}')

configure(port=8080, host='localhost')  # Valid, reordered
configure(100, port=8080)                 # Valid, mixed style
configure(host='example.com', port=80)   # Valid, all keywords

# Invalid combinations
configure(port=80, 100)                  # Error: positional after keyword
configure(port=80, host='localhost', port=90)  # Error: duplicate assignment

3. Default Parameters

Parameters with preassigned values in the definition. Callers may omit these arguments.

def create_user(name, status='active'):
    print(f'user: {name}, status: {status}')

create_user('alice')              # Uses default: 'active'
create_user('bob', 'inactive')    # Overrides default

# Default parameters must follow non-default parameters
def invalid(x=1, y):  # SyntaxError
    pass

Caution with mutable defaults: Avoid using mutable objects (lists, dicts) as default values.

def add_skill(name, skills=[]):
    skills.append(name)
    print(skills)

add_skill('python')   # ['python']
add_skill('java')     # ['python', 'java']  # Bug: accumulates across calls

Correct approach:

def add_skill(name, skills=None):
    if skills is None:
        skills = []
    skills.append(name)
    print(skills)

4. Variable-Length Arguments

Use * and ** to accept arbitrary numbers of arguments.

In Function Definitions

# Collects excess positional arguments as tuple
def collect_args(a, b, *extras):
    print(f'a={a}, b={b}, extras={extras}')

collect_args(1, 2, 3, 4, 5)  # a=1, b=2, extras=(3, 4, 5)

# Collects excess keyword arguments as dictionary
def collect_kwargs(a, b, **options):
    print(f'a={a}, b={b}, options={options}')

collect_kwargs(1, b=2, timeout=30, debug=True)  # a=1, b=2, options={'timeout': 30, 'debug': True}

In Function Calls

def display(a, b, c):
    print(f'a={a}, b={b}, c={c}')

# Unpack sequence to positional arguments
items = [10, 20, 30]
display(*items)  # Equivalent to display(10, 20, 30)

# Unpack dictionary to keyword arguments
config = {'b': 200, 'c': 300, 'a': 100}
display(**config)  # Equivalent to display(a=100, b=200, c=300)

5. Forwarding Arguments

To pass all received arguments to another function unchanged:

def destination(x, y, z):
    print(f'received: {x}, {y}, {z}')

def forward(*args, **kwargs):
    destination(*args, **kwargs)

forward(1, 2, z=3)  # received: 1, 2, 3

6. Keyword-Only Parameters

Parameters defined after * or *args must be passed as keyword arguments.

def query(*, filter_key, limit=10):
    print(f'filter={filter_key}, limit={limit}')

query(filter_key='active')       # Valid
query(filter_key='active', limit=50)  # Valid
query('active')                  # Error: positional argument not allowed

Complete Parameter Signature

def complete(pos1, pos2, default_val=100, *args, keyword_only, **kwargs):
    pass

# Parameters breakdown:
# pos1, pos2: positional parameters
# default_val: default parameter
# keyword_only: keyword-only parameter
# args, kwargs: variable-length parameters

Function Objects

In Python, functions are first-class objects. The function name is a reference that can be used like any other object.

def execute():
    print('running')

# Assign function to variable
handler = execute
handler()  # prints 'running'

# Pass as function argument
def call_func(fn):
    fn()

call_func(execute)  # prints 'running'

# Return from function
def factory():
    return execute

returned = factory()
returned()  # prints 'running'

# Store in container
collection = [execute, execute()]

Function Nesting

Nested Function Calls

def inner():
    print('inner executed')

def outer():
    print('outer starting')
    inner()
    print('outer finished')

outer()
# Output:
# outer starting
# inner executed
# outer finished

Nested Function Definitions

def level1():
    print('level 1')
    
    def level2():
        print('level 2')
        
        def level3():
            print('level 3')
        
        level3()
    
    level2()

level1()

Namespaces and Scope

A namespace is a container that maps names to memory addresses. Every value lookup occurs through namespace searches.

Namespace Types

Namespace	Contents	Lifetime
Built-in	Python interpreter built-in names (print, len)	Interpreter startup to shutdown
Global	Module-level names (top-level of file)	Module load to termination
Local	Names inside functions	Function call start to end

Resolution Order

Python 3: local → enclosing → global → builtin

global_var = 100

def outer():
    enclosing_var = 200
    
    def inner():
        local_var = 300
        # Looks up: local_var, enclosing_var, global_var, builtin
        print(local_var, enclosing_var, global_var)
    
    inner()

outer()  # 300 200 100

Important Behavior

The scope resolution is determined at definition time, not call time:

name = 'global'

def get_name():
    print(name)  # Resolves to 'global' at definition

get_name()       # 'global'

name = 'modified'
get_name()       # Still 'global' (resolved at definition)

# Variable assignment creates local scope by default
counter = 0

def increment():
    counter = 1  # Creates new local variable, doesn't modify global

increment()
print(counter)  # 0 (global unchanged)

Modifying Variables Across Scopes

# Using global to modify global variable
counter = 0

def inc():
    global counter
    counter += 1

inc()
print(counter)  # 1

# Using nonlocal to modify enclosing scope variable
def outer():
    value = 10
    
    def inner():
        nonlocal value
        value = 20
    
    inner()
    print(value)  # 20

outer()

Closures

A closure is an inner function that retains access to variables from its enclosing scope, even after the outer function has finished eexcuting.

def outer(x):
    def inner(y):
        return x + y  # inner 'closes over' x
    return inner

add_five = outer(5)
print(add_five(10))  # 15
print(add_five(3))   # 8

Closures solve the problem of passing values to functions without using global variables or class instances.

Decorators

A decorator is a callable that wraps a function to extend its behavior without modifying its source code. This follows the Open/Closed Principle: open for extension, closed for modification.

Basic Decorator Pattern

import time

def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)  # Call original function
        elapsed = time.time() - start
        print(f'{func.__name__} executed in {elapsed:.4f}s')
        return result
    return wrapper

@timer_decorator
def fetch_data():
    time.sleep(1)
    return 'data retrieved'

fetch_data()
# Output:
# fetch_data executed in 1.0023s

The @decorator syntax is equivalent to: fetch_data = timer_decorator(fetch_data)

Multiple Decorators

Decorators are applied bottom-to-top during definition, but execute top-to-bottom during invocation:

import time

def decorator_a(func):
    print('decorator_a setup')
    def wrapper(*args, **kwargs):
        print('decorator_a executing')
        return func(*args, **kwargs)
    return wrapper

def decorator_b(func):
    print('decorator_b setup')
    def wrapper(*args, **kwargs):
        print('decorator_b executing')
        return func(*args, **kwargs)
    return wrapper

@decorator_a
@decorator_b
def target():
    print('target function')

target()
# Setup order: decorator_b, decorator_a
# Execution order: decorator_a, decorator_b, target

Decorators with Parameters

def retry(max_attempts=3):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts - 1:
                        raise
                    print(f'attempt {attempt + 1} failed, retrying...')
        return wrapper
    return decorator

@retry(max_attempts=5)
def unreliable_operation():
    pass

Preserving Function Metadata

Decorators replace functions, losing original metadata. Use functools.wraps to preserve it:

from functools import wraps

def logged(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f'calling {func.__name__}')
        return func(*args, **kwargs)
    return wrapper

@logged
def calculate(x):
    """Computes the square of x"""
    return x ** 2

print(calculate.__name__)  # 'calculate' (not 'wrapper')
print(calculate.__doc__)   # 'Computes the square of x'

Recursion

A function is recursive when it calls itself either directly or indirectly through another function.

Every recursive function requires:

1. Base case: Condition to stop recursion
2. Recursive case: Logic that reduces problem size toward base case

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

print(factorial(5))  # 120

# Fibonacci sequence
def fibonacci(n):
    if n in (0, 1):
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

for i in range(10):
    print(fibonacci(i), end=' ')  # 0 1 1 2 3 5 8 13 21 34

# Binary search using recursion
def binary_search(target, sorted_list):
    if not sorted_list:
        return False
    
    mid = len(sorted_list) // 2
    
    if target == sorted_list[mid]:
        return True
    elif target < sorted_list[mid]:
        return binary_search(target, sorted_list[:mid])
    else:
        return binary_search(target, sorted_list[mid + 1:])

data = [1, 3, 5, 7, 9, 11, 13, 15]
binary_search(7, data)   # True
binary_search(6, data)   # False

# Tower of Hanoi
def move_tower(height, source, auxiliary, destination):
    if height >= 1:
        move_tower(height - 1, source, destination, auxiliary)
        print(f'move disk {height} from {source} to {destination}')
        move_tower(height - 1, auxiliary, source, destination)

move_tower(3, 'A', 'B', 'C')

Comprehensions

Ternary Expression

maximum = value1 if condition else value2
result = 10 if 3 > 5 else 20  # 20

List Comprehension

# Basic syntax: [expression for item in iterable]
squares = [x ** 2 for x in range(10)]  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# With conditional filtering
selected = [x for x in range(20) if x % 3 == 0]  # [0, 3, 6, 9, 12, 15, 18]

# With ternary expression
transformed = [x if x % 2 == 0 else -x for x in range(5)]  # [0, -1, 2, -3, 4]

Dictionary Comprehension

keys = ['name', 'age', 'city']
values = ['Alice', 30, 'Seattle']

# Create dict from parallel lists
mapping = {keys[i]: values[i] for i in range(len(keys))}
# {'name': 'Alice', 'age': 30, 'city': 'Seattle'}

# Using enumerate
mapping = {k: v for k, v in zip(keys, values)}
# {'name': 'Alice', 'age': 30, 'city': 'Seattle'}

# With conditional filtering
data = {chr(i + 65): i for i in range(5) if i != 2}
# {'A': 0, 'B': 1, 'D': 3, 'E': 4}

Set Comprehension

unique_chars = {char for char in 'programming'}
# {'p', 'r', 'o', 'g', 'a', 'm', 'i', 'n'}

squared_unique = {x ** 2 for x in [-2, -1, 0, 1, 2]}
# {0, 1, 4}

Lambda Functions

Lambda functions are anonymous functions defined with a single expression. Use them for short-lived operations that don't warrant a named function.

# Syntax: lambda parameters: expression
add = lambda x, y: x + y
print(add(3, 4))  # 7

# With built-in functions
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_nums = sorted(numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]
sorted_nums_desc = sorted(numbers, reverse=True)  # [9, 6, 5, 4, 3, 2, 1, 1]

Lambda with max(), min(), sorted()

employees = {
    'Alice': 75000,
    'Bob': 120000,
    'Carol': 95000,
    'David': 45000
}

# Find employee with highest salary
highest_earner = max(employees, key=lambda name: employees[name])
# 'Bob'

# Find employee with lowest salary
lowest_earner = min(employees, key=lambda name: employees[name])
# 'David'

# Sort by salary
by_salary = sorted(employees, key=lambda name: employees[name])
# ['David', 'Alice', 'Carol', 'Bob']

Lambda with map()

names = ['alice', 'bob', 'charlie']
capitalized = list(map(lambda name: name.title(), names))
# ['Alice', 'Bob', 'Charlie']

Lambda with filter()

names = ['Alice', 'BobABC', 'Carol', 'DavidXYZ']
filtered = list(filter(lambda name: name.isalpha(), names))
# ['Alice', 'Carol']

# Equivalent comprehension
filtered = [name for name in names if name.isalpha()]

Lambda with reduce()

from functools import reduce

# Sum all values
numbers = [1, 2, 3, 4, 5]
total = reduce(lambda x, y: x + y, numbers, 0)
# 15

# Concatenate with initial value
letters = ['a', 'b', 'c', 'd']
concatenated = reduce(lambda x, y: x + y, letters, 'X')
# 'Xabcd'

Iterators

An iterator is an object that yields values one at a time, maintaining internal state to track position.

Iteration vs Repetition

# Not iteration (mere repetition)
while True:
    print('hello')

# True iteration (each step based on previous)
items = ['a', 'b', 'c']
index = 0
while index < len(items):
    print(items[index])
    index += 1

Iterable Objects

Objects with an __iter__() method are iterable. Built-in iterables include: str, list, tuple, dict, set, file objects.

data = {'x': 1, 'y': 2}
iter_obj = data.__iter__()

print(iter_obj.__next__())  # 'x'
print(iter_obj.__next__())  # 'y'
print(iter_obj.__next__())  # StopIteration exception

Iterator Protocol

data = [10, 20, 30]
iter_obj = iter(data)  # Same as data.__iter__()

# Manual iteration
while True:
    try:
        value = next(iter_obj)
        print(value)
    except StopIteration:
        break

For Loop Mechanics

for item in iterable:
    process(item)

# Equivalent to:
_temp = iter(iterable)
while True:
    try:
        item = next(_temp)
        process(item)
    except StopIteration:
        break

Iterator Characteristics

Aspect	Description
Memory efficient	Only one element in memory at a time
Single traversal	Cannot reset; create new iterator
Stateful	Cannot go backwards

Generators

Generators are user-defined iterators created using functions with yield statements.

Generator Fundamentals

def count_up_to(limit):
    count = 1
    while count <= limit:
        yield count
        count += 1

gen = count_up_to(3)
print(next(gen))  # 1
print(next(gen))  # 2
print(next(gen))  # 3
print(next(gen))  # StopIteration

When yield executes, the function pauses and preserves its state. Subsequent next() calls resume execution after the yield.

Sending Values to Generators

def receiver():
    print('waiting to receive')
    while True:
        value = yield  # Pause and receive
        print(f'received: {value}')

gen = receiver()
next(gen)  # Initialize: prints 'waiting to receive'

gen.send('first message')  # received: first message
gen.send('second message')  # received: second message

The send() method passes a value into the generator and resumes execution until the next yield.

Generator vs Return

Aspect	yield	return
Execution	Pauses, can resume	Terminates function
Values	Multiple yields possible	Single return value
State	Preserved between calls	Lost

Generator Expressions

Like list comprehensions but with parentheses, creating generators:

# Generator expression (lazy evaluation)
squares_gen = (x ** 2 for x in range(1000000))

# Does not compute until iterated
print(next(squares_gen))  # 0
print(next(squares_gen))  # 1

# Memory efficient for large datasets
with open('large_file.txt') as f:
    line_lengths = sum(len(line) for line in f)  # Streams, doesn't load file

# Generator expression with filter
filtered = (x for x in range(100) if x % 7 == 0)
print(list(filtered))  # [0, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98]

Built-in Functions Reference

# Numeric operations
abs(-5)               # 5 (absolute value)
bool(0)               # False (falsy values: 0, '', [], {}, None)
bool('text')          # True
bytes('hello', 'utf-8')  # b'hello'
divmod(17, 5)         # (3, 2)
pow(2, 3, 5)          # 8, equivalent to (2**3) % 5
round(3.5)            # 4 (banker's rounding)
round(2.5)            # 2 (rounds to even)

# Conversion
chr(65)               # 'A' (ASCII to character)
ord('A')              # 65 (character to ASCII)
list('abc')           # ['a', 'b', 'c']
tuple([1, 2])          # (1, 2)
set([1, 2, 2, 3])     # {1, 2, 3}
bytes([65, 66])       # b'AB'

# Iteration utilities
enumerate(['a', 'b', 'c'])  # [(0, 'a'), (1, 'b'), (2, 'c')]
zip([1, 2], 'ab')           # [(1, 'a'), (2, 'b')]
reversed([1, 2, 3])         # iterator yielding 3, 2, 1
slice(1, 10, 2)             # slice object for [1:10:2]
list(range(5))              # [0, 1, 2, 3, 4]

# Truthiness
all([True, 1, 'text'])      # True (all truthy)
all([0, 1])                 # False
any([0, '', None])          # False (none truthy)
any([0, 'x'])               # True

# String evaluation
eval('2 + 3')               # 5 (executes string as code)
exec('for i in range(3): print(i)')

# Number systems
bin(10)                     # '0b1010'
oct(10)                     # '0o12'
hex(10)                     # '0xa'

# Type checking
callable(lambda x: x)       # True (lambdas are callable)
callable(5)                 # False
isinstance(5, int)           # True
isinstance('text', str)      # True

# Introspection
dir([])                     # List of list methods
globals()                   # Global namespace dict
locals()                    # Local namespace dict
getattr(obj, 'method')      # Get attribute by name
hasattr(obj, 'attr')        # Check attribute exists
setattr(obj, 'attr', val)   # Set attribute
delattr(obj, 'attr')        # Delete attribute

# Object identity
id(obj)                     # Memory address
hash(obj)                   # Hash value for dict keys
type(obj)                   # Object's type

# Module import
import os
module_name = 'os'
mod = __import__(module_name)

# Functional programming
filter(None, [1, 0, 2, 0])   # Yields 1, 2
map(str, [1, 2, 3])          # Yields '1', '2', '3'
map(lambda x: x**2, range(5))  # Yields 0, 1, 4, 9, 16

Type Conversion Cheatsheet

# Integer representations
0b1010        # Binary literal (10)
0o12          # Octal literal (10)
0xA           # Hexadecimal literal (10)
int('1010', 2)   # Convert binary string to int
int('12', 8)     # Convert octal string to int
int('A', 16)     # Convert hex string to int

# String to bytes
'hello'.encode('utf-8')      # b'hello'
b'hello'.decode('utf-8')     # 'hello'

# Collections
list((1, 2, 3))              # [1, 2, 3]
tuple([1, 2, 3])             # (1, 2, 3)
set([1, 2, 2, 3])            # {1, 2, 3}
frozenset([1, 2, 3])         # Immutable set
dict([('a', 1), ('b', 2)])   # {'a': 1, 'b': 2}
str([1, 2, 3])               # '[1, 2, 3]'