Python - Assertions

Hello, aspiring programmers! Today, we're going to dive into the world of Python assertions. As your friendly neighborhood computer teacher, I'm excited to guide you through this fascinating topic. Let's embark on this journey together!

Assertions in Python

Imagine you're building a treehouse. You wouldn't start nailing boards together without first making sure your foundation is solid, right? That's exactly what assertions do in programming. They help us check if certain conditions are true before we proceed with our code.

In Python, assertions are a way to say, "I believe this condition is true, and if it's not, something has gone terribly wrong!" They're like little checkpoints in your code that ensure everything is as it should be.

The assert Statement

The basic syntax of an assertion in Python is quite simple:

assert condition, message

Here, condition is the thing we're checking, and message is an optional explanation that appears if the assertion fails.

Let's look at a simple example:

x = 5
assert x == 5, "x should be 5"
print("Code continues...")

In this case, the assertion passes silently because x is indeed 5, and our code continues to run. But what if we change the value of x?

x = 10
assert x == 5, "x should be 5"
print("This line will never be reached!")

Oops! This would raise an AssertionError with our custom message, "x should be 5".

Using Assertions

Assertions are incredibly useful in various scenarios. Let's explore a few:

1. Checking function inputs

def calculate_rectangle_area(length, width):
    assert length > 0 and width > 0, "Length and width must be positive"
    return length * width

# This will work
print(calculate_rectangle_area(5, 3))

# This will raise an AssertionError
print(calculate_rectangle_area(-1, 3))

Here, we're making sure that someone doesn't try to calculate the area of a rectangle with negative or zero dimensions. That would be quite a peculiar rectangle, wouldn't it?

2. Verifying internal state

class BankAccount:
    def __init__(self, initial_balance):
        self.balance = initial_balance
        assert self.balance >= 0, "Initial balance cannot be negative"

    def withdraw(self, amount):
        assert amount > 0, "Withdrawal amount must be positive"
        assert self.balance >= amount, "Insufficient funds"
        self.balance -= amount

account = BankAccount(100)
account.withdraw(50)  # This works
account.withdraw(60)  # This raises an AssertionError

In this example, we're using assertions to ensure that our bank account behaves correctly. We can't start with a negative balance or withdraw more money than we have. If only real banks were this strict!

Custom Error Messages

As we've seen, we can add custom error messages to our assertions. These messages can be incredibly helpful when debugging:

def divide(a, b):
    assert b != 0, f"Cannot divide {a} by zero"
    return a / b

print(divide(10, 2))  # This works
print(divide(10, 0))  # This raises an AssertionError with our custom message

Handling AssertionError

Sometimes, we might want to catch and handle AssertionErrors rather than letting them crash our program. We can do this using a try-except block:

def risky_function(x):
    assert x > 0, "x must be positive"
    return 1 / x

try:
    result = risky_function(-5)
except AssertionError as e:
    print(f"An assertion failed: {e}")
    result = None

print(f"The result is: {result}")

This allows our program to continue running even if an assertion fails, which can be useful in certain situations.

Assertions vs. Exceptions

You might be wondering, "Why use assertions when we have exceptions?" Great question! Let's break down the key differences:

Assertions	Exceptions
Used to check for programmer errors	Used to handle runtime errors
Should be used for conditions that should never occur	Used for expected error conditions
Can be disabled globally	Always active
Primarily a debugging aid	Part of error handling strategy

Assertions are like the safety checks we do before a roller coaster ride starts. Exceptions are more like the safety harness that catches us if something goes wrong during the ride.

In conclusion, assertions are a powerful tool in a Python programmer's toolkit. They help us write more robust and reliable code by catching potential issues early. Remember, it's always better to fail fast and fail loudly when something unexpected happens in your code.

As you continue your Python journey, keep assertions in mind. They're like faithful guardians, watching over your code and ensuring everything is as it should be. Happy coding, future Pythonistas!

Credits: Image by storyset