Defining Functions

A function is a named block of reusable code that performs a specific task. Functions help you organize your code, avoid repetition, and make programs easier to understand and maintain.

Your First Function

Creating a function in Python uses the def keyword followed by the function name, parentheses, and a colon. The function body is indented.

# Define a simple function
def greet():
    print("Hello, World!")

# Call the function
greet()  # Output: Hello, World!

# You can call it multiple times
greet()  # Output: Hello, World!
greet()  # Output: Hello, World!

When to Use Functions

Not all code needs to be in a function. Here are guidelines for when to create functions versus when to keep code inline:

Function vs Inline Comparison

Let's compare solving the same problem with and without functions:

# Calculate area for room 1
length1 = 12
width1 = 10
area1 = length1 * width1
print(f"Room 1: {area1} sq ft")

# Calculate area for room 2
length2 = 15
width2 = 8
area2 = length2 * width2
print(f"Room 2: {area2} sq ft")

# Calculate area for room 3
length3 = 10
width3 = 10
area3 = length3 * width3
print(f"Room 3: {area3} sq ft")

total = area1 + area2 + area3
print(f"Total: {total} sq ft")

def calculate_area(length, width):
    """Calculate rectangle area."""
    return length * width

def print_room_area(room_name, area):
    """Display formatted room area."""
    print(f"{room_name}: {area} sq ft")

# Calculate all areas
area1 = calculate_area(12, 10)
area2 = calculate_area(15, 8)
area3 = calculate_area(10, 10)

# Display results
print_room_area("Room 1", area1)
print_room_area("Room 2", area2)
print_room_area("Room 3", area3)

total = area1 + area2 + area3
print(f"Total: {total} sq ft")

Real-World Function Library

Here are practical functions you'll use in real projects, organized by category:

def is_valid_email(email):
    """Check if email format is valid."""
    return "@" in email and "." in email.split("@")[-1]

def is_strong_password(password):
    """Check if password meets basic criteria."""
    return (len(password) >= 8 and 
            any(c.isupper() for c in password) and
            any(c.isdigit() for c in password))

# Using validation functions
print(is_valid_email("user@example.com"))     # True
print(is_valid_email("invalid.email"))        # False
print(is_strong_password("Pass123"))          # True
print(is_strong_password("weak"))             # False

def format_currency(amount):
    """Format number as USD currency."""
    return f"${amount:,.2f}"

def format_phone(number):
    """Format 10-digit phone number."""
    digits = ''.join(c for c in number if c.isdigit())
    if len(digits) == 10:
        return f"({digits[:3]}) {digits[3:6]}-{digits[6:]}"
    return number

# Using formatting functions
print(format_currency(1234.56))               # $1,234.56
print(format_currency(1000000))               # $1,000,000.00
print(format_phone("5551234567"))             # (555) 123-4567
print(format_phone("555-123-4567"))           # (555) 123-4567

def get_file_extension(filename):
    """Extract file extension from filename."""
    if "." in filename:
        return filename.split(".")[-1].lower()
    return ""

def is_leap_year(year):
    """Determine if year is a leap year."""
    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

def celsius_to_fahrenheit(celsius):
    """Convert Celsius to Fahrenheit."""
    return (celsius * 9/5) + 32

# Using utility functions
print(get_file_extension("document.pdf"))     # pdf
print(get_file_extension("photo.jpg"))        # jpg
print(is_leap_year(2024))                     # True
print(is_leap_year(2023))                     # False
print(celsius_to_fahrenheit(100))             # 212.0
print(celsius_to_fahrenheit(0))               # 32.0

Every function has specific parts that work together. Understanding function anatomy helps you write clean, well-structured code.

Complete Function Example

Here is a complete function with all parts labeled. Docstrings document what the function does.

def calculate_area(length, width):
    """
    Calculate the area of a rectangle.
    
    Args:
        length: The length of the rectangle
        width: The width of the rectangle
    
    Returns:
        The area (length * width)
    """
    area = length * width
    return area

# Call the function with arguments
result = calculate_area(5, 3)
print(result)  # Output: 15

Complete Real-World Examples

Here are full working examples that combine multiple concepts:

Temperature Converter

Building a temperature conversion library with multiple related functions:

def celsius_to_fahrenheit(celsius):
    """Convert Celsius to Fahrenheit."""
    return (celsius * 9/5) + 32

def fahrenheit_to_celsius(fahrenheit):
    """Convert Fahrenheit to Celsius."""
    return (fahrenheit - 32) * 5/9

def kelvin_to_celsius(kelvin):
    """Convert Kelvin to Celsius."""
    return kelvin - 273.15

# Usage examples
print(f"100°C = {celsius_to_fahrenheit(100)}°F")  # 212.0°F
print(f"32°F = {fahrenheit_to_celsius(32)}°C")    # 0.0°C
print(f"0K = {kelvin_to_celsius(0)}°C")           # -273.15°C

Input Validator

Validation functions check data format and return boolean values:

def is_valid_email(email):
    """Validate email format."""
    return "@" in email and "." in email.split("@")[-1]

def is_strong_password(password):
    """Check password strength."""
    return (len(password) >= 8 and
            any(c.isupper() for c in password) and
            any(c.isdigit() for c in password))

def validate_age(age):
    """Check if age is valid."""
    return 0 <= age <= 150

# Using validators
print(is_valid_email("user@example.com"))  # True
print(is_strong_password("Pass123"))       # True  
print(validate_age(25))                    # True

Price Calculator

Building complex calculations from simple function components:

def calculate_discount(price, percent):
    """Calculate discounted price."""
    discount = price * (percent / 100)
    return price - discount

def add_tax(price, tax_rate=0.08):
    """Add sales tax to price."""
    return price * (1 + tax_rate)

def final_price(price, discount=0, tax_rate=0.08):
    """Calculate final price with discount and tax."""
    after_discount = calculate_discount(price, discount)
    with_tax = add_tax(after_discount, tax_rate)
    return round(with_tax, 2)

# Usage
original = 100
print(f"Original: ${original}")                      # $100
print(f"20% off: ${calculate_discount(original, 20)}")  # $80.0
print(f"Final: ${final_price(original, 20)}")        # $86.4

Statistics Functions

Analyzing numeric data with specialized functions:

def calculate_average(numbers):
    """Calculate mean of numbers."""
    if not numbers:
        return 0
    return sum(numbers) / len(numbers)

def find_min_max(numbers):
    """Return minimum and maximum."""
    if not numbers:
        return None, None
    return min(numbers), max(numbers)

