5 Functions

Functions are reusable blocks of code that perform specific tasks. They help organize code, avoid repetition, and make programs more maintainable. In Python, functions are defined using the def keyword.

5.1 Defining functions and using them

Here’s the basic syntax for defining and calling functions:

def greet(name):
    message = f"Hello, {name}!"
    return message

# Calling the function
result = greet("Alice")
print(result)  # Outputs: Hello, Alice!

Let’s understand what happens step by step:

Function Definition:
- def tells Python we’re creating a new function
- greet is the name we give our function
- name in parentheses is a parameter - it’s like a variable that will hold whatever value we pass to the function
- The colon : marks the start of the function’s body
- Everything indented belongs to this function
Function Body:
- Creates a message using the value stored in name
- return sends this message back to wherever the function was called
Using the Function:
- We call the function by writing its name followed by parentheses
- We put “Alice” in the parentheses - this becomes the value of name
- The function creates the message “Hello, Alice!”
- The message is returned and stored in result
- Finally, we print result to see the message

Let’s break down this example:

def is a special word that tells Python we’re creating a new function
greet is the name we chose for our function - like variables, function names should be descriptive
The parentheses () after the name contain the parameters - in this case, name is a parameter
The colon : marks the start of the function’s body
Everything indented under the def line is part of the function’s body
return sends a value back to wherever the function was called from

Python uses indentation (usually 4 spaces) to group lines of code together. Jupyter and code editors will insert indentation when you press that Tab key. All the lines indented under def belong to that function. This is different from many other programming languages that use braces {} or other symbols.

When you call a function like greet("Alice"), here’s what happens step by step:

Python evaluates the argument "Alice" (in this case it’s just a simple string)
The parameter name is bound to the value "Alice" - think of this like creating a new variable name = "Alice" that only exists inside the function
The function body runs:
- First it creates the message "Hello, Alice!"
- Then it hits the return statement
The return message sends the string "Hello, Alice!" back to where we called the function
This returned value is stored in result

The return statement is like a special exit door for your function - it both specifies what value to send back AND immediately ends the function’s execution. For example:

def example():
    print("First line")
    return "Done"
    print("This never runs!")  # This line is never reached

result = example()  # Only prints "First line"
print(result)      # Prints "Done"

For example:

def double(x):
    return x * 2

a = 5
result = double(a + 3)  # a + 3 is evaluated first (8), then passed to double()
print(result)  # Outputs: 16

5.2 Multiple return values

Python functions can return multiple values using tuples. The values are automatically packed into a tuple by the function and can be unpacked by the caller:

def get_coordinates():
    x = 10
    y = 20
    return x, y  # Automatically packed into a tuple

# Method 1: Unpack into separate variables
x_pos, y_pos = get_coordinates()
print(x_pos)  # Outputs: 10
print(y_pos)  # Outputs: 20

# Method 2: Keep as tuple
coords = get_coordinates()
print(coords)  # Outputs: (10, 20)

This is particularly useful when a function needs to return related values:

def analyze_numbers(numbers):
    minimum = min(numbers)
    maximum = max(numbers)
    average = sum(numbers) / len(numbers)
    return minimum, maximum, average

# Unpack all values
min_val, max_val, avg = analyze_numbers([1, 2, 3, 4, 5])

5.3 Default arguments and keyword arguments

Functions can have default values for parameters, making them optional when calling the function:

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

print(greet("Bob"))          # Uses default greeting: Hello, Bob!
print(greet("Alice", "Hi"))  # Override default: Hi, Alice!

You can also use keyword arguments to specify arguments by name, making the code more readable:

def create_profile(name, age, city="Unknown", hobby=None):
    return f"Name: {name}, Age: {age}, City: {city}, Hobby: {hobby}"

# Using keyword arguments (order doesn't matter)
profile = create_profile(
    age=25,
    name="Alice",
    hobby="Reading"
)

⚠️ Warning: Be careful with mutable default arguments! They are created once when the function is defined, not each time it’s called:

# BAD: List is mutable and shared between calls
def add_item(item, lst=[]):  # Don't do this!
    lst.append(item)
    return lst

