and, or y not en Python: operadores lógicos, cortocircuito y valores truthy

Tres palabras en lugar de símbolos

Los operadores lógicos de Python son las palabras inglesas and, or y not. Otros lenguajes los escriben &&, || y !. En Python && y || son un SyntaxError, y ! solo aparece como parte de != ("distinto de").

has_ticket = True
is_adult = False

print(has_ticket and is_adult)   # False: ambos deben ser verdaderos
print(has_ticket or is_adult)    # True: al menos uno es verdadero
print(not is_adult)              # True: invierte el valor

Con True y False las reglas son las que esperas:

and necesita que ambos lados sean verdaderos. or necesita al menos uno. not toma un solo valor y lo invierte.

En código real los lados suelen ser comparaciones, y el resultado alimenta un if o un 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")

Salida:

eligible
standard ticket

Con eso basta para la mayoría de las condiciones. El resto de esta página cubre qué hacen los operadores con valores que no son True ni False, y las reglas que deciden qué lado de una expresión se ejecuta.

Valores truthy y falsy

and, or y not aceptan cualquier valor, no solo booleanos. Python decide si un valor cuenta como verdadero según su valor de verdad. Estos valores son falsy:

• False y None
• el cero de cualquier tipo numérico: 0, 0.0
• los contenedores y strings vacíos: "", [], (), {}, set(), range(0)

Todo lo demás es truthy, incluidos "0", "False", [0] y -1. Puedes ver cómo clasifica Python un valor con bool():

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

Salida:

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

El string "0" es truthy porque es un string no vacío. Este caso pilla a quien lee números de la entrada y los comprueba antes de convertirlos. La página de números y booleanos explica cómo se relaciona bool con int.

and y or devuelven un operando

Aquí es donde Python se diferencia de la mayoría de los lenguajes. and y or no producen un True o False nuevo. Devuelven uno de los dos valores que les diste:

• x or y devuelve x si x es truthy; si no, devuelve y.
• x and y devuelve x si x es falsy; si no, devuelve 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, y sin ZeroDivisionError

Cuando ambos operandos son booleanos, "devolver un operando" y "devolver un booleano" son lo mismo, y por eso la diferencia pasa desapercibida hasta que mezclas otros tipos.

not es la excepción: siempre devuelve True o False.

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

Si necesitas un booleano real de una expresión con and/or, por ejemplo para guardarlo o devolverlo desde una función que promete un bool, envuélvela en bool():

name = "Ada"
email = ""

print(name and email)         # imprime una línea vacía: el valor es ""
print(bool(name and email))   # False

Evaluación en cortocircuito

Python evalúa and y or de izquierda a derecha y se detiene en cuanto conoce la respuesta:

• and se detiene en el primer valor falsy, porque nada de lo que venga después puede hacer verdadera la expresión completa.
• or se detiene en el primer valor truthy, porque nada de lo que venga después puede hacer falsa la expresión completa.

El lado que se salta no se ejecuta en absoluto. Puedes verlo con funciones que imprimen algo cuando se las llama:

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))

Salida:

and:
  checking A
False
or:
  checking A
True

B no se comprueba en ninguno de los dos casos. El cortocircuito es lo que hace seguras las condiciones de guarda. La segunda mitad de cada condición de abajo fallaría por sí sola, pero solo se ejecuta cuando la primera mitad ya ha descartado el caso problemático:

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")

Pon primero la prueba barata o la que protege. Si inviertes el orden, user.startswith("admin") and user is not None lanza AttributeError cuando user es None.

Patrones construidos sobre or y and

Como or devuelve su primer operando truthy, sirve para dar un valor por defecto en una línea:

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

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

Salida:

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

El problema es que or reemplaza cualquier valor falsy, no solo None. Si 0, "" o [] son entradas legítimas, or las descartará:

volume = 0
print(volume or 50)                           # 50: el 0 se reemplazó

print(volume if volume is not None else 50)   # 0: solo se reemplaza None