def calculate_range(numbers):
    """Calculate range (max - min)."""
    if not numbers:
        return 0
    return max(numbers) - min(numbers)

# Usage
scores = [85, 92, 78, 95, 88]
print(f"Average: {calculate_average(scores)}")  # 87.6
min_score, max_score = find_min_max(scores)
print(f"Range: {min_score} - {max_score}")      # 78 - 95

Error Handling in Functions

Functions should handle invalid inputs gracefully to prevent crashes and provide helpful feedback:

def safe_divide(a, b):
    """Safely divide two numbers."""
    if b == 0:
        return "Error: Cannot divide by zero"
    return a / b

# Using safe_divide
print(safe_divide(10, 2))   # Output: 5.0
print(safe_divide(10, 0))   # Output: Error: Cannot divide by zero

def get_grade(score):
    """Convert numeric score to letter grade."""
    if not 0 <= score <= 100:
        return "Invalid score"
    
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

# Using get_grade
print(get_grade(95))   # Output: A
print(get_grade(150))  # Output: Invalid score
print(get_grade(-10))  # Output: Invalid score

def safe_get_item(items, index):
    """Safely get item from list."""
    if not items:
        return "Empty list"
    if not 0 <= index < len(items):
        return "Index out of range"
    return items[index]

# Using safe_get_item
colors = ["red", "green", "blue"]
print(safe_get_item(colors, 1))   # Output: green
print(safe_get_item(colors, 10))  # Output: Index out of range
print(safe_get_item([], 0))       # Output: Empty list

def say_hello():
    print("Hello, Python!")

# Call the function three times
say_hello()  # Output: Hello, Python!
say_hello()  # Output: Hello, Python!
say_hello()  # Output: Hello, Python!

def print_info():
    """Print personal programming information."""
    print("Name: Alex")
    print("Favorite Language: Python")

print_info()
# Output:
# Name: Alex
# Favorite Language: Python

def print_box():
    """Print Hello inside an asterisk box."""
    print("*" * 10)
    print("*        *")
    print("* Hello  *")
    print("*        *")
    print("*" * 10)

print_box()

Docstring Styles and Formats

Python supports several docstring formats. Choose one and use it consistently across your project.

Google Style Docstring

Google style is popular for its readability and clean structure:

def calculate_bmi(weight, height):
    """Calculate Body Mass Index.
    
    Args:
        weight (float): Weight in kilograms
        height (float): Height in meters
    
    Returns:
        float: BMI value
    
    Examples:
        >>> calculate_bmi(70, 1.75)
        22.86
    """
    return weight / (height ** 2)

NumPy/SciPy Style

NumPy style uses underlines and is common in scientific computing:

def calculate_bmi(weight, height):
    """
    Calculate Body Mass Index.
    
    Parameters
    ----------
    weight : float
        Weight in kilograms
    height : float
        Height in meters
    
    Returns
    -------
    float
        BMI value
    """
    return weight / (height ** 2)

Type Hints and Modern Python

Python 3.5+ supports type hints that document expected types without affecting runtime behavior.

Basic Type Hints

Type hints show what types parameters should be and what the function returns:

def greet(name: str, times: int = 1) -> str:
    """
    Greet someone multiple times.
    
    Args:
        name: Person's name
        times: Number of times to repeat greeting
    
    Returns:
        The complete greeting message
    """
    greeting = f"Hello, {name}! " * times
    return greeting.strip()

# Using the function with type hints
result: str = greet("Alice", 3)
print(result)  # Hello, Alice! Hello, Alice! Hello, Alice!

from typing import List, Dict, Optional, Tuple

def process_data(items: List[str]) -> Dict[str, int]:
    """Count occurrences of each item."""
    counts: Dict[str, int] = {}
    for item in items:
        counts[item] = counts.get(item, 0) + 1
    return counts

def find_user(user_id: int) -> Optional[Dict[str, str]]:
    """Find user by ID, return None if not found."""
    if user_id > 0:
        return {"name": "User", "email": "user@example.com"}
    return None

def get_coordinates() -> Tuple[float, float]:
    """Return latitude and longitude as tuple."""
    return (40.7128, -74.0060)

Function Annotations and Metadata

You can access function metadata like name, docstring, and annotations programmatically.

def add(x: int, y: int) -> int:
    """Add two numbers together."""
    return x + y

# Access function name
print(add.__name__)  # Output: add

# Access function docstring
print(add.__doc__)  # Output: Add two numbers together.

# Access type annotations
print(add.__annotations__)
# Output: {'x': , 'y': , 'return': }

# Get help on a function
help(add)
# Output:
# Help on function add in module __main__:
# add(x: int, y: int) -> int
#     Add two numbers together.

# Check if something is callable
import inspect

print(callable(add))  # True

print(inspect.isfunction(add))  # True

# Get function signature
sig = inspect.signature(add)
print(sig)  # Output: (x: int, y: int) -> int

for param_name, param in sig.parameters.items():
    print(f"{param_name}: {param.annotation}")

Function Naming Conventions

Follow PEP 8 naming guidelines for Python functions.

Parameters make functions flexible. Instead of hardcoding values, you pass data into functions as arguments. Parameters are the placeholders in the function definition; arguments are the actual values you pass when calling.

Positional Parameters

Parameters are matched to arguments by position. The first argument goes to the first parameter, and so on.

def greet(name):
    print(f"Hello, {name}!")

greet("Alice")  # Output: Hello, Alice!
greet("Bob")    # Output: Hello, Bob!

# Multiple parameters
def add(a, b):
    result = a + b
    print(f"{a} + {b} = {result}")

add(5, 3)   # Output: 5 + 3 = 8
add(10, 20) # Output: 10 + 20 = 30

Default Parameters

Default parameters have predefined values. If the caller does not provide an argument, the default is used. Default parameters must come after required parameters.

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice")              # Output: Hello, Alice!
greet("Bob", "Hi")          # Output: Hi, Bob!
greet("Carol", "Welcome")   # Output: Welcome, Carol!

# Multiple defaults
def create_user(name, role="user", active=True):
    print(f"Created {name} as {role}, active={active}")

create_user("Alice")                    # Uses all defaults
create_user("Bob", "admin")             # Override role
create_user("Carol", "mod", False)      # Override both

Keyword Arguments

Keyword arguments let you specify which parameter gets which value by name. This makes code more readable and allows arguments in any order.

def describe_pet(name, animal, age):
    print(f"{name} is a {age}-year-old {animal}")

