Using the "not" Boolean Operator in Python

if Statements

You can use the not operator in an if statement to check if a given condition is not met. To make an if statement test if something didn’t happen, you can put the not operator in front of the condition at hand. Since the not operator returns the negated result, something true becomes False and the other way around.

The syntax for an if statement with the not logical operator is:

if not condition:
    # Do something...

In this example, condition could be a Boolean expression or any Python object that makes sense. For example, condition can be a variable containing a string, a list, a dictionary, a set, and even a user-defined object.

If condition evaluates to false, then not returns True and the if code block runs. If condition evaluates to true, then not returns False and the if code block doesn’t execute.

A common situation is one where you use a predicate or Boolean-valued function as a condition. Say you want to check if a given number is prime before doing any further processing. In that case, you can write an is_prime() function:

>>> import math

>>> def is_prime(n):
...     if n <= 1:
...         return False
...     for i in range(2, int(math.sqrt(n)) + 1):
...         if n % i == 0:
...             return False
...     return True
...

>>> # Work with prime numbers only
>>> number = 3
>>> if is_prime(number):
...     print(f"{number} is prime")
...
3 is prime

In this example, is_prime() takes an integer number as an argument and returns True if the number is prime. Otherwise, it returns False.

You can also use this function in a negative conditional statement to approach those situations where you want to work with composite numbers only:

>>> # Work with composite numbers only
>>> number = 8
>>> if not is_prime(number):
...     print(f"{number} is composite")
...
8 is composite

Since it’s also possible that you need to work with composite numbers only, you can reuse is_prime() by combining it with the not operator as you did in this second example.

Another common situation in programming is to find out if a number is inside a specific numeric interval. To determine if a number x is in a given interval in Python, you can use the and operator or you can chain comparison operators appropriately:

>>> x = 30

>>> # Use the "and" operator
>>> if x >= 20 and x < 40:
...     print(f"{x} is inside")
...
30 is inside

>>> # Chain comparison operators
>>> if 20 <= x < 40:
...     print(f"{x} is inside")
...
30 is inside

In the first example, you use the and operator to create a compound Boolean expression that checks if x is between 20 and 40. The second example makes the same check but using chained operators, which is a best practice in Python.

You may also face the need to check if a number is outside of the target interval. To this end, you can use the or operator:

>>> x = 50

>>> if x < 20 or x >= 40:
...     print(f"{x} is outside")
...
50 is outside

This or expression allows you to check if x is outside the 20 to 40 interval. However, if you already have a working expression that successfully checks if a number is in a given interval, then you can reuse that expression to check the opposite condition:

>>> x = 50

>>> # Reuse the chained logic
>>> if not (20 <= x < 40):
...     print(f"{x} is outside")
50 is outside

In this example, you reuse the expression you originally coded to determine if a number is inside a target interval. With not before the expression, you check if x is outside the 20 to 40 interval.

while Loops

The second Boolean context in which you can use the not operator is in your while loops. These loops iterate while a given condition is met or until you jump out of the loop by using break, using return, or raising an exception. Using not in a while loop allows you to iterate while a given condition is not met.

Say you want to code a small Python game to guess a random number between 1 and 10. As a first step, you decide to use input() to capture the user’s name. Since the name is a requirement for the rest of the game to work, you need to make sure you get it. To do that, you can use a while loop that asks for the user’s name until the user provides a valid one.

Fire up your code editor or IDE and create a new guess.py file for your game. Then add the following code:

 1# guess.py
 2
 3from random import randint
 4
 5secret = randint(1, 10)
 6
 7print("Welcome!")
 8
 9name = ""
10while not name:
11    name = input("Enter your name: ").strip()

In guess.py, you first import randint() from random. This function allows you to generate random integer numbers in a given range. In this case, you’re generating numbers from 1 to 10, both included. Then you print a welcoming message to the user.

The while loop on line 10 iterates until the user provides a valid name. If the user provides no name by just pressing Enter, then input() returns an empty string ("") and the loop runs again because not "" returns True.

Now you can continue with your game by writing the code to provide the guessing functionality. You can do it by yourself, or you can expand the box below to check out a possible implementation.

while True:
    user_input = input("Guess a number between 1 and 10: ")
    if not user_input.isdigit():
        user_input = input("Please enter a valid number: ")
    guess = int(user_input)
    if guess == secret:
        print(f"Congrats {name}! You win!")
        break
    elif guess > secret:
        print("The secret number is lower than that...")
    else:
        print("The secret number is greater than that...")

How was your experience with this little game? To learn more about game programming in Python, check out PyGame: A Primer on Game Programming in Python.

Now that you know how to use not in Boolean contexts, it’s time to learn about using not in non-Boolean contexts. That’s what you’ll do in the following section.

Test for Membership

Membership tests are commonly useful when you’re determining if a particular object exists in a given container data type, such as a list, tuple, set, or dictionary. To perform this kind of test in Python, you can use the in operator:

>>> numbers = [1, 2, 3, 4]

>>> 3 in numbers
True

>>> 5 in numbers
False

The in operator returns True if the left-side object is in the container on the right side of the expression. Otherwise, it returns False.

Sometimes you may need to check if an object is not in a given container. How can you do that? The answer to this question is the not operator.

There are two different syntaxes to check if an object is not in a given container in Python. The Python community considers the first syntax as bad practice because it’s difficult to read. The second syntax reads like plain English:

>>> # Bad practice
>>> not "c" in ["a", "b", "c"]
False