Usa x if x is not None else default cuando cero o vacío sea un valor válido. La página de if/else explica esa expresión condicional.

and tiene un patrón equivalente: "usa este valor solo si el primero está definido". Es menos común y a menudo queda más claro como un if, así que úsalo con moderación:

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

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

Precedencia: not, luego and, luego or

Cuando una expresión mezcla los tres, Python aplica primero not, luego and y luego or. Las comparaciones como ==, < e in se aplican antes que cualquiera de ellos.

a, b, c = True, False, False

print(a or b and c)      # True: se lee como a or (b and c)
print((a or b) and c)    # False
print(not a or b)        # False: se lee como (not a) or b
print(not (a or b))      # False
print(not 1 == 2)        # True: se lee como not (1 == 2)

a or b and c y (a or b) and c dan respuestas distintas con los mismos valores, así que una condición mixta debería llevar paréntesis aunque el orden por defecto resulte ser el correcto. No cuestan nada y le ahorran la duda al siguiente lector.

and/or frente a &/|

& y | se parecen a and y or y a veces dan la misma respuesta, pero son operadores distintos.

• and / or comprueban el valor de verdad, hacen cortocircuito y devuelven uno de los operandos.
• & / | son operadores bitwise. Con enteros combinan los bits de los dos números. Con sets significan intersección y unión. Con True y False devuelven un booleano. Nunca hacen cortocircuito: siempre se evalúan ambos lados.

print(6 and 3)   # 3: 6 es truthy, así que and devuelve el segundo operando
print(6 & 3)     # 2: 110 & 011 = 010 en binario

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

Los operadores bitwise además tienen mayor precedencia que las comparaciones, lo que convierte una condición escrita con & en algo completamente distinto:

x, y = 5, 5

print(x > 1 and y > 1)     # True
print(x > 1 & y > 1)       # False: se lee como x > (1 & y) > 1
print((x > 1) & (y > 1))   # True, pero los paréntesis son obligatorios

1 & y es 1 & 5, que vale 1, así que la línea del medio se convierte en la cadena 5 > 1 > 1, y 1 > 1 es falso. En código Python normal, usa and, or y not para las condiciones.

El único sitio donde &, | y ~ son correctos en condiciones es NumPy y pandas. Un array contiene muchos valores, así que no tiene un único valor de verdad, y and lanza ValueError: The truth value of an array ... is ambiguous. Estas bibliotecas sobrecargan & y | para que trabajen elemento a elemento, y por eso los filtros de pandas tienen la forma df[(df.age > 18) & (df.country == "CA")], con paréntesis alrededor de cada comparación por el motivo de precedencia de arriba.

any() y all(): and y or sobre una lista

Para combinar una secuencia entera de condiciones, usa las funciones integradas all() (un and sobre todos los elementos) y any() (un or sobre todos los elementos). Ambas hacen cortocircuito de la misma manera:

scores = [72, 88, 95, 61]

print(all(s >= 60 for s in scores))   # True: todas las notas aprobaron
print(any(s >= 90 for s in scores))   # True: al menos un sobresaliente
print(any(s < 50 for s in scores))    # False

print(all([]))   # True: nada falló
print(any([]))   # False: nada aprobó

A diferencia de and y or, any() y all() siempre devuelven un booleano.

Errores comunes

Comparar una variable con varios valores usando or. Esta condición siempre es verdadera:

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 lee la primera condición como (color == "red") or "blue". La comparación es False, así que or devuelve "blue", un string no vacío, que es truthy. Repite la comparación en ambos lados o, mejor aún, comprueba la pertenencia con in.

Escribir && o ||. Ambos son un SyntaxError. Usa and y or.

Esperar un booleano de and/or. x = a or b guarda el propio a o b. A menudo es lo que quieres, pero si una función debe devolver True o False, convierte con bool().

Confiar en la precedencia en condiciones mixtas. a or b and c es válido y está bien definido, pero añade paréntesis para que nadie tenga que recordar la regla.