# Positional arguments (order matters)
describe_pet("Buddy", "dog", 5)

# Keyword arguments (order flexible)
describe_pet(animal="cat", age=3, name="Whiskers")

# Mix positional and keyword
describe_pet("Max", animal="hamster", age=1)

def welcome(name):
    print(f"Welcome, {name}!")

welcome("Alice")   # Output: Welcome, Alice!
welcome("Bob")     # Output: Welcome, Bob!
welcome("Carol")   # Output: Welcome, Carol!

def power(base, exponent=2):
    result = base ** exponent
    print(f"{base}^{exponent} = {result}")

power(5)        # Output: 5^2 = 25
power(2, 10)    # Output: 2^10 = 1024
power(3, 3)     # Output: 3^3 = 27

def build_profile(name, age=18, city="Unknown", job="Student"):
    print(f"Name: {name}")
    print(f"Age: {age}")
    print(f"City: {city}")
    print(f"Job: {job}")
    print("-" * 20)

build_profile("Alice")
build_profile("Bob", age=25, job="Engineer")
build_profile("Carol", city="NYC", age=30, job="Designer")

Variable-Length Arguments (*args)

Sometimes you don't know how many arguments a function will receive. Use *args to accept any number of positional arguments. They are collected into a tuple.

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

print(sum_all(1, 2, 3))           # Output: 6
print(sum_all(10, 20, 30, 40))    # Output: 100
print(sum_all(5))                 # Output: 5
print(sum_all())                  # Output: 0

def greet_all(*names):
    """Greet multiple people."""
    for name in names:
        print(f"Hello, {name}!")

greet_all("Alice", "Bob", "Carol")
# Output:
# Hello, Alice!
# Hello, Bob!
# Hello, Carol!

Combining Regular and *args Parameters

You can mix regular parameters with *args. Regular parameters come first, then *args captures the rest.

def make_pizza(size, *toppings):
    """Make a pizza with size and any number of toppings."""
    print(f"Making a {size}-inch pizza with:")
    for topping in toppings:
        print(f"  - {topping}")

make_pizza(12, "pepperoni", "mushrooms")
# Output:
# Making a 12-inch pizza with:
#   - pepperoni
#   - mushrooms

make_pizza(16, "olives", "sausage", "peppers", "onions")
# Output:
# Making a 16-inch pizza with:
#   - olives
#   - sausage
#   - peppers
#   - onions

def calculate_average(name, *scores):
    """Calculate average of student scores."""
    if len(scores) == 0:
        return f"{name}: No scores"
    
    avg = sum(scores) / len(scores)
    return f"{name}: {avg:.2f} average"

print(calculate_average("Alice", 85, 90, 78))  # Alice: 84.33 average
print(calculate_average("Bob", 95, 88))        # Bob: 91.50 average

Keyword Arguments (**kwargs)

Use **kwargs (keyword arguments) to accept any number of keyword arguments. They are collected into a dictionary.

def build_user(**info):
    """Create a user profile from keyword arguments."""
    print("User Profile:")
    for key, value in info.items():
        print(f"  {key}: {value}")

build_user(name="Alice", age=25, city="NYC")
# Output:
# User Profile:
#   name: Alice
#   age: 25
#   city: NYC

build_user(username="bob123", email="bob@example.com", role="admin")
# Output:
# User Profile:
#   username: bob123
#   email: bob@example.com
#   role: admin

def save_settings(**settings):
    """Save application settings."""
    for setting, value in settings.items():
        print(f"Setting {setting} = {value}")
    return settings

config = save_settings(theme="dark", font_size=14, auto_save=True)
# Output:
# Setting theme = dark
# Setting font_size = 14
# Setting auto_save = True

Complete Parameter Combination

You can use regular parameters, *args, and **kwargs together. The order must be: regular, *args, keyword-only, **kwargs.

def complex_function(required, *args, default_param=None, **kwargs):
    """Demonstrate all parameter types together."""
    print(f"Required: {required}")
    print(f"Args: {args}")
    print(f"Default: {default_param}")
    print(f"Kwargs: {kwargs}")

complex_function(
    "value1",                    # required
    "extra1", "extra2",          # *args
    default_param="custom",      # keyword parameter
    option1="A", option2="B"     # **kwargs
)
# Output:
# Required: value1
# Args: ('extra1', 'extra2')
# Default: custom
# Kwargs: {'option1': 'A', 'option2': 'B'}

def send_email(to, *cc, subject="No Subject", **headers):
    """Send email with flexible recipients and headers."""
    print(f"To: {to}")
    if cc:
        print(f"CC: {', '.join(cc)}")
    print(f"Subject: {subject}")
    for header, value in headers.items():
        print(f"{header}: {value}")

send_email(
    "alice@example.com",
    "bob@example.com", "carol@example.com",
    subject="Meeting Tomorrow",
    priority="High",
    reply_to="noreply@example.com"
)
# Output:
# To: alice@example.com
# CC: bob@example.com, carol@example.com
# Subject: Meeting Tomorrow
# priority: High
# reply_to: noreply@example.com

Unpacking Arguments

You can unpack lists and dictionaries into function arguments using * and ** operators.

def calculate(a, b, c):
    """Perform calculation with three numbers."""
    return a + b * c

# Unpack a list as arguments
numbers = [2, 3, 4]
result = calculate(*numbers)  # Same as calculate(2, 3, 4)
print(result)  # Output: 14

def greet(first_name, last_name, age):
    return f"{first_name} {last_name} is {age} years old"

person = {"first_name": "Alice", "last_name": "Smith", "age": 30}
message = greet(**person)  # Same as greet(first_name="Alice", last_name="Smith", age=30)
print(message)  # Output: Alice Smith is 30 years old

def make_sandwich(bread, *fillings, toasted=False):
    sandwich = f"{bread} bread with {', '.join(fillings)}"
    if toasted:
        sandwich += " (toasted)"
    return sandwich

ingredients = ["wheat", "ham", "cheese", "lettuce"]
bread = ingredients[0]
fillings = ingredients[1:]

result = make_sandwich(bread, *fillings, toasted=True)
print(result)  # Output: wheat bread with ham, cheese, lettuce (toasted)

Functions can send data back to the caller using the return statement. This lets you capture results and use them elsewhere in your code.

Basic Return

Use return to send a value back. The caller can store this value in a variable or use it directly.

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

# Capture the returned value
result = add(5, 3)
print(result)  # Output: 8

# Use return value directly
print(add(10, 20))  # Output: 30

