Python Assertions Tutorial – Complete Guide

Python boasts a powerful tool for making your code more robust and bug-free – assertions. Harnessing Python’s assertion capabilities can help you catch and handle potential errors before they morph into full-blown bugs. With assertions in Python, you can troubleshoot better, improve code readability, and maintain code quality, all while building more efficient and bug-proof programs.

What is an Assertion in Python?

An assertion in Python is a debugging tool which allows a program to check if a given logical expression is true or false. If it’s true, the program will continue to execute. However, if it’s false, the program will halt and produce an AssertionError.

What are Assertions used for in Python?

Assertions are primarily used for debugging purposes. They can help you identify issues in the initial stages of your code’s development, saving you from problematic bugs down the line. By effectively using Python assertions, you can:

  • Check whether the inputs to a function are as expected
  • Monitor the output of a function to prevent unexpected results
  • Test code in various scenarios and conditions

Why Should You Learn Python Assertions?

Integrating assertions into your code holds various benefits that can significantly improve your overall coding experience and the quality of your programs. Here are a few reasons why learning Python assertions is worth your time:

Easier debugging: Assertions can help identify and fix bugs in the code during the early stages of development, making the debugging process less daunting.

Improved code readability: Well-placed assertions make your code more understandable. They can also work as documentation, outlining what a function does and what inputs it expects.

Better code quality: Assertions foster the building of higher-quality, reliable code that’s less prone to bugs and issues.

Nonetheless, it’s important to note that assertions shouldn’t be used to handle exceptions in Python. They are meant as debugging aids, and their use is usually restricted to development and testing environments.

CTA Small Image

Understanding Python Assertions with Examples

Now that we’ve covered what an assertion is and why it’s useful in Python, let’s dive into some practical examples. We will start with the basic assertion command and gradually build up to more complex usage.

Basic Assertion

# Defining a simple function 
def add_numbers(a, b):
    assert type(a) == int and type(b) == int, "Both arguments must be integers"
    return a + b

# Testing our function
print(add_numbers(1, 2)) # prints 3
print(add_numbers('1', '2')) # raises an AssertionError

In this example, the assertion statement checks if both inputs to the function are integers. If either input is not an integer, the program raises an AssertionError with the specified error message.

Asserting Within a Loop

# Let's define our function
def check_even(numbers):
    for i, num in enumerate(numbers):
        assert num % 2 == 0, f"Found an odd number at index {i}"
    return "All numbers are even!"

# Testing our function
print(check_even([2, 4, 6, 8])) # prints "All numbers are even!"
print(check_even([2, 3, 6, 8])) # raises an AssertionError

In the above example, the assertion placed within the loop checks every number in the list to see if it’s even. If the assertion encounters an odd number, it raises an AssertionError outlining the index of the odd number in the errors message.

We hope that these examples have given you a good understanding of how Python assertions work. In the next section, we’ll dig deeper into some more complex situations where you might need to use assertions.

Advanced Python Assertions

Negative Testing using Assertions

# Simple negative testing
def calculate_reward(points):
    assert points >= 0, "Points can't be negative"
    return points * 10

# Testing our function
print(calculate_reward(5)) # prints 50
print(calculate_reward(-5)) # raises an AssertionError

The assertion in this function checks the input for negative values. If the input is negative, the program manufactures an AssertionError.

Asserting Function Output

# Checks the output of a function
def add_and_check(a, b):
    sum = a + b
    assert sum == a + b, "Addition failed"
    return sum

# Testing our function
print(add_and_check(3, 7)) # prints 10
print(add_and_check(3, '7')) # raises an AssertionError

This function asserts if the sum of two integers equals the expected output. If the addition operation fails for any reason, possibly due to one of the inputs being a non-integer, the program raises an AssertionError.

Through these examples, we aim to have given you a better perspective on how to assert your programs and enhance your Python development process. Remember, assertions are a great debugging tool, making your coding life easier.Absolutely! Let’s look into some additional ways we can leverage assertions in Python with more examples.

Further Assertion Use Cases

Asserting a Condition

# Checking a specific condition
def check_number(num):
    assert num != 0, "Number can't be 0"
    return num

# Testing our function
print(check_number(5)) # prints 5
print(check_number(0)) # raises an AssertionError

In this code snippet, the assertion checks that the input is not zero. If the input is zero, it raises an AssertionError.

Asserting Multiple Conditions

Here’s an example of checking multiple conditions in a single assertion:

# Checking multiple conditions simultaneously
def validate_password(password):
    assert len(password) >= 8 and any(char.isdigit() for char in password), "Password must be at least 8 characters long and contain a number"
    return "Password is valid"

# Testing our function
print(validate_password('mypass123')) # prints "Password is valid"
print(validate_password('password')) # raises an AssertionError

This function asserts that the password is at least 8 characters long and contains at least one digit. If either condition fails, it raises an AssertionError.

Asserting a Data Type

# Checking if an argument is of a specific data type
def check_type(var):
    assert isinstance(var, int), f"Expected int, got {type(var).__name__}"
    return "Correct type!"

# Testing our function
print(check_type(5)) # prints "Correct type!"
print(check_type('Hello')) # raises an AssertionError

This assertion checks the data type of the input. If the input is not an integer, the program triggers an AssertionError.

Asserting a Return Value

# Checking the return value of a function
def return_test(a, b):
    result = a * b
    assert result > 10, "Product is not greater than 10"
    return result

# Testing our function
print(return_test(5, 3)) # prints 15
print(return_test(2, 3)) # raises an AssertionError

Here, the assertion is checking the result of a multiplication operation. If the result is not greater than 10, the assertion triggers an AssertionError.

Understanding the flexibility and utility of Python assertions can significantly enhance your programs’ reliability and efficiency. Despite their apparent simplicity, leveraging them effectively can make your coding journey far smoother.

Where to go Next – Continuing Your Python Journey

Congratulations on getting this far in your Python programming journey! Understanding and effectively utilizing assertions is an important step towards becoming a proficient Python developer. So what’s next on this journey? We strongly believe that the best path forward from here involves a combination of continued learning and hands-on practical experience.

To further your Python learning journey, checkout our Python Mini-Degree. This comprehensive collection of courses teach Python programming in depth, covering various topics from coding basics and algorithms to object-oriented programming and even game and app development. Our mini-degree courses revolve around hands-on projects, ensuring that you’ll learn by creating real-world applications, games, and apps. Not only does this enhance your understanding and retention of key concepts, but also, it allows you to build a compelling portfolio of projects.

Python is in high demand in the job market, particularly in the field of data science. Our flexible courses are fully accessible across all devices and can be taken at your own pace. Our experienced instructors, certified by Unity Technologies and CompTIA, provide informative and engaging content to enhance your learning experience. Moreover, our courses are frequently updated to reflect industry trends and advances.

Even if you’re a beginner with no coding experience, our Python Mini-Degree can equip you with the necessary skills to thrive in the world of programming. Many of our students have found success, landing jobs, publishing games, and even launching their own businesses using the skills they’ve learned on Zenva.

Alternatively, for a broader selection, you can explore our collection of Python courses.


Assertions are undoubtedly a powerful tool in Python, providing an effective way to debug and improve your code quality. By integrating Python assertions, you gain the upper hand in producing bug-free, efficient, and reliable code while enhancing your programming fluency. Boost your coding journey by mastering this invaluable skill and watch your Python programs become more reliable and efficient.

At Zenva, we are committed to fostering a learning ecosystem that nurtures your coding skills and helps you thrive in the tech industry. Our Python Mini-Degree is a comprehensive and hands-on introduction to Python that is sure to equip you with the skills you need to excel. Join us and countless other learners and step into the exciting world of programming with Python. Dive deeper into the universes of data science, game development, and more for an enriching learning experience. The road to mastering Python is indeed a journey worth embarking on. Happy coding!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.