Logical Operators

Recall that an operator carries out an action on one or more operands (values). Math operators (+, -, *, /, //, **, %) perform calculations. Boolean operators (like the comparisons == and <) return a value of either True or False.

1
2
3
4
5
6

name = input('Please enter a username: ')

if len(name) > 5:
   print("Welcome, " + name + "!")
else:
   print("Invalid username.")

What if we wanted to set another limit to the length of name? We could replace line 3 with if len(name) < 10, but then we would lose the first comparison. Fortunately, we can perform both checks at the same time.

Three boolean operators allow us to make more complicated comparisons in a single if statement. These are called logical operators, and there are only three—and, or, and not.

Logical and

Let’s take the two boolean expressions from above:

1. len(name) > 5 returns True when name contains more than 5 characters.
2. len(name) < 10 returns True when name contains less than 10 characters.

A compound boolean expression is a boolean expression built out of smaller ones. Python allows us to combine expressions by using the and operator.

len(name) > 5 and len(name) < 10

A compound expression returns only one boolean value, which depends on the results from both of the smaller comparisons. len(name) > 5 and len(name) < 10 is true only if len(name) is greater than 5 AND, at the same time, len(name) is less than 10.

1. Logical and combines two conditions.
2. The combined expression is True only if both conditions return True.
3. If either condition is False, the overall expression is False.

Let’s look at an example.

1
2
3
4
5
6

num = 5
print(num > 0 and num < 10)

print(7 > num and num == 3)

print(num*5 > 100 and 'dog' == 'cat')

True
False
False

In line 2, num > 0 and num < 10 evaluates to True because both num > 0 and num < 10 are each True.

In line 4, the expression 7 > num and num == 3 evaluates to False because one of the two comparisons, num == 3, is False.

Line 6 evaluates to False because both comparisons return False. Notice that we can mix and match data types however we like, as long as both sides of the and expression are themselves boolean expressions.

Logical or

Python’s logical or also combines two boolean expressions. In this case, however, the resulting expression is True if either of the conditions are True. If both conditions are False, the overall expression is False.

For the compound expression num - 2 == 0 or num - 3 == 0, only one part has to be true for the overall result to be True.

Let’s look at another code example. Change the value of num to see when each combined expression returns True.

1
2
3
4
5

num = 5

print(num > 0 or num < 10)
print(7 > num or num == 3)
print(num*5 > 100 or 'dog' == 'cat')

Using num = 5, lines 3 and 4 both return True because at least one of the two comparisons is True. Line 5 returns False because both of the comparisons are False.

Logical not

The logical not operator takes a single operand and flips its boolean value. If a comparison returns False, then applying not changes the result to True (and vice versa).

1
2
3
4
5
6
7
8

print(not True)
print(not False)

num = 5

print( not(num < 7) )
print( not('dog' == 'cat') )
print( not(num*5 > 100 or 'dog' == 'cat') )

False
True
False
True
True

Longer Combinations

In the examples above, we used the and and or operators to combine two smaller boolean expressions. However, we can use these operators to combine as many expressions as we want!

1
2
3
4
5

num = 5
python = 'Awesome!'

print(num > 0 and num < 10 and 'dog' == 'cat')
print(num > 7 or num == 3 or 'dog' == 'cat' or python == 'Awesome!')

Console Output

False
True

Check Your Understanding

4 < 3 or 2 < 3