print(add_item("apple"))     # Returns: ["apple"]
print(add_item("banana"))    # Returns: ["apple", "banana"]  - Surprise!
print(add_item("cherry"))    # Returns: ["apple", "banana", "cherry"]  - Oops!

What’s happening here? The empty list [] is created only once when Python first reads the def statement, not each time the function runs. This means all calls to add_item are using the same list! It’s like having a shared shopping cart that keeps accumulating items from different shoppers.

The correct way is to use None as the default and create a new list when needed:

# GOOD: Use None as default and create list in function
def add_item(item, lst=None):
    if lst is None:
        lst = []    # Creates a fresh list each time
    lst.append(item)
    return lst

print(add_item("apple"))     # Returns: ["apple"]
print(add_item("banana"))    # Returns: ["banana"]  - Good!
print(add_item("cherry"))    # Returns: ["cherry"]  - Perfect!

Now each call gets its own fresh list unless you specifically pass one in:

my_list = ["existing"]
add_item("new", my_list)    # Returns: ["existing", "new"]

5.4 Variable scoping

Think of variable scope like different rooms in a house. Each room (scope) has its own set of items (variables), but there are rules about who can see and use which items.

5.4.1 Local Variables - Your Private Room

When you create a variable inside a function, it’s like putting something in your private room. Only code inside that function can see or use it:

def make_greeting():
    name = "Alice"    # This is a local variable
    return f"Hello, {name}!"

print(make_greeting())    # Works fine: "Hello, Alice!"
print(name)              # Error! We can't see 'name' out here

This is good! It means different functions can use the same variable names without confusion:

def greet_friend():
    name = "Bob"      # This is a different 'name'
    return f"Hi {name}!"

def greet_teacher():
    name = "Mrs. Smith"  # This is yet another 'name'
    return f"Hello {name}!"

# Each function has its own private 'name' variable
print(greet_friend())    # "Hi Bob!"
print(greet_teacher())   # "Hello Mrs. Smith!"

5.4.2 Global Variables - The Living Room

Variables created outside of any function are called global variables. Think of them like items in the living room - everyone can see them:

message = "Welcome!"    # A global variable

def say_greeting():
    print(message)     # Functions can see global variables

say_greeting()         # Prints: "Welcome!"

However, there’s a catch! While functions can see global variables, they need special permission to change them:

score = 0    # Global variable

def add_point():
    global score    # Tell Python we want to change the global variable
    score = score + 1

add_point()
print(score)    # Prints: 1

Without the global keyword, Python would create a new local variable instead of changing the global one.

5.4.3 Nested Functions - Rooms within Rooms

You can define functions inside other functions. The inner function can see variables from the outer function:

def make_counter():
    count = 0    # Variable in outer function
    
    def increment():
        nonlocal count    # Tell Python we want to use outer function's variable
        count = count + 1
        return count
    
    return increment

# Create a counter
counter = make_counter()
print(counter())    # Prints: 1
print(counter())    # Prints: 2

5.4.4 Best Practices

Try to avoid global variables when possible. They make it harder to understand where values are coming from.
Keep functions focused and self-contained. If a function needs data, pass it as parameters.
Use clear, descriptive names that won’t conflict with other parts of your code.

Here’s a good example putting it all together:

def calculate_total(prices):
    """Calculate total price including 10% tax"""
    subtotal = sum(prices)    # Local variable for sum
    tax_rate = 0.10          # Local variable for tax rate
    tax = subtotal * tax_rate
    total = subtotal + tax
    return total

# Each call is completely independent
print(calculate_total([10, 20]))    # Prints: 33.0
print(calculate_total([5, 15]))     # Prints: 22.0

5.5 Exceptions

Sometimes things go wrong when running our functions. Let’s look at what happens when we try to convert text to a number:

def convert_to_number(text):
    number = int(text)
    return number

# This works fine
print(convert_to_number("123"))    # Prints: 123

# But this crashes!
print(convert_to_number("cat"))    # ValueError: invalid literal for int() with base 10: 'cat'

