Python and, or, not: Logical Operators, Short-Circuiting, and Truthiness

Three Words Instead of Symbols

Python's logical operators are the English words and, or and not. Other languages spell them &&, || and !. In Python && and || are a SyntaxError, and ! only appears as part of != ("not equal").

has_ticket = True
is_adult = False

print(has_ticket and is_adult)   # False: both must be true
print(has_ticket or is_adult)    # True: at least one is true
print(not is_adult)              # True: flips the value

With True and False the rules are the ones you expect:

and needs both sides to be true. or needs at least one. not takes a single value and inverts it.

In real code the sides are usually comparisons, and the result feeds an if or a while:

age = 34
country = "CA"

if age >= 18 and country in ("US", "CA"):
    print("eligible")

if age < 13 or age > 65:
    print("discounted ticket")
else:
    print("standard ticket")

Output:

eligible
standard ticket

That much is enough for most conditions. The rest of this page covers what the operators do with values that are not True or False, and the rules that decide which side of an expression runs.

Truthy and Falsy Values

and, or and not accept any value, not only booleans. Python decides whether a value counts as true by its truthiness. These values are falsy:

• False and None
• zero of any number type: 0, 0.0
• empty containers and strings: "", [], (), {}, set(), range(0)

Everything else is truthy, including "0", "False", [0] and -1. You can see how Python classifies a value with bool():

for value in [0, 1, -1, "", "0", [], [0], None, 0.0]:
    print(repr(value), bool(value))

Output:

0 False
1 True
-1 True
'' False
'0' True
[] False
[0] True
None False
0.0 False

The string "0" is truthy because it is a non-empty string. That one catches people who read numbers from input and test them before converting. The numbers and booleans page covers how bool relates to int.

and and or Return an Operand

This is where Python differs from most languages. and and or do not produce a fresh True or False. They return one of the two values you gave them:

• x or y returns x if x is truthy, otherwise it returns y.
• x and y returns x if x is falsy, otherwise it returns y.

print(0 or 5)            # 5
print(3 or 5)            # 3
print("" or "guest")     # guest
print([] or None)        # None

print(0 and 5)           # 0
print(3 and 5)           # 5
print("a" and "b")       # b
print(None and 1 / 0)    # None, and no ZeroDivisionError

When both operands are booleans, "return an operand" and "return a boolean" are the same thing, which is why the difference goes unnoticed until you mix in other types.

not is the exception: it always returns True or False.

print(not 0)        # True
print(not "hi")     # False
print(not [])       # True

If you need a real boolean from an and/or expression, for example to store it or return it from a function that promises bool, wrap it in bool():

name = "Ada"
email = ""

print(name and email)         # prints an empty line: the value is ""
print(bool(name and email))   # False

Short-Circuit Evaluation

Python evaluates and and or from left to right and stops as soon as the answer is known:

• and stops at the first falsy value, because nothing after it can make the whole expression true.
• or stops at the first truthy value, because nothing after it can make the whole expression false.

The skipped side is not run at all. You can watch this happen with functions that print when they are called:

def check(label, result):
    print(f"  checking {label}")
    return result

print("and:")
print(check("A", False) and check("B", True))

print("or:")
print(check("A", True) or check("B", False))

Output:

and:
  checking A
False
or:
  checking A
True

B is never checked in either case. Short-circuiting is what makes guard conditions safe. The second half of each condition below would crash on its own, but it only runs once the first half has ruled out the bad case:

user = None
items = []

if user is not None and user.startswith("admin"):
    print("admin")
else:
    print("not an admin")

if items and items[0] > 10:
    print("first item is large")
else:
    print("no large first item")

Put the cheap or protective test first. Reversing the order, user.startswith("admin") and user is not None, raises AttributeError when user is None.

Patterns Built on or and and

Because or returns its first truthy operand, it gives a one-line default value:

def greet(name):
    name = name or "guest"
    print(f"Hello, {name}!")

greet("Ada")
greet("")
greet(None)

Output:

Hello, Ada!
Hello, guest!
Hello, guest!

The catch is that or replaces every falsy value, not only None. If 0, "" or [] is a legitimate input, or will throw it away:

volume = 0
print(volume or 50)                           # 50: the 0 was replaced

print(volume if volume is not None else 50)   # 0: only None is replaced

Use x if x is not None else default when zero or empty is a valid value. The if/else page covers that conditional expression.

and has a matching pattern: "use this value only if the first one is set". It is less common and often clearer as an if, so reach for it sparingly:

user = {"name": "Ada"}
print(user and user["name"])   # Ada

user = None
print(user and user["name"])   # None

Precedence: not, then and, then or

When an expression mixes the three, Python applies not first, then and, then or. Comparisons such as ==, < and in are applied before any of them.

a, b, c = True, False, False

print(a or b and c)      # True: read as a or (b and c)
print((a or b) and c)    # False
print(not a or b)        # False: read as (not a) or b
print(not (a or b))      # False
print(not 1 == 2)        # True: read as not (1 == 2)

a or b and c and (a or b) and c give different answers from the same values, so a mixed condition should carry parentheses even when the default order happens to be right. They cost nothing and remove the question for the next reader.

and/or vs &/|

& and | look similar to and and or and sometimes give the same answer, but they are different operators.

• and / or test truthiness, short-circuit, and return one of the operands.
• & / | are bitwise operators. On integers they combine the bits of the two numbers. On sets they mean intersection and union. On True and False they return a boolean. They never short-circuit: both sides are always evaluated.

print(6 and 3)   # 3: 6 is truthy, so and returns the second operand
print(6 & 3)     # 2: 110 & 011 = 010 in binary

print(6 or 3)    # 6
print(6 | 3)     # 7: 110 | 011 = 111

print({1, 2, 3} & {2, 3, 4})   # {2, 3}
print(True & False)             # False

The bitwise operators also have higher precedence than comparisons, which turns a condition written with & into something else entirely:

x, y = 5, 5

print(x > 1 and y > 1)     # True
print(x > 1 & y > 1)       # False: read as x > (1 & y) > 1
print((x > 1) & (y > 1))   # True, but the parentheses are required

1 & y is 1 & 5, which is 1, so the middle line becomes the chain 5 > 1 > 1, and 1 > 1 is false. In plain Python code, use and, or and not for conditions.

The one place &, | and ~ are correct for conditions is NumPy and pandas. An array holds many values, so it has no single truth value, and and raises ValueError: The truth value of an array ... is ambiguous. The libraries overload & and | to work element by element, which is why pandas filters look like df[(df.age > 18) & (df.country == "CA")], with parentheses around each comparison for the precedence reason above.

any() and all(): and and or Over a List

To combine a whole sequence of conditions, use the built-ins all() (an and across every item) and any() (an or across every item). Both short-circuit the same way:

scores = [72, 88, 95, 61]

print(all(s >= 60 for s in scores))   # True: every score passed
print(any(s >= 90 for s in scores))   # True: at least one A
print(any(s < 50 for s in scores))    # False

print(all([]))   # True: nothing failed
print(any([]))   # False: nothing passed

Unlike and and or, any() and all() always return a boolean.

Common Mistakes

Comparing one variable against several values with or. This condition is always true:

color = "green"

if color == "red" or "blue":
    print("matched (wrong!)")

if color == "red" or color == "blue":
    print("matched")
else:
    print("no match")

if color in ("red", "blue"):
    print("matched")
else:
    print("no match")

Python reads the first condition as (color == "red") or "blue". The comparison is False, so or returns "blue", a non-empty string, which is truthy. Repeat the comparison on both sides, or better, test membership with in.

Writing && or ||. Both are a SyntaxError. Use and and or.

Expecting a boolean from and/or. x = a or b stores a or b itself. That is often what you want, but if a function should return True or False, convert with bool().

Relying on precedence in mixed conditions. a or b and c is legal and well defined, but add parentheses so nobody has to remember the rule.