Python Assert: How to Use Python Assert for Debugging Code

The Python ASSERT statement is easy to learn, but it’s also easy to misuse. ASSERT exists in virtually every programming language, primarily as a debugging tool. ASSERT is particularly useful in the Python language because it helps you identify problems, such as exceptions, in advance. Since Python is not a compiled language, it is an interpreted language. This is critically important to avoid runtime errors.

Let’s take a deeper look at what ASSERT is, how to use it, and when it becomes beneficial. 

What is Python ASSERT?

Python ASSERT is a basic Python command. ASSERT checks a given condition and determines whether that condition is true. If the conditions return true, it does nothing. If it doesn’t return true, it will raise the assert condition message: a specific error message to do with the ASSERT command.

The easiest way to understand Python ASSERT is to look at an example:

	assert false, "Error Message: Assertion failed."
	print("This line will never be reached.")

In the above ASSERT expression, we begin the ASSERT command, but what we ASSERT is just “false.” Then, the ASSERT condition message is “Error Message: Assertion failed” because the assertion fails.

Note that this is an optional message. We could also just do:

	assert false
	print("This line will never be reached.")

The ASSERT command itself relies on a Boolean expression. So either the condition is true, and it prints a statement (which will never happen in our example, because false will never be true), or it’s false and raises an AssertionError. Similarly, we could have written:

	assert a<b, "Error Message: A is not less than B."

If the condition evaluates to false, then you get that error message. If the condition evaluates to true, the condition returns without comment. 

But what if we wanted it to evaluate with a comment?

assert a<b, "Error Message: A is not less than B."
	print("A is less than B!")

Now, the results are absolutely going to depend on what we have set the “a” and “b” variables to, which is why it’s so incredible as a debugging tool.

The Python ASSERT statement as a debugging tool

As you can see, the primary use of the ASSERT keyword is that it’s a debugging tool. If you wanted to know, for instance, if a particular variable is set, you would ASSERT whether the variable was set. If it returns true, you can do one thing; otherwise, you can do another.

In our code snippets, we can quite easily see how the ASSERT keyword will resolve. But in a very long sequence of code, we might not be able to see what a variable is. We may need to track it back.

So, ASSERT makes it much easier to determine the current state of a program. But it’s generally an impractical thing to do in live code. In live code, you would be more likely to use an IF/THEN statement.

The way debugging tools generally work is that you enter in your command, and then you either comment it out later or you disable it in some way. With ASSERT, you would use the ASSERT command to test certain debug conditions throughout the code project.

But when it came time to push the code project live, you would want to remove these ASSERT lines.

Note also that ASSERT is used to test for conditions that should never happen. The purpose of ASSERT is to test for conditions that would cause your program to crash. The assertion value itself should always be true. 

For instance, if you’re looking into how to read and write CSV files in Python, you’d want to ensure that the CSV file always exists before reading from it.

Thus, you don’t want to use ASSERT to control the flow of your program. You should never use ASSERT in a way that would break your program should ASSERT be turned off.

ASSERT vs IF statements: which should you use?

You may have realized that there’s nothing you can do with an ASSERT statement that you couldn’t do with an IF statement. Take a look at this code:

assert a<b
	print("A is less than B!")

That code is the same as:

if a<b:
	print("A is less than B!")

And yes, it’s true that you could use that code. But the difference between using ASSERT and using an IF statement is that you can turn off ASSERT statements when you’re no longer debugging your program.

You can’t do that with an IF statement!

How to disable Python ASSERT

You can easily disable Python’s ASSERT command by using #define NDEBUG, which stands for “no debug.” This means that these debug tools will not be included. Using NDEBUG is an easy way to toggle ASSERT commands on and off, thereby making it easier to debug your product without going through and commenting out ASSERT commands.

For developers, ASSERT digs into some of the basic foundations of debugging. No one programs perfectly the first time. Most people are going to have to debug their systems regularly. To debug your programs, you need to identify the program’s status, something that isn’t always visible.

ASSERT is a visibility tool, as it lets you peer into the program’s inner workings. But it’s not a good practice to do anything else with ASSERT. 

Moving forward with Python ASSERT

Python’s ASSERT is one of the first steps toward debugging Python code. Python is an easy system to learn, but it also has a lot of potential stumbling blocks because it’s so easy to learn. It’s relatively easy to accidentally write code that causes a runtime error because Python is incredibly flexible. Consider going through a few Python programming examples and asking yourself where you would put an ASSERT.

The more debugging you do on your Python code, the less likely you will run into errors when you run your code. Because Python is an interpreted language rather than a compiled error, you won’t necessarily catch all errors upon compiling. Runtime errors can crop up when a user utilizes the program instead.
To brush up on your Python skills, you can continue to look into debugging courses or basic Python classes. One of the best ways to learn Python is through an interesting Python programming project.