# Use in expressions
total = add(1, 2) + add(3, 4)
print(total)  # Output: 10 (3 + 7)

Multiple Return Values

Python functions can return multiple values as a tuple. You can unpack them directly into separate variables.

def get_min_max(numbers):
    return min(numbers), max(numbers)

# Unpack into two variables
lowest, highest = get_min_max([5, 2, 8, 1, 9])
print(f"Min: {lowest}, Max: {highest}")
# Output: Min: 1, Max: 9

def divide_and_remainder(a, b):
    quotient = a // b
    remainder = a % b
    return quotient, remainder

q, r = divide_and_remainder(17, 5)
print(f"17 / 5 = {q} remainder {r}")
# Output: 17 / 5 = 3 remainder 2

Early Return

Return can exit a function early, skipping remaining code. This is useful for guard clauses and error handling.

def divide(a, b):
    if b == 0:
        return "Error: Division by zero"
    return a / b

print(divide(10, 2))   # Output: 5.0
print(divide(10, 0))   # Output: Error: Division by zero

def get_grade(score):
    if score >= 90:
        return "A"
    if score >= 80:
        return "B"
    if score >= 70:
        return "C"
    return "F"

print(get_grade(95))  # Output: A
print(get_grade(65))  # Output: F

def double(num):
    return num * 2

print(double(7))   # Output: 14
print(double(15))  # Output: 30

def rectangle_info(length, width):
    area = length * width
    perimeter = 2 * (length + width)
    return area, perimeter

a, p = rectangle_info(5, 3)
print(f"Area: {a}, Perimeter: {p}")
# Output: Area: 15, Perimeter: 16

def safe_get(items, index):
    if index < 0 or index >= len(items):
        return "Index out of range"
    return items[index]

colors = ["red", "green", "blue"]
print(safe_get(colors, 1))   # Output: green
print(safe_get(colors, 10))  # Output: Index out of range

Returning None vs Empty Values

Understanding what your function returns is crucial. Python returns None if no return statement is used, which is different from returning empty collections.

def no_return():
    x = 10  # Does something
    # No return statement

result = no_return()
print(result)  # None
print(result is None)  # True

def empty_list():
    return []

result = empty_list()
print(result)  # []
print(result is None)  # False
print(len(result))  # 0

def empty_string():
    return ""

result = empty_string()
print(result)  # (empty)
print(result is None)  # False
print(len(result))  # 0

Returning Different Types

Functions can return different types based on conditions, but it's often better to return consistent types.

def find_user(user_id):
    """Find user by ID."""
    if user_id > 0:
        return {"id": user_id, "name": "User"}
    else:
        return "Invalid ID"  # Different type!

user = find_user(5)
# Need to check type before using
if isinstance(user, dict):
    print(user["name"])
else:
    print(user)

def find_user(user_id):
    """Find user by ID."""
    if user_id > 0:
        return {"id": user_id, "name": "User"}
    else:
        return None  # Same concept, consistent

user = find_user(5)
if user:  # Simple check
    print(user["name"])
else:
    print("User not found")

Using Return Values in Expressions

Return values can be used directly in expressions, assignments, or as arguments to other functions.

def square(x):
    return x * x

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

# Use return value in expression
result = square(5) + square(3)
print(result)  # Output: 34 (25 + 9)

# Pass return value to another function
total = add(square(2), square(3))
print(total)  # Output: 13 (4 + 9)

# Chain function calls
def increment(x):
    return x + 1

def double(x):
    return x * 2

result = double(increment(5))  # increment(5) = 6, double(6) = 12
print(result)  # Output: 12

# Use in conditionals
def is_even(n):
    return n % 2 == 0

if is_even(10):
    print("Even number")

# Store in data structures
numbers = [1, 2, 3, 4, 5]
squares = [square(n) for n in numbers]
print(squares)  # Output: [1, 4, 9, 16, 25]

Boolean Returns for Validation

Functions that return True or False are often called predicates. Name them with is_ or has_ prefixes.

def is_adult(age):
    """Check if person is 18 or older."""
    return age >= 18

def has_discount_code(order):
    """Check if order has a discount code."""
    return "discount_code" in order and order["discount_code"] != ""

def is_valid_password(password):
    """Validate password meets requirements."""
    return (len(password) >= 8 and
            any(c.isupper() for c in password) and
            any(c.islower() for c in password) and
            any(c.isdigit() for c in password))

# Using boolean functions in conditions
age = 25
if is_adult(age):
    print("Can vote")

password = "MyPass123"
if is_valid_password(password):
    print("Password accepted")
else:
    print("Password too weak")

# Combine with logical operators
def can_purchase_alcohol(age, has_id):
    return is_adult(age) and has_id

if can_purchase_alcohol(21, True):
    print("Sale approved")

Return Value Best Practices

Scope determines where variables can be accessed in your code. Understanding scope prevents bugs and helps you write cleaner functions. Python has local, enclosing, global, and built-in scopes (LEGB rule).

Local Scope

Variables created inside a function are local. They only exist within that function and cannot be accessed from outside.

def calculate():
    result = 10 * 5  # Local variable
    print(result)

calculate()  # Output: 50

# This would cause NameError
# print(result)  # Error: result is not defined outside the function

def greet():
    message = "Hello"  # Local to greet()
    print(message)

def farewell():
    message = "Goodbye"  # Different local variable
    print(message)

greet()     # Output: Hello
farewell()  # Output: Goodbye

Global Scope

Variables defined at the top level of a module are global. They can be read from inside functions, but modifying them requires the global keyword.

# Global variable
counter = 0

def read_global():
    print(f"Counter is {counter}")  # Can read global

read_global()  # Output: Counter is 0

def increment():
    global counter  # Declare we want to modify global
    counter += 1
    print(f"Counter is now {counter}")

increment()  # Output: Counter is now 1
increment()  # Output: Counter is now 2
print(counter)  # Output: 2

# Without global keyword
def broken_increment():
    counter = counter + 1  # Error: local variable referenced before assignment

# broken_increment()  # Would raise UnboundLocalError

Enclosing Scope (Nested Functions)

When you define a function inside another function, the inner function can access variables from the outer function.

def outer():
    outer_var = "I'm from outer"
    
    def inner():
        # Can access outer_var from enclosing scope
        print(outer_var)
        inner_var = "I'm from inner"
        print(inner_var)
    
    inner()
    # Cannot access inner_var here
    # print(inner_var)  # NameError

outer()
# Output:
# I'm from outer
# I'm from inner