When something goes wrong, Python raises an exception - a special object that describes the error. Without handling these exceptions, our program crashes!

We can handle these errors gracefully using try and except:

def convert_to_number(text):
    try:
        number = int(text)
        return number
    except ValueError:
        print(f"Sorry, '{text}' is not a valid number")
        return None

# Try it with different inputs
print(convert_to_number("123"))    # Works fine: 123
print(convert_to_number("cat"))    # Handles error gracefully: None

Let’s break this down:

The try block contains code that might raise an exception
If int(text) fails (like when text=“cat”), it raises a ValueError
The except block catches that error and handles it nicely
Instead of crashing, our function returns None and explains the problem

You can catch multiple types of exceptions:

def divide_numbers(x, y):
    try:
        result = x / y
        return result
    except ZeroDivisionError:
        print("Error: Cannot divide by zero!")
        return None
    except TypeError:
        print("Error: Both inputs must be numbers!")
        return None

print(divide_numbers(10, 2))     # Works: 5.0
print(divide_numbers(10, 0))     # Handles division by zero
print(divide_numbers(10, "two")) # Handles invalid input type

Sometimes we want to handle an exception but continue with the function’s operation. Here’s an example that retries reading user input until it’s valid:

def get_age():
    while True:
        try:
            age_text = input("Please enter your age: ")
            age = int(age_text)
            if age < 0 or age > 150:
                raise ValueError("Age must be between 0 and 150")
            return age
        except ValueError as e:
            print(f"Invalid input: {e}")
            print("Please try again...")
            # Instead of returning, we continue the loop

# Usage:
# age = get_age()
# This will keep asking until valid input is received

This function:

Uses a loop to keep trying until successful
Catches ValueError but doesn’t immediately return
Gives feedback and continues asking for input
Only returns once valid input is received

This pattern is common when:

Reading files that might be temporarily locked
Making network requests that might timeout
Handling user input that needs validation

5.5.1 Raising Exceptions

Sometimes your function needs to tell the caller that something went wrong. You can do this by raising your own exceptions:

def withdraw_money(balance, amount):
    if amount <= 0:
        raise ValueError("Withdrawal amount must be positive")
    if amount > balance:
        raise ValueError("Insufficient funds")
    
    return balance - amount

# Try using the function
try:
    new_balance = withdraw_money(100, 50)
    print(f"New balance: ${new_balance}")  # Works: New balance: $50
    
    new_balance = withdraw_money(100, -10)  # Raises: ValueError: Withdrawal amount must be positive
except ValueError as e:
    print(f"Error: {e}")

try:
    new_balance = withdraw_money(100, 150)  # Raises: ValueError: Insufficient funds
except ValueError as e:
    print(f"Error: {e}")

When an exception occurs in Python, execution immediately stops at that point and Python begins searching through the call stack for exception handlers. It starts at the current function and progressively moves outward through each calling function, looking for a try/except block that can handle the specific type of exception.

For example, imagine we have a chain of function calls: outer() calls middle() which calls inner(). If inner() raises an exception, Python first checks if inner() itself has a try/except block to handle it. If not, Python immediately stops executing inner() and checks middle(). If middle() doesn’t handle it either, Python moves to outer(). This continues until either:

A matching try/except block is found, which handles the exception
No handler is found, and the program crashes with an error message

Here’s what happens in detail when we call withdraw_money(100, -10):

The function first checks if amount <= 0. Since -10 is negative, it raises a ValueError. At this point, Python immediately stops normal execution and starts searching for a handler. It finds the try/except block right in the calling code, jumps to the except ValueError clause, and continues execution there.

The as e clause in except ValueError as e gives us access to the exception object itself. This object contains the error message we created (“Withdrawal amount must be positive”) and other details about what went wrong. This information helps us understand and handle the error appropriately.

This is useful when:

Input validation fails
A required resource is missing
Business rules are violated
You want to provide specific error messages

The caller can then decide how to handle these situations using try/except.

5.5.2 Separating Error Handling from Output

When writing functions, it’s best to:

Use return values for successful results
Use exceptions for error conditions
Avoid printing messages directly from functions

Here’s an example of poor error handling:

def divide(x, y):
    if y == 0:
        print("Error: Cannot divide by zero!")
        return None
    return x / y

This is better:

def divide(x, y):
    if y == 0:
        raise ValueError("Cannot divide by zero")
    return x / y

# Handle errors at the top level:
try:
    result = divide(10, 0)
    print(f"Result: {result}")
except ValueError as e:
    print(f"Error: {e}")

Why is this better?

Functions stay focused on their core task (computing values) rather than handling user interaction
The calling code can decide how to handle errors (print message, log error, retry, etc.)
Functions can be reused in different contexts (GUI, web service, notebook) without changing their error handling
Testing is easier because we can check if functions raise the right exceptions without worrying about printed output

This separation of concerns makes your code more flexible and maintainable.

5.6 Assertions

Sometimes functions have requirements that must be true before they can work correctly. These requirements are called preconditions. Assertions help us check these preconditions and fail fast if they’re not met.

Here’s an example:

def calculate_square_root(number):
    # Precondition: number must be non-negative
    assert number >= 0, f"Cannot calculate square root of negative number: {number}"
    return number ** 0.5

# This works fine
print(calculate_square_root(16.0))  # Prints: 4.0

# This raises an AssertionError
print(calculate_square_root(-16.0))  # AssertionError: Cannot calculate square root of negative number: -16.0

The assert statement checks if a condition is True. If it’s False, Python immediately raises an AssertionError with your message. This helps catch problems early, before they cause more confusing errors later.

Assertions are different from raising exceptions because:

They’re meant for programmer errors (impossible conditions), not user errors
They can be disabled in production code for better performance
They serve as documentation of your assumptions

Here’s another example checking multiple preconditions:

def create_user(username, age):
    assert isinstance(username, str), "Username must be a string"
    assert len(username) > 0, "Username cannot be empty"
    assert isinstance(age, int), "Age must be an integer"
    assert 0 <= age <= 150, "Age must be between 0 and 150"
    
    return {"username": username, "age": age}

The isinstance(object, classinfo) function checks if an object belongs to a particular type or category (like numbers, strings, or lists). When we create a number like 42 or a string like "hello", we’re creating an instance - a specific example - of that type. The function returns True if the object belongs to that type, and False otherwise. For example:

# Basic type checking
x = "hello"
print(isinstance(x, str))      # True: x is a string
print(isinstance(x, int))      # False: x is not an integer

# Multiple types can be checked at once
y = 42
print(isinstance(y, (int, float)))  # True: y is either an int or float

# Works with custom classes too
class Animal:
    pass

dog = Animal()
print(isinstance(dog, Animal))  # True: dog is an Animal instance

Type checking with isinstance() serves different purposes depending on whether you use it with assertions or exceptions. When used with assertions, it helps catch programming errors early in development - for example, asserting that a function meant to process strings isn’t accidentally called with numbers. These are issues that should never happen in correct code and indicate bugs that need fixing.

On the other hand, when used with exceptions, type checking helps handle situations that might legitimately occur during normal operation. For instance, if your function processes user input, you might use isinstance() in a try/except block to gracefully handle cases where the input isn’t the expected type and guide the user to provide correct input.

The key difference is that assertions should check for programmer errors (preconditions that must always be true in correct code), while exceptions should handle runtime situations that might reasonably occur. This makes isinstance() a versatile tool that fits both scenarios, helping you write more robust and maintainable code.

5.7 Conclusion

Functions are the building blocks of reusable code in Python. They help us organize code into logical units, avoid repetition, and make our programs easier to understand and maintain. Here’s what we’ve covered:

Functions are defined with def and can take parameters and return values
Parameters can have default values and can be passed by position or name
Functions create their own scope for variables, protecting them from conflicts
Multiple values can be returned using tuples
Exceptions help handle errors gracefully using try/except blocks
Assertions help catch programming errors early
Type checking helps ensure functions receive the correct kinds of data

Remember that good functions should:

Do one thing and do it well
Have clear names that describe what they do
Handle errors appropriately
Document their assumptions with assertions
Be neither too long nor too short

These principles will help you write code that’s easier to understand, test, and maintain.

# Functions Functions are reusable blocks of code that perform specific tasks. They help organize code, avoid repetition, and make programs more maintainable. In Python, functions are defined using the `def` keyword. ## Defining functions and using them Here's the basic syntax for defining and calling functions: ```python def greet(name): message = f"Hello, {name}!" return message # Calling the function result = greet("Alice") print(result) # Outputs: Hello, Alice! ``` Let's understand what happens step by step: 1. Function Definition: - `def` tells Python we're creating a new function - `greet` is the name we give our function - `name` in parentheses is a parameter - it's like a variable that will hold whatever value we pass to the function - The colon `:` marks the start of the function's body - Everything indented belongs to this function 2. Function Body: - Creates a message using the value stored in `name` - `return` sends this message back to wherever the function was called 3. Using the Function: - We call the function by writing its name followed by parentheses - We put "Alice" in the parentheses - this becomes the value of `name` - The function creates the message "Hello, Alice!" - The message is returned and stored in `result` - Finally, we print `result` to see the message Let's break down this example: - `def` is a special word that tells Python we're creating a new function - `greet` is the name we chose for our function - like variables, function names should be descriptive - The parentheses `()` after the name contain the parameters - in this case, `name` is a parameter - The colon `:` marks the start of the function's body - Everything indented under the `def` line is part of the function's body - `return` sends a value back to wherever the function was called from Python uses indentation (usually 4 spaces) to group lines of code together. Jupyter and code editors will insert indentation when you press that Tab key. All the lines indented under `def` belong to that function. This is different from many other programming languages that use braces `{}` or other symbols. When you call a function like `greet("Alice")`, here's what happens step by step: 1. Python evaluates the argument `"Alice"` (in this case it's just a simple string) 2. The parameter `name` is bound to the value `"Alice"` - think of this like creating a new variable `name = "Alice"` that only exists inside the function 3. The function body runs: - First it creates the message `"Hello, Alice!"` - Then it hits the `return` statement 4. The `return message` sends the string `"Hello, Alice!"` back to where we called the function 5. This returned value is stored in `result` The `return` statement is like a special exit door for your function - it both specifies what value to send back AND immediately ends the function's execution. For example: ```python def example(): print("First line") return "Done" print("This never runs!") # This line is never reached result = example() # Only prints "First line" print(result) # Prints "Done" ``` For example: ```python def double(x): return x * 2 a = 5 result = double(a + 3) # a + 3 is evaluated first (8), then passed to double() print(result) # Outputs: 16 ``` ## Multiple return values Python functions can return multiple values using tuples. The values are automatically packed into a tuple by the function and can be unpacked by the caller: ```python def get_coordinates(): x = 10 y = 20 return x, y # Automatically packed into a tuple # Method 1: Unpack into separate variables x_pos, y_pos = get_coordinates() print(x_pos) # Outputs: 10 print(y_pos) # Outputs: 20 # Method 2: Keep as tuple coords = get_coordinates() print(coords) # Outputs: (10, 20) ``` This is particularly useful when a function needs to return related values: ```python def analyze_numbers(numbers): minimum = min(numbers) maximum = max(numbers) average = sum(numbers) / len(numbers) return minimum, maximum, average # Unpack all values min_val, max_val, avg = analyze_numbers([1, 2, 3, 4, 5]) ``` ## Default arguments and keyword arguments Functions can have default values for parameters, making them optional when calling the function: ```python def greet(name, greeting="Hello"): return f"{greeting}, {name}!" print(greet("Bob")) # Uses default greeting: Hello, Bob! print(greet("Alice", "Hi")) # Override default: Hi, Alice! ``` You can also use keyword arguments to specify arguments by name, making the code more readable: ```python def create_profile(name, age, city="Unknown", hobby=None): return f"Name: {name}, Age: {age}, City: {city}, Hobby: {hobby}" # Using keyword arguments (order doesn't matter) profile = create_profile( age=25, name="Alice", hobby="Reading" ) ``` ⚠️ Warning: Be careful with mutable default arguments! They are created once when the function is defined, not each time it's called: ```python # BAD: List is mutable and shared between calls def add_item(item, lst=[]): # Don't do this! lst.append(item) return lst print(add_item("apple")) # Returns: ["apple"] print(add_item("banana")) # Returns: ["apple", "banana"] - Surprise! print(add_item("cherry")) # Returns: ["apple", "banana", "cherry"] - Oops! ``` What's happening here? The empty list `[]` is created only once when Python first reads the `def` statement, not each time the function runs. This means all calls to `add_item` are using the same list! It's like having a shared shopping cart that keeps accumulating items from different shoppers. The correct way is to use `None` as the default and create a new list when needed: ```python # GOOD: Use None as default and create list in function def add_item(item, lst=None): if lst is None: lst = [] # Creates a fresh list each time lst.append(item) return lst print(add_item("apple")) # Returns: ["apple"] print(add_item("banana")) # Returns: ["banana"] - Good! print(add_item("cherry")) # Returns: ["cherry"] - Perfect! ``` Now each call gets its own fresh list unless you specifically pass one in: ```python my_list = ["existing"] add_item("new", my_list) # Returns: ["existing", "new"] ``` ## Variable scoping Think of variable scope like different rooms in a house. Each room (scope) has its own set of items (variables), but there are rules about who can see and use which items. ### Local Variables - Your Private Room When you create a variable inside a function, it's like putting something in your private room. Only code inside that function can see or use it: ```python def make_greeting(): name = "Alice" # This is a local variable return f"Hello, {name}!" print(make_greeting()) # Works fine: "Hello, Alice!" print(name) # Error! We can't see 'name' out here ``` This is good! It means different functions can use the same variable names without confusion: ```python def greet_friend(): name = "Bob" # This is a different 'name' return f"Hi {name}!" def greet_teacher(): name = "Mrs. Smith" # This is yet another 'name' return f"Hello {name}!" # Each function has its own private 'name' variable print(greet_friend()) # "Hi Bob!" print(greet_teacher()) # "Hello Mrs. Smith!" ``` ### Global Variables - The Living Room Variables created outside of any function are called global variables. Think of them like items in the living room - everyone can see them: ```python message = "Welcome!" # A global variable def say_greeting(): print(message) # Functions can see global variables say_greeting() # Prints: "Welcome!" ``` However, there's a catch! While functions can see global variables, they need special permission to change them: ```python score = 0 # Global variable def add_point(): global score # Tell Python we want to change the global variable score = score + 1 add_point() print(score) # Prints: 1 ``` Without the `global` keyword, Python would create a new local variable instead of changing the global one. ### Nested Functions - Rooms within Rooms You can define functions inside other functions. The inner function can see variables from the outer function: ```python def make_counter(): count = 0 # Variable in outer function def increment(): nonlocal count # Tell Python we want to use outer function's variable count = count + 1 return count return increment # Create a counter counter = make_counter() print(counter()) # Prints: 1 print(counter()) # Prints: 2 ``` ### Best Practices 1. Try to avoid global variables when possible. They make it harder to understand where values are coming from. 2. Keep functions focused and self-contained. If a function needs data, pass it as parameters. 3. Use clear, descriptive names that won't conflict with other parts of your code. Here's a good example putting it all together: ```python def calculate_total(prices): """Calculate total price including 10% tax""" subtotal = sum(prices) # Local variable for sum tax_rate = 0.10 # Local variable for tax rate tax = subtotal * tax_rate total = subtotal + tax return total # Each call is completely independent print(calculate_total([10, 20])) # Prints: 33.0 print(calculate_total([5, 15])) # Prints: 22.0 ``` ## Exceptions Sometimes things go wrong when running our functions. Let's look at what happens when we try to convert text to a number: ```python def convert_to_number(text): number = int(text) return number # This works fine print(convert_to_number("123")) # Prints: 123 # But this crashes! print(convert_to_number("cat")) # ValueError: invalid literal for int() with base 10: 'cat' ``` When something goes wrong, Python raises an exception - a special object that describes the error. Without handling these exceptions, our program crashes! We can handle these errors gracefully using `try` and `except`: ```python def convert_to_number(text): try: number = int(text) return number except ValueError: print(f"Sorry, '{text}' is not a valid number") return None # Try it with different inputs print(convert_to_number("123")) # Works fine: 123 print(convert_to_number("cat")) # Handles error gracefully: None ``` Let's break this down: 1. The `try` block contains code that might raise an exception 2. If `int(text)` fails (like when text="cat"), it raises a ValueError 3. The `except` block catches that error and handles it nicely 4. Instead of crashing, our function returns None and explains the problem You can catch multiple types of exceptions: ```python def divide_numbers(x, y): try: result = x / y return result except ZeroDivisionError: print("Error: Cannot divide by zero!") return None except TypeError: print("Error: Both inputs must be numbers!") return None print(divide_numbers(10, 2)) # Works: 5.0 print(divide_numbers(10, 0)) # Handles division by zero print(divide_numbers(10, "two")) # Handles invalid input type ``` Sometimes we want to handle an exception but continue with the function's operation. Here's an example that retries reading user input until it's valid: ```python def get_age(): while True: try: age_text = input("Please enter your age: ") age = int(age_text) if age < 0 or age > 150: raise ValueError("Age must be between 0 and 150") return age except ValueError as e: print(f"Invalid input: {e}") print("Please try again...") # Instead of returning, we continue the loop # Usage: # age = get_age() # This will keep asking until valid input is received ``` This function: 1. Uses a loop to keep trying until successful 2. Catches ValueError but doesn't immediately return 3. Gives feedback and continues asking for input 4. Only returns once valid input is received This pattern is common when: - Reading files that might be temporarily locked - Making network requests that might timeout - Handling user input that needs validation ### Raising Exceptions Sometimes your function needs to tell the caller that something went wrong. You can do this by raising your own exceptions: ```python def withdraw_money(balance, amount): if amount <= 0: raise ValueError("Withdrawal amount must be positive") if amount > balance: raise ValueError("Insufficient funds") return balance - amount # Try using the function try: new_balance = withdraw_money(100, 50) print(f"New balance: ${new_balance}") # Works: New balance: $50 new_balance = withdraw_money(100, -10) # Raises: ValueError: Withdrawal amount must be positive except ValueError as e: print(f"Error: {e}") try: new_balance = withdraw_money(100, 150) # Raises: ValueError: Insufficient funds except ValueError as e: print(f"Error: {e}") ``` When an exception occurs in Python, execution immediately stops at that point and Python begins searching through the call stack for exception handlers. It starts at the current function and progressively moves outward through each calling function, looking for a try/except block that can handle the specific type of exception. For example, imagine we have a chain of function calls: outer() calls middle() which calls inner(). If inner() raises an exception, Python first checks if inner() itself has a try/except block to handle it. If not, Python immediately stops executing inner() and checks middle(). If middle() doesn't handle it either, Python moves to outer(). This continues until either: - A matching try/except block is found, which handles the exception - No handler is found, and the program crashes with an error message Here's what happens in detail when we call `withdraw_money(100, -10`): The function first checks if `amount <= 0`. Since -10 is negative, it raises a ValueError. At this point, Python immediately stops normal execution and starts searching for a handler. It finds the try/except block right in the calling code, jumps to the except ValueError clause, and continues execution there. The `as e` clause in `except ValueError as e` gives us access to the exception object itself. This object contains the error message we created ("Withdrawal amount must be positive") and other details about what went wrong. This information helps us understand and handle the error appropriately. This is useful when: 1. Input validation fails 2. A required resource is missing 3. Business rules are violated 4. You want to provide specific error messages The caller can then decide how to handle these situations using try/except. ### Separating Error Handling from Output When writing functions, it's best to: - Use return values for successful results - Use exceptions for error conditions - Avoid printing messages directly from functions Here's an example of poor error handling: ```python def divide(x, y): if y == 0: print("Error: Cannot divide by zero!") return None return x / y ``` This is better: ```python def divide(x, y): if y == 0: raise ValueError("Cannot divide by zero") return x / y # Handle errors at the top level: try: result = divide(10, 0) print(f"Result: {result}") except ValueError as e: print(f"Error: {e}") ``` Why is this better? 1. Functions stay focused on their core task (computing values) rather than handling user interaction 2. The calling code can decide how to handle errors (print message, log error, retry, etc.) 3. Functions can be reused in different contexts (GUI, web service, notebook) without changing their error handling 4. Testing is easier because we can check if functions raise the right exceptions without worrying about printed output This separation of concerns makes your code more flexible and maintainable. ## Assertions Sometimes functions have requirements that must be true before they can work correctly. These requirements are called preconditions. Assertions help us check these preconditions and fail fast if they're not met. Here's an example: ```python def calculate_square_root(number): # Precondition: number must be non-negative assert number >= 0, f"Cannot calculate square root of negative number: {number}" return number ** 0.5 # This works fine print(calculate_square_root(16.0)) # Prints: 4.0 # This raises an AssertionError print(calculate_square_root(-16.0)) # AssertionError: Cannot calculate square root of negative number: -16.0 ``` The `assert` statement checks if a condition is True. If it's False, Python immediately raises an AssertionError with your message. This helps catch problems early, before they cause more confusing errors later. Assertions are different from raising exceptions because: 1. They're meant for programmer errors (impossible conditions), not user errors 2. They can be disabled in production code for better performance 3. They serve as documentation of your assumptions Here's another example checking multiple preconditions: ```python def create_user(username, age): assert isinstance(username, str), "Username must be a string" assert len(username) > 0, "Username cannot be empty" assert isinstance(age, int), "Age must be an integer" assert 0 <= age <= 150, "Age must be between 0 and 150" return {"username": username, "age": age} ``` The `isinstance(object, classinfo)` function checks if an object belongs to a particular type or category (like numbers, strings, or lists). When we create a number like `42` or a string like `"hello"`, we're creating an instance - a specific example - of that type. The function returns `True` if the object belongs to that type, and `False` otherwise. For example: ```python # Basic type checking x = "hello" print(isinstance(x, str)) # True: x is a string print(isinstance(x, int)) # False: x is not an integer # Multiple types can be checked at once y = 42 print(isinstance(y, (int, float))) # True: y is either an int or float # Works with custom classes too class Animal: pass dog = Animal() print(isinstance(dog, Animal)) # True: dog is an Animal instance ``` Type checking with `isinstance()` serves different purposes depending on whether you use it with assertions or exceptions. When used with assertions, it helps catch programming errors early in development - for example, asserting that a function meant to process strings isn't accidentally called with numbers. These are issues that should never happen in correct code and indicate bugs that need fixing. On the other hand, when used with exceptions, type checking helps handle situations that might legitimately occur during normal operation. For instance, if your function processes user input, you might use isinstance() in a try/except block to gracefully handle cases where the input isn't the expected type and guide the user to provide correct input. The key difference is that assertions should check for programmer errors (preconditions that must always be true in correct code), while exceptions should handle runtime situations that might reasonably occur. This makes isinstance() a versatile tool that fits both scenarios, helping you write more robust and maintainable code. ## Conclusion Functions are the building blocks of reusable code in Python. They help us organize code into logical units, avoid repetition, and make our programs easier to understand and maintain. Here's what we've covered: - Functions are defined with `def` and can take parameters and return values - Parameters can have default values and can be passed by position or name - Functions create their own scope for variables, protecting them from conflicts - Multiple values can be returned using tuples - Exceptions help handle errors gracefully using try/except blocks - Assertions help catch programming errors early - Type checking helps ensure functions receive the correct kinds of data Remember that good functions should: - Do one thing and do it well - Have clear names that describe what they do - Handle errors appropriately - Document their assumptions with assertions - Be neither too long nor too short These principles will help you write code that's easier to understand, test, and maintain.