Skip to content

How to Fix Assertion Error


Python’s assert statement is a powerful tool that allows you to write sanity checks in your code. These sanity checks, known as assertions, help you test if certain assumptions remain true during the development process. If any of the assertions turn out to be false, it indicates a bug in your code.

Assertions serve various purposes such as documenting, debugging, and testing code. They help ensure that your code is efficient, robust, and reliable. In this tutorial, we will explore the different aspects of assertions in Python, including their syntax, common assertion formats, and best practices for using them effectively.

Getting to Know Assertions in Python

What Are Assertions?

Assertions are statements that express the developer’s confidence in the correctness of a particular condition. These conditions are usually expectations that should hold true at specific points in your code. If an assertion fails, it raises an AssertionError, indicating that the condition is not met.

What Are Assertions Good For?

Assertions play a crucial role in software development by helping you:

  • Check the correctness of your code during development.
  • Verify the validity of assumptions made by the code.
  • Identify and debug errors or unexpected behavior.
  • Improve the reliability and maintainability of your code.

When Not to Use Assertions?

While assertions are beneficial during development, it’s essential to consider the following scenarios where their use might not be appropriate:

  • In production code: It’s recommended to disable assertions in production as they can impact performance.
  • In situations where security is a concern: Assertions can potentially reveal sensitive information about the code.
  • In scenarios where you need flexibility: When you want to test different conditions dynamically, assertions might not be the ideal solution.

Understanding Python’s assert Statements

The assert statement in Python is used to evaluate and assert the truthfulness of an expression. It takes the following syntax:

assert condition, message
  • The condition can be any expression that evaluates to either True or False.
  • The message is an optional argument used to provide additional information about the failed assertion.

When the condition in the assert statement evaluates to False, an AssertionError exception is raised. The message, if specified, is included in the exception’s error message.

The AssertionError Exception

The AssertionError is a built-in exception that is raised when an assert statement fails. It contains information about the location in the code where the error occurred and the specific condition that failed.

Exploring Common Assertion Formats

Assertions can take different formats depending on the complexity of the condition being evaluated. Some common formats include:

  • Simple assertions: These are basic assertions that check the truthfulness of a single condition.
assert condition
  • Assertions with custom error messages: You can provide a custom error message to be displayed when the assertion fails.
assert condition, "Custom error message"
  • Assertions with complex expressions: You can use complex expressions involving logical operators (e.g., AND, OR, NOT) to evaluate multiple conditions.
assert condition1 and condition2 or condition3, "Complex expression"

Documenting Your Code With Assertions

Assertions can serve as a form of documentation in your code by expressing assumptions about the expected state of variables or the behavior of functions. When assertions are strategically placed throughout the code, they provide valuable guidance to other developers and help maintain code integrity.

It’s important to write clear and concise assertions that describe the specific conditions being checked. Additionally, using informative error messages can provide context and help others understand the intention of the assertion.

Debugging Your Code With Assertions

Assertions are an invaluable tool for debugging your code. By placing assertions at critical points in your program, you can verify the correctness of data, identify logic errors, and quickly narrow down the source of a bug.

An Example of Debugging With Assertions

Consider the following example where you want to ensure that a list of numbers is always sorted in ascending order. You can use assertions to validate this assumption:

def sort_numbers(numbers):
assert sorted(numbers) == numbers, "List is not sorted"
# Rest of the code for sorting the numbers

If, during testing or debugging, the assertion fails, it immediately alerts you to a bug in the code. The error message provides valuable information about the specific issue, allowing you to quickly fix the problem.

A Few Considerations on Debugging With Assertions

When using assertions for debugging purposes, keep the following considerations in mind:

  • Assertions should be used to test conditions that you believe should always hold true. They are not meant to handle unexpected or exceptional cases.
  • Assertions can help you catch and fix bugs early in the development process, reducing the amount of time spent debugging.
  • However, be cautious not to rely solely on assertions for error handling. Assertions should not replace proper exception handling techniques.

Disabling Assertions in Production for Performance

While assertions are beneficial during the development and testing stages, they can impact the performance of your code in a production environment. Therefore, it’s essential to disable assertions when your code is deployed for production.

Python provides several ways to disable assertions:

Understanding the debug Built-in Constant

In Python, the __debug__ built-in constant is set to True by default. However, it is automatically set to False when running Python in optimized mode or when using the -O or -OO command-line options.

This constant allows you to conditionally execute code based on whether assertions are enabled or disabled.

Running Python With the -O or -OO Options

Running Python with the -O or -OO options enables optimization by suppressing assertions and docstrings.

The -O option removes assert statements and -OO removes both assert statements and docstrings. These options can significantly improve the performance of your code when assertions are not needed.

Setting the PYTHONOPTIMIZE Environment Variable

The PYTHONOPTIMIZE environment variable is another way to control the optimization level of your Python code. By setting PYTHONOPTIMIZE to a non-empty string, you can disable assertions and achieve the same effect as running Python with the -O or -OO options.

Running Python in Optimized Mode

By running Python in optimized mode, you can globally disable assertions for all code modules.

To run Python in optimized mode, use the -O command-line option:

Terminal window
python -O

Remember to exercise caution when disabling assertions in production. Although they improve performance, assertions are an invaluable tool during development and testing phases.

Testing Your Code With Assertions

Assertions are an effective means of testing your code during development. By using assertions, you can verify that the input, output, or intermediate states of your code match your expectations.

Here’s an example of testing a simple function that squares a number:

def square(number):
assert isinstance(number, (int, float)), "Number must be numeric"
return number ** 2
# Testing the square function
assert square(5) == 25
assert square(-3) == 9
assert square(2.5) == 6.25

In this example, the assertions check if the input to the square function is numeric. If the condition fails, it indicates invalid input, and an error is raised. These assertions serve as embedded tests and help ensure the correctness of the function.

Understanding Common Pitfalls of assert

While assertions are a powerful tool, there are some common pitfalls you should be aware of:

Using assert for Data Processing and Validation

Assertions are primarily intended for debugging and testing purposes. It is generally not recommended to use assertions for regular data processing or validation. Instead, consider using proper data validation techniques and custom exception handling for these scenarios.

Handling Errors With assert

Assertions should not be used to handle errors. They are meant to detect and report programming errors during development, not to handle runtime errors. Use exception handling mechanisms to handle expected errors and exceptions in your code.

Running assert on Expressions With Side Effects

Since assertions are not meant to handle side effects, it’s essential to avoid running them on expressions that have unintended consequences. For example, avoid assertions that modify or interact with data or modules in ways that could lead to unexpected behavior.

Impacting Performance With assert

Assertions can impact the performance of your code, especially when they involve complex calculations or expensive operations. When running assertions in a performance-critical section of your code, consider disabling them to improve runtime performance.

Having assert Statements Enabled by Default

When working on a project with multiple developers, it’s important to consider whether assert statements are enabled by default or require explicit opt-in. Some developers may have a preference for the way assert statements are used and may want to disable them by default to avoid performance issues.


Assertions are a powerful tool in Python that can be used for documenting, debugging, and testing code during development. They help you ensure the correctness of your code by expressing assumptions and checking conditions.

By strategically placing assertions throughout your code, you can catch bugs early, identify logic errors, and improve code reliability. However, it’s essential to disable assertions in production to optimize performance.

When using assertions, be mindful of their limitations and potential pitfalls. Use them to test conditions that should always hold true, avoid using them for data processing or error handling, and consider their impact on performance.

By leveraging the power of assertions effectively, you can enhance the quality of your code and streamline the development process.