def make_multiplier(n):
    def multiply(x):
        return x * n  # n comes from enclosing scope
    return multiply

times_3 = make_multiplier(3)
times_5 = make_multiplier(5)

print(times_3(10))  # Output: 30
print(times_5(10))  # Output: 50

The nonlocal Keyword

Use nonlocal to modify variables from an enclosing (but not global) scope.

def counter():
    count = 0
    
    def increment():
        nonlocal count  # Modify variable from enclosing scope
        count += 1
        return count
    
    def decrement():
        nonlocal count
        count -= 1
        return count
    
    def get_count():
        return count
    
    return increment, decrement, get_count

inc, dec, get = counter()
print(inc())  # Output: 1
print(inc())  # Output: 2
print(dec())  # Output: 1
print(get())  # Output: 1

Scope Visualization Example

Here is a comprehensive example showing all scope levels working together:

# Built-in scope: len, print, etc.
# Global scope
global_var = "I'm global"

def outer_function():
    # Enclosing scope for inner_function
    outer_var = "I'm in outer"
    
    def inner_function():
        # Local scope
        local_var = "I'm local"
        
        # Access all scopes
        print(f"Local: {local_var}")
        print(f"Enclosing: {outer_var}")
        print(f"Global: {global_var}")
        print(f"Built-in: {len('hello')}")
    
    inner_function()
    print(f"Outer can access: {outer_var}")
    # print(local_var)  # Error: not accessible

outer_function()
print(f"Global level: {global_var}")
# print(outer_var)  # Error: not accessible
# print(local_var)  # Error: not accessible

name = "Global"  # Global variable

def test_scope():
    name = "Local"  # Local variable (shadows global)
    print(f"Inside function: {name}")

test_scope()  # Output: Inside function: Local
print(f"Outside function: {name}")  # Output: Outside function: Global

total = 0  # Global variable

def add_to_total(amount):
    global total
    total += amount
    print(f"Total is now: {total}")

add_to_total(10)  # Output: Total is now: 10
add_to_total(25)  # Output: Total is now: 35
add_to_total(5)   # Output: Total is now: 40

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

counter1 = make_counter()
counter2 = make_counter()

print(counter1())  # Output: 1
print(counter1())  # Output: 2
print(counter2())  # Output: 1 (independent counter)
print(counter1())  # Output: 3

def create_calculator():
    result = 0
    
    def add(n):
        nonlocal result
        result += n
    
    def subtract(n):
        nonlocal result
        result -= n
    
    def get_result():
        return result
    
    return add, subtract, get_result

add, sub, get = create_calculator()
add(10)
add(5)
sub(3)
print(get())  # Output: 12

Writing good functions takes practice. Follow these guidelines to create clean, maintainable, and reusable code that other developers (including future you) will appreciate.

Function Naming Conventions

Clear names make code self-documenting. Follow Python's PEP 8 style guide for naming.

def calculate_total_price(items, tax_rate):
    pass

def is_valid_email(email):
    pass

def get_user_by_id(user_id):
    pass

def send_welcome_email(user):
    pass

def calc(x, y):  # Too abbreviated
    pass

def func1(data):  # Generic, meaningless
    pass

def GetUser(id):  # Wrong case (not snake_case)
    pass

def do_stuff(thing):  # Vague
    pass

Single Responsibility Principle

Each function should do one thing and do it well. If a function does too much, split it into smaller functions.

def process_order(user, items):
    # Validates user
    if not user.is_active:
        return "Error"
    
    # Calculates total
    total = sum(item.price for item in items)
    
    # Applies discount
    if user.is_premium:
        total *= 0.9
    
    # Sends email
    send_email(user.email, f"Total: {total}")
    
    # Updates database
    db.save_order(user, items, total)
    
    # Logs activity
    log(f"Order for {user.name}")

def validate_user(user):
    return user.is_active

def calculate_total(items):
    return sum(item.price for item in items)

def apply_discount(total, user):
    return total * 0.9 if user.is_premium else total

def process_order(user, items):
    if not validate_user(user):
        return "Error"
    
    total = calculate_total(items)
    total = apply_discount(total, user)
    
    send_confirmation(user, total)
    save_order(user, items, total)
    log_order(user)
    
    return total

Function Length Guidelines

Keep functions short and focused. A good rule of thumb is 10-20 lines of code per function.

Comprehensive Docstrings

Document your functions with docstrings. Describe what the function does, parameters, return values, and any exceptions raised.

def calculate_discount(price, discount_percent, min_price=0):
    """
    Calculate the discounted price of an item.
    
    Args:
        price (float): The original price of the item
        discount_percent (float): The discount percentage (0-100)
        min_price (float, optional): Minimum price threshold. 
            Discount only applies if price >= min_price. Defaults to 0.
    
    Returns:
        float: The price after applying the discount
    
    Raises:
        ValueError: If discount_percent is negative or greater than 100
        ValueError: If price is negative
    
    Examples:
        >>> calculate_discount(100, 10)
        90.0
        >>> calculate_discount(50, 20, min_price=60)
        50.0
    """

    if price < 0:
        raise ValueError("Price cannot be negative")
    if discount_percent < 0 or discount_percent > 100:
        raise ValueError("Discount must be between 0 and 100")

    if price < min_price:
        return price
    
    discount_amount = price * (discount_percent / 100)
    return price - discount_amount

# Access the docstring
help(calculate_discount)

DRY Principle (Don't Repeat Yourself)

If you find yourself writing the same code in multiple places, extract it into a function.

# Calculating tax in multiple places
order1_total = 100
order1_with_tax = order1_total * 1.08

order2_total = 200
order2_with_tax = order2_total * 1.08

order3_total = 150
order3_with_tax = order3_total * 1.08

def add_tax(amount, rate=0.08):
    """Add tax to an amount."""
    return amount * (1 + rate)

order1_with_tax = add_tax(100)
order2_with_tax = add_tax(200)
order3_with_tax = add_tax(150)

# Easy to change tax rate everywhere
order4_with_tax = add_tax(300, rate=0.10)

Default Argument Gotcha: Mutable Defaults

Never use mutable objects (lists, dicts) as default arguments. They are created once and shared across all calls.

def add_item(item, items=[]):
    items.append(item)
    return items

# Unexpected behavior!
list1 = add_item("apple")
print(list1)  # ['apple']

list2 = add_item("banana")
print(list2)  # ['apple', 'banana'] - WRONG!

# The default list is shared!

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

# Correct behavior
list1 = add_item("apple")
print(list1)  # ['apple']

list2 = add_item("banana")
print(list2)  # ['banana'] - CORRECT!

Type Hints (Python 3.5+)

Type hints make your code more self-documenting and enable better IDE support and static analysis tools.

def greet(name: str, age: int) -> str:
    """Greet a person with their name and age."""
    return f"Hello, {name}! You are {age} years old."

def calculate_area(width: float, height: float) -> float:
    """Calculate rectangle area."""
    return width * height

def process_items(items: list[str]) -> dict[str, int]:
    """Count occurrences of each item."""
    counts = {}
    for item in items:
        counts[item] = counts.get(item, 0) + 1
    return counts

# Type hints are documentation, not enforcement
result = greet("Alice", 25)  # Correct types
result = greet("Bob", "25")  # Python still runs this!

# Use mypy or other tools for type checking:
# mypy your_script.py

Guard Clauses for Early Exit

Check error conditions first and return early. This reduces nesting and makes code clearer.

def process_user(user):
    if user is not None:
        if user.is_active:
            if user.has_permission:
                # Do actual work here
                return user.process()
            else:
                return "No permission"
        else:
            return "Inactive user"
    else:
        return "User not found"

def process_user(user):
    if user is None:
        return "User not found"
    
    if not user.is_active:
        return "Inactive user"
    
    if not user.has_permission:
        return "No permission"
    
    # Main logic at top level
    return user.process()

Function Composition

Build complex operations by combining simple functions. Each function does one thing, and you chain them together.

def clean_text(text):
    """Remove whitespace and convert to lowercase."""
    return text.strip().lower()

def remove_punctuation(text):
    """Remove common punctuation marks."""
    for char in ".,!?;:":
        text = text.replace(char, "")
    return text

def count_words(text):
    """Count words in text."""
    words = text.split()
    return len(words)

def analyze_sentence(sentence):
    """Clean and analyze a sentence."""
    cleaned = clean_text(sentence)
    no_punct = remove_punctuation(cleaned)
    word_count = count_words(no_punct)
    
    return {
        "original": sentence,
        "cleaned": cleaned,
        "word_count": word_count
    }

result = analyze_sentence("  Hello, World! How are you?  ")
print(result)
# Output: {'original': '  Hello, World! How are you?  ', 
#          'cleaned': 'hello, world! how are you?', 
#          'word_count': 4}

Learn to identify and fix common function errors. Understanding these pitfalls will save you hours of debugging.

Mistake 1: Forgetting to Call the Function

def greet():
    return "Hello"

message = greet  # Forgot parentheses!
print(message)
# Output: 

# The function object, not the result

def greet():
    return "Hello"

message = greet()  # Called with parentheses
print(message)
# Output: Hello

# Function was executed, result stored

Mistake 2: Print vs Return Confusion

def add(a, b):
    print(a + b)  # Prints, but no return

result = add(5, 3)
# Output: 8 (printed)

print(result)
# Output: None

# Can't use the value in calculations
total = result * 2  # Error: can't multiply None

def add(a, b):
    return a + b  # Returns the value

result = add(5, 3)
# No output (nothing printed)

print(result)
# Output: 8

# Can use the value
total = result * 2  # Works! total = 16

Mistake 3: Modifying Mutable Default Arguments

def append_to(item, target=[]):
    target.append(item)
    return target

list1 = append_to(1)
print(list1)  # [1]

list2 = append_to(2)
print(list2)  # [1, 2] - Wrong!

list3 = append_to(3)
print(list3)  # [1, 2, 3] - All share same list!

def append_to(item, target=None):
    if target is None:
        target = []  # Create fresh list
    target.append(item)
    return target

list1 = append_to(1)
print(list1)  # [1]

list2 = append_to(2)
print(list2)  # [2] - Correct!

list3 = append_to(3)
print(list3)  # [3] - Each gets own list

Mistake 4: Wrong Number of Arguments

# Function definition
def calculate(a, b, c):
    return a + b + c

# Common errors:

# Too few arguments
calculate(1, 2)
# TypeError: calculate() missing 1 required positional argument: 'c'

# Too many arguments
calculate(1, 2, 3, 4)
# TypeError: calculate() takes 3 positional arguments but 4 were given

# Fix 1: Provide exact number
result = calculate(1, 2, 3)  # Correct

# Fix 2: Use default parameters
def calculate(a, b, c=0):  # c is optional now
    return a + b + c

result = calculate(1, 2)     # Works, c defaults to 0
result = calculate(1, 2, 3)  # Also works

# Fix 3: Use *args for variable arguments
def calculate(*args):
    return sum(args)

result = calculate(1, 2)        # Works
result = calculate(1, 2, 3, 4)  # Also works

Mistake 5: Indentation Errors

def greet(name):
print(f"Hello, {name}")  # Not indented!
# IndentationError: expected an indented block

def calculate():
    x = 10
  y = 20  # Wrong indentation level
# IndentationError: unindent does not match

def greet(name):
    print(f"Hello, {name}")  # Properly indented

def calculate():
    x = 10
    y = 20  # Same level as x
    return x + y

Mistake 6: Scope Issues

# Problem: Trying to access local variable outside function
def calculate():
    result = 100
    return result

print(result)  # NameError: name 'result' is not defined

# Solution 1: Use the return value
def calculate():
    result = 100
    return result

value = calculate()
print(value)  # Works

# Problem: Modifying global variable without declaration
counter = 0

def increment():
    counter = counter + 1  # Error: local variable referenced before assignment
    return counter

# Solution: Use global keyword
counter = 0

def increment():
    global counter
    counter = counter + 1
    return counter

# Better Solution: Avoid globals, use parameters and returns
def increment(counter):
    return counter + 1

counter = 0
counter = increment(counter)

Mistake 7: Name Shadowing

# Problem: Using same name as built-in function
def list(items):  # Shadows built-in list()
    return items

result = list([1, 2, 3])
# Now you can't use list() to convert other types!
# numbers = list(range(5))  # Error

# Solution: Use different name
def create_list(items):  # Different name
    return items

# Problem: Parameter shadows global
name = "Global"

def greet(name):  # Parameter name shadows global name
    print(f"Hello, {name}")  # Uses parameter, not global
    
greet("Local")  # Output: Hello, Local

# This is actually OK in most cases, but can be confusing
# Use descriptive parameter names that make the distinction clear

Debugging Tips

def calculate(x, y):
    print(f"Input: x={x}, y={y}")
    result = x * y
    print(f"Result: {result}")
    return result

def complex_calc(a, b):
    return (a + b) * 2

# Test with easy numbers
print(complex_calc(1, 1))  # Should be 4
print(complex_calc(0, 5))  # Should be 10

def process(data):
    print(f"Type: {type(data)}")
    print(f"Value: {data}")
    # Continue processing

A comprehensive cheat sheet of function syntax and patterns for quick lookup.

Function Definition Syntax

Function Call Syntax

Return Statement Patterns

# Single value
return 42

# Multiple values (tuple)
return value1, value2, value3

# Conditional return
return True if condition else False

# Early return (guard clause)
if error:
    return None

# No return (implicit None)
# Function ends without return statement

# Return None explicitly
return None

# Return complex data structure
return {
    "status": "success",
    "data": [1, 2, 3],
    "count": 3
}

Common Function Templates

def is_valid_something(value):
    """
    Check if value meets criteria.
    
    Args:
        value: The value to validate
    
    Returns:
        bool: True if valid, False otherwise
    """
    # Validation logic
    if not condition:
        return False
    
    # More checks...
    
    return True

def calculate_something(param1, param2):
    """
    Calculate result based on inputs.
    
    Args:
        param1: First parameter
        param2: Second parameter
    
    Returns:
        The calculated result
    """
    # Input validation
    if not valid:
        return None
    
    # Calculation
    result = param1 + param2
    
    return result

def transform_data(input_data):
    """
    Transform input to output format.
    
    Args:
        input_data: Raw input data
    
    Returns:
        Transformed data
    """
    # Handle empty input
    if not input_data:
        return []
    
    # Transform
    output = []
    for item in input_data:
        transformed = process(item)
        output.append(transformed)
    
    return output

def aggregate_data(items):
    """
    Aggregate items into summary.
    
    Args:
        items: Collection of items
    
    Returns:
        dict: Summary statistics
    """
    if not items:
        return {}
    
    return {
        "count": len(items),
        "total": sum(items),
        "average": sum(items) / len(items),
        "min": min(items),
        "max": max(items)
    }

Parameter Order Rules

# Complete example with all parameter types
def complete_function(
    required_param,           # 1. Required positional
    default_param="default",  # 2. Positional with default
    *args,                    # 3. Variable positional
    keyword_only,             # 4. Keyword-only (after *args)
    key_with_default="value", # 5. Keyword-only with default
    **kwargs                  # 6. Variable keyword
):
    """Function showing all parameter types."""
    print(f"Required: {required_param}")
    print(f"Default: {default_param}")
    print(f"Args: {args}")
    print(f"Keyword-only: {keyword_only}")
    print(f"Key with default: {key_with_default}")
    print(f"Kwargs: {kwargs}")

# Call example
complete_function(
    "value1",                    # required_param
    "value2",                    # default_param
    "extra1", "extra2",          # *args
    keyword_only="must_name",    # keyword_only
    key_with_default="custom",   # key_with_default
    option1="A", option2="B"     # **kwargs
)

Scope Quick Reference

# Scope modification keywords
global var_name    # Modify global variable
nonlocal var_name  # Modify enclosing scope variable

Best Practices Checklist

Learn reusable patterns that solve common programming problems. These recipes are building blocks for larger applications.

Validation Functions

Functions that check if data meets certain criteria:

def is_palindrome(text):
    """Check if text reads same forwards and backwards."""
    cleaned = text.lower().replace(" ", "")
    return cleaned == cleaned[::-1]

def has_digits(text):
    """Check if text contains any digits."""
    return any(char.isdigit() for char in text)

def is_all_caps(text):
    """Check if all letters are uppercase."""
    return text.isupper() and text != text.lower()

# Usage
print(is_palindrome("racecar"))  # True
print(is_palindrome("A man a plan a canal Panama"))  # True
print(has_digits("abc123"))      # True
print(is_all_caps("HELLO"))      # True

def is_even(n):
    """Check if number is even."""
    return n % 2 == 0

def is_prime(n):
    """Check if number is prime."""
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def is_in_range(value, min_val, max_val):
    """Check if value is within range."""
    return min_val <= value <= max_val

# Usage
print(is_even(10))            # True
print(is_prime(17))           # True
print(is_in_range(5, 1, 10))  # True

Transformation Functions

Functions that convert data from one form to another:

def capitalize_words(text):
    """Capitalize first letter of each word."""
    return ' '.join(word.capitalize() for word in text.split())

def snake_to_camel(snake_str):
    """Convert snake_case to camelCase."""
    components = snake_str.split('_')
    return components[0] + ''.join(x.title() for x in components[1:])

def seconds_to_time(seconds):
    """Convert seconds to HH:MM:SS format."""
    hours = seconds // 3600
    minutes = (seconds % 3600) // 60
    secs = seconds % 60
    return f"{hours:02d}:{minutes:02d}:{secs:02d}"

def list_to_string(items, separator=", "):
    """Join list items into a string."""
    return separator.join(str(item) for item in items)

def truncate(text, length, suffix="..."):
    """Truncate text to specified length."""
    if len(text) <= length:
        return text
    return text[:length - len(suffix)] + suffix

# Usage examples
print(capitalize_words("hello world"))      # Hello World
print(snake_to_camel("user_name"))          # userName
print(seconds_to_time(3665))                # 01:01:05
print(list_to_string([1, 2, 3], " | "))     # 1 | 2 | 3
print(truncate("Long text here", 10))       # Long te...

Aggregation Functions

Functions that combine or summarize data:

def count_occurrences(items, target):
    """Count how many times target appears in items."""
    return items.count(target)

def unique_items(items):
    """Return list with duplicates removed."""
    return list(set(items))

def most_common(items):
    """Return the most frequently occurring item."""
    if not items:
        return None
    return max(set(items), key=items.count)

def group_by_length(words):
    """Group words by their length."""
    groups = {}
    for word in words:
        length = len(word)
        if length not in groups:
            groups[length] = []
        groups[length].append(word)
    return groups

def calculate_stats(numbers):
    """Return dictionary with basic statistics."""
    if not numbers:
        return {}
    return {
        "count": len(numbers),
        "sum": sum(numbers),
        "average": sum(numbers) / len(numbers),
        "min": min(numbers),
        "max": max(numbers)
    }

# Usage
print(count_occurrences([1, 2, 2, 3, 2], 2))  # 3
print(unique_items([1, 2, 2, 3, 1]))          # [1, 2, 3]
print(most_common(['a', 'b', 'a', 'c', 'a'])) # 'a'

words = ["cat", "dog", "bird", "fish", "ant"]
print(group_by_length(words))
# {3: ['cat', 'dog', 'ant'], 4: ['bird', 'fish']}

print(calculate_stats([10, 20, 30, 40, 50]))
# {'count': 5, 'sum': 150, 'average': 30.0, 'min': 10, 'max': 50}

Helper Functions (Pure Functions)

Small, reusable functions with no side effects:

def clamp(value, min_value, max_value):
    """Restrict value to be within min and max."""
    return max(min_value, min(value, max_value))

def percentage(part, whole):
    """Calculate what percentage part is of whole."""
    if whole == 0:
        return 0
    return (part / whole) * 100

def average_of_two(a, b):
    """Calculate mean of two numbers."""
    return (a + b) / 2

def sign(number):
    """Return -1, 0, or 1 based on number's sign."""
    if number > 0:
        return 1
    elif number < 0:
        return -1
    else:
        return 0

def swap_values(a, b):
    """Swap two values and return them."""
    return b, a

# Usage
print(clamp(15, 0, 10))            # 10 (clamped to max)
print(clamp(-5, 0, 10))            # 0 (clamped to min)
print(percentage(25, 200))         # 12.5
print(average_of_two(10, 20))      # 15.0
print(sign(-5))                    # -1
print(swap_values(1, 2))           # (2, 1)

Factory Functions

Functions that create and return other objects or functions:

def make_multiplier(factor):
    """Create a function that multiplies by factor."""
    def multiply(x):
        return x * factor
    return multiply

def create_counter(start=0, step=1):
    """Create a counter that increments by step."""
    count = start - step  # Start one step before
    
    def next_value():
        nonlocal count
        count += step
        return count
    
    return next_value

def make_greeter(greeting):
    """Create a customized greeting function."""
    def greet(name):
        return f"{greeting}, {name}!"
    return greet

# Usage
times_3 = make_multiplier(3)
times_5 = make_multiplier(5)
print(times_3(10))  # 30
print(times_5(10))  # 50

counter = create_counter(start=0, step=5)
print(counter())  # 5
print(counter())  # 10
print(counter())  # 15

say_hello = make_greeter("Hello")
say_hi = make_greeter("Hi")
print(say_hello("Alice"))  # Hello, Alice!
print(say_hi("Bob"))       # Hi, Bob!

Decorator Pattern Preview

Functions that modify or enhance other functions (advanced topic):

def timer_wrapper(func):
    """Measure how long a function takes to run."""
    import time
    
    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

def validate_positive(func):
    """Ensure all arguments are positive numbers."""
    def wrapper(*args):
        if any(arg <= 0 for arg in args):
            return "Error: All arguments must be positive"
        return func(*args)
    
    return wrapper

# Create enhanced functions
@timer_wrapper
def slow_calculation(n):
    """Simulate slow calculation."""
    total = 0
    for i in range(n):
        total += i
    return total

@validate_positive
def divide(a, b):
    """Divide a by b."""
    return a / b

# Usage
result = slow_calculation(1000000)
# Output: slow_calculation took 0.0234 seconds

print(divide(10, 2))   # 5.0
print(divide(-10, 2))  # Error: All arguments must be positive

Visualize how functions work with these interactive examples.

Function Call Visualizer

See how data flows through function parameters and return values:

def calculate_tax(amount, rate):
    tax = amount * rate
    total = amount + tax
    return total

price = 100
tax_rate = 0.08

result = calculate_tax(price, tax_rate)

# Inside function:
# tax = 100 * 0.08 = 8.0
# total = 100 + 8.0 = 108.0
# return 108.0

# result = 108.0

Scope Visualizer

Understand variable scope with this step-by-step breakdown:

# Global scope
global_var = "I'm global"

def outer():
    # Enclosing scope
    outer_var = "I'm in outer"
    
    def inner():
        # Local scope
        local_var = "I'm local"
        print(f"1. {local_var}")
        print(f"2. {outer_var}")
        print(f"3. {global_var}")
    
    inner()

outer()

Default Arguments Behavior

See how default arguments work (and the mutable default pitfall):

def add_item(item, items=[]):
    items.append(item)
    return items

# First call
list1 = add_item("apple")
print(list1)  # ['apple']

# Second call
list2 = add_item("banana")
print(list2)  # ['apple', 'banana']

# Same list object!
print(list1 is list2)  # True

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

# First call
list1 = add_item("apple")
print(list1)  # ['apple']

# Second call
list2 = add_item("banana")
print(list2)  # ['banana'] ✓

# Different list objects
print(list1 is list2)  # False

*args and **kwargs Visualizer

See how variable-length arguments are collected:

def sum_all(*args):
    print(f"args type: {type(args)}")
    print(f"args value: {args}")
    return sum(args)

result = sum_all(1, 2, 3, 4, 5)

# Output:
# args type: 
# args value: (1, 2, 3, 4, 5)
# result: 15

def build_profile(**kwargs):
    print(f"kwargs type: {type(kwargs)}")
    print(f"kwargs value: {kwargs}")

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

# Output:
# kwargs type: 
# kwargs value: {'name': 'Alice', 
#                'age': 25, 
#                'city': 'NYC'}

Return Value Patterns

Compare different return patterns and their use cases:

Function Composition Pipeline

See how small functions combine to create complex behavior:

# Step 1: Define small, focused functions
def remove_whitespace(text):
    """Remove leading/trailing whitespace."""
    return text.strip()

def lowercase(text):
    """Convert to lowercase."""
    return text.lower()

def remove_punctuation(text):
    """Remove common punctuation."""
    for char in ".,!?;:":
        text = text.replace(char, "")
    return text

def word_count(text):
    """Count words in text."""
    return len(text.split())

# Step 2: Compose into pipeline
def analyze_text(text):
    """Complete text analysis pipeline."""
    # Data flows through transformations
    cleaned = remove_whitespace(text)        # "  Hello, World!  " → "Hello, World!"
    lowered = lowercase(cleaned)             # "Hello, World!" → "hello, world!"
    no_punct = remove_punctuation(lowered)   # "hello, world!" → "hello world"
    count = word_count(no_punct)             # "hello world" → 2
    
    return {
        "original": text,
        "cleaned": no_punct,
        "word_count": count
    }

# Step 3: Use the pipeline
result = analyze_text("  Hello, World! How are you?  ")
print(result)
# Output: {
#     'original': '  Hello, World! How are you?  ',
#     'cleaned': 'hello world how are you',
#     'word_count': 5
# }