>>> # Best practice
>>> "c" not in ["a", "b", "c"]
False

The first example works. However, the leading not makes it difficult for someone reading your code to determine if the operator is working on "c" or on the whole expression, "c" in ["a", "b", "c"]. This detail makes the expression difficult to read and understand.

The second example is much clearer. The Python documentation refers to the syntax in the second example as the not in operator. The first syntax can be a common practice for people who are starting out with Python.

Now it’s time to revisit the examples where you checked if a number was inside or outside a numeric interval. If you’re working with integer numbers only, then the not in operator provides a more readable way to perform this check:

>>> x = 30

>>> # Between 20 and 40
>>> x in range(20, 41)
True

>>> # Outside 20 and 40
>>> x not in range(20, 41)
False

The first example checks if x is inside the 20 to 40 range or interval. Note that you use 41 as the second argument to range() to include 40 in the check.

When you’re working with integer numbers, this small trick about where exactly you use the not operator can make a big difference regarding code readability.

Check the Identity of Objects

Another common requirement when you’re coding in Python is to check for an object’s identity. You can determine an object’s identity using id(). This built-in function takes an object as an argument and returns an integer number that uniquely identifies the object at hand. This number represents the object’s identity.

The practical way to check for identity is to use the is operator, which is pretty useful in some conditional statements. For example, one of the most common use cases of the is operator is to test if a given object is None:

>>> obj = None
>>> obj is None
True

The is operator returns True when the left operand has the same identity as the right operand. Otherwise, it returns False.

In this case, the question is: how do you check if two objects don’t have the same identity? Again, you can use two different syntaxes:

>>> obj = None

>>> # Bad practice
>>> not obj is None
False

>>> # Best practice
>>> obj is not None
False

In both examples, you check if obj has the same identity as the None object. The first syntax is somewhat difficult to read and non-Pythonic. The is not syntax is way more explicit and clear. The Python documentation refers to this syntax as the is not operator and promotes its use as a best practice.

Avoid Unnecessary Negative Logic

The not operator enables you to reverse the meaning or logic of a given condition or object. In programming, this kind of feature is known as negative logic or negation.

Using negative logic correctly can be tricky because this logic is difficult to think about and understand, not to mention hard to explain. In general, negative logic implies a higher cognitive load than positive logic. So, whenever possible, you should use positive formulations.

Here is an example of a custom_abs() function that uses a negative condition to return the absolute value of an input number:

>>> def custom_abs(number):
...     if not number < 0:
...         return number
...     return -number
...

>>> custom_abs(42)
42

>>> custom_abs(-42)
42

This function takes a number as an argument and returns its absolute value. You can achieve the same result by using positive logic with a minimal change:

>>> def custom_abs(number):
...     if number < 0:
...         return -number
...     return number
...

>>> custom_abs(42)
42

>>> custom_abs(-42)
42

That’s it! Your custom_abs() now uses positive logic. It’s more straightforward and understandable. To get this result, you removed not and moved the negative sign (-) to modify the input number when it’s lower than 0.

You can find many similar examples in which changing a comparison operator can remove unnecessary negative logic. Say you want to check if a variable x is not equal to a given value. You can use two different approaches:

>>> x = 27

>>> # Use negative logic
>>> if not x == 42:
...     print("not 42")
...
not 42

>>> # Use positive logic
>>> if x != 42:
...     print("not 42")
...
not 42

In this example, you remove the not operator by changing the comparison operator from equal (==) to different (!=). In many cases, you can avoid negative logic by expressing the condition differently with an appropriate relational or equality operator.

However, sometimes negative logic can save you time and make your code more concise. Suppose you need a conditional statement to initialize a given file when it doesn’t exist in the file system. In that case, you can use not to check if the file doesn’t exist:

from pathlib import Path

file = Path("/some/path/config.ini")

if not file.exists():
    # Initialize the file here...

The not operator allows you to invert the result of calling .exists() on file. If .exists() returns False, then you need to initialize the file. However, with a false condition, the if code block doesn’t run. That’s why you need the not operator to invert the result of .exists().

Now think of how to turn this negative conditional into a positive one. Up to this point, you don’t have any action to perform if the file exists, so you may think of using a pass statement and an additional else clause to handle the file initialization:

if file.exists():
    pass # YAGNI
else:
    # Initialize the file here...

Even though this code works, it violates the “You aren’t gonna need it” (YAGNI) principle. It’s an especially determined attempt to remove negative logic.

The idea behind this example is to show that sometimes using negative logic is the right way to go. So, you should consider your specific problem and select the appropriate solution. A good rule of thumb would be to avoid negative logic as much as possible without trying to avoid it at all costs.

Finally, you should pay special attention to avoiding double negation. Say you have a constant called NON_NUMERIC that holds characters that Python can’t turn into numbers, such as letters and punctuation marks. Semantically, this constant itself implies a negation.

Now say you need to check if a given character is a numeric value. Since you already have NON_NUMERIC, you can think of using not to check the condition:

if char not in NON_NUMERIC:
    number = float(char)
    # Do further computations...

This code looks odd, and you probably won’t ever do something like this in your career as a programmer. However, doing something similar can sometimes be tempting, such as in the example above.

This example uses double negation. It relies on NON_NUMERIC and also on not, which makes it hard to digest and understand. If you ever get to a piece of code like this, then take a minute to try writing it positively or, at least, try to remove one layer of negation.