Operadores lógicos de Python: Una introducción práctica

En programación, a menudo tenemos que tomar decisiones basadas en múltiples condiciones. Por ejemplo, podemos querer ejecutar una determinada acción sólo si se cumplen varias condiciones simultáneamente. Alternativamente, podríamos querer desencadenar una acción alternativa si se cumple alguna de varias condiciones.

Python ofrece un conjunto de operadores lógicos - and, or, not - para manejar estos escenarios.

En este tutorial, aprenderemos cómo funcionan los operadores lógicos de Python y cómo utilizarlos en programación y ciencia de datos. Ten en cuenta que utilizaremos las palabras Y, O y NO en mayúsculas para representar conceptualmente estos operadores. Y nos referiremos a las palabras clave de Python utilizando esta convención: and, or, y not.

Si buscas un plan de estudios de Python curado, echa un vistazo a este curso de seis cursos sobre habilidades de programación en Python.

Antes de entrar en detalles, empecemos con una respuesta muy breve para los que tengáis prisa.

Respuesta corta: ¿Qué son los operadores lógicos de Python?

Los operadores lógicos de Python (and, or, not) son palabras clave especiales que actúan como conjunciones en nuestro código, conectando y evaluando varias condiciones dentro de una misma expresión.

Considera este ejemplo:

temperature = 25
is_sunny = True
if temperature > 20 and is_sunny:
    print("It's a perfect day for a picnic!")

It's a perfect day for a picnic!

Aquí, el operador y garantiza que el mensaje sólo se imprima si se cumplen las condiciones both: la temperatura es superior a 20 grados and hace sol.

Veamos otro ejemplo utilizando el operador or:

has_umbrella = False

if is_sunny or has_umbrella:
    print("Let's go for a walk!")

Let's go for a walk!

En este caso, saldremos a pasear si hace sol o tenemos un paraguas.

Por último, el operador not invierte el valor de verdad de una condición:

if not is_sunny:
    print("Maybe we should stay indoors.")

Aquí, el mensaje se imprime sólo si no está soleado.

Los operadores lógicos nos proporcionan una forma concisa y potente de expresar condiciones complejas, permitiendo a nuestros programas tomar decisiones basadas en múltiples factores. Ahora vamos a profundizar un poco más y empezaremos con el operador lógico and.

Python: El método and Operario

En lógica booleana, la operación Y consiste en comparar dos valores o expresiones. Sólo produce un resultado verdadero si ambos valores son verdaderos. Si uno o los dos valores son falsos, el resultado de la operación AND es falso. Aquí tienes un resumen de cómo se comporta AND:

Podemos recrear esta tabla verdadero-falso con el operador and de Python:

options = True, False
for a in options:
    for b in options:
        print(f"{a} and {b} gives {a and b}")

True and True gives True
True and False gives False
False and True gives False
False and False gives False

La variable options contiene los dos valores booleanos. Los bucles anidados for iteran a través de las opciones dos veces para crear todas las permutaciones de True y False.

A menudo, las expresiones utilizadas como operandos de y incluyen operadores de comparación o igualdad:

names = "James", "Bob", "David", "Jane", "Kate", "Mary"
for name in names:
   if len(name) < 5 and name[0] == "J":
      print(name)

Jane

El nombre sólo se imprime si contiene menos de cinco letras y empieza por "J". Deben cumplirse ambos requisitos.

Los operadores de comparación e igualdad, como < y ==, evalúan a True o False.

Sin embargo, el operador and de Python funciona con cualquier tipo de datos y no sólo con los booleanos True y False. El valor de salida también puede ser cualquier tipo de dato.

Exploremos el operador and de Python con más detalle en esta sección. En primer lugar, hablaremos de la veracidad.

Python: veraz y falso

Todo objeto de Python puede convertirse a un tipo booleano mediante la función bool(). Un objeto es verdadero si bool(object) devuelve True. Para un objeto falso, bool(object) devuelve False.

El operador and de Python mira la veracidad de sus operandos. Si ambos operandos son verdaderos, el operador and también devuelve un valor verdadero. Si uno o ambos operandos son falsos, and devuelve un valor falso. Veamos algunos ejemplos:

if 42 and "python":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")

Both operands are truthy

Consideremos este ejemplo:

if 42 and "":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")

One or both operands are falsy

Y veamos este último ejemplo:

if 0 and "python":
    print("Both operands are truthy")
else:
    print("One or both operands are falsy")

One or both operands are falsy

Los tipos numéricos, como los enteros y los flotantes, son verdaderos si son distintos de cero y falsos cuando son iguales a cero. Las secuencias, como las cadenas, son verdaderas cuando no están vacías y falsas cuando están vacías.

Por tanto, sólo el primero de los tres ejemplos anteriores cumple la condición de que ambos operandos deben ser verdaderos para que el operador and se evalúe como verdadero.

El operador and no siempre devuelve un valor booleano. Una expresión que incluya and también podría evaluarse a uno de los operandos. Vamos a profundizar en esto utilizando los mismos ejemplos que hemos utilizado antes. En lugar de utilizar las expresiones and en una sentencia if, las evaluaremos directamente:

print(42 and "python")
print(42 and "")
print(0 and "python")

python

0

¿Puedes identificar lo que ocurre con estas expresiones?

Empecemos con el último de los tres ejemplos, que tiene 0 y "python" como los dos operandos. El operador and busca dos operandos verdaderos. Como el primero es 0, es falso. No es necesario que el programa compruebe el segundo operador, ya que toda la expresión será falsa independientemente del valor del segundo operando.

Sin embargo, el operador and no devuelve False. En su lugar, devuelve directamente el primer operando. Como el primer operando es falso, toda la expresión and se evalúa como falsa. Esto no causa ningún problema en Python, ya que en situaciones en las que Python requiere un valor verdadero o falso, puede utilizar la veracidad de un objeto.

En el primer ejemplo, el primer operando es 42, que es verdadero. El programa evalúa el segundo operando y lo devuelve. Como el segundo operando es la cadena "python", que es verdadera, toda la expresión se evalúa como verdadera.

En el segundo ejemplo, el primer operando también es 42. Como es verdadero, el programa evalúa y devuelve el segundo operando, que es la cadena vacía. La cadena vacía es falsa y, por tanto, toda la expresión and se evalúa como falsa.

Cuando el primer operando es verdadero, el operador and siempre devuelve el valor del segundo operando, sea verdadero o falso.

Cuando el primer operando es falso, Python no evalúa el segundo operando. Esto se llama cortocircuitar, y es una forma de evaluación perezosa. Puedes confirmarlo con el siguiente código:

0 and 5/0

0

El segundo operando es 5/0, que normalmente provocaría un ZeroDivisionError. Sin embargo, la expresión 5/0 no se evalúa en este ejemplo porque el primer operando es falso. Nunca se lanza la excepción.

Ejemplo: La tienda online de los programadores

Veamos un ejemplo sencillo que representa una aplicación de la vida real. Las transacciones en una tienda online que suministra productos para programadores se registran y se accede a ellas a través de una API. Los datos se convierten en una lista de diccionarios. Cada elemento de la lista representa una transacción y cada transacción es un diccionario que contiene información relevante:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]

Cada transacción incluye el nombre y el precio del artículo, la cantidad incluida en el pedido y si la transacción se ha realizado correctamente.

Supongamos que necesitamos transacciones exitosas para artículos con un precio igual o superior a 100 $. Podemos utilizar el operador and para filtrar las filas que necesitamos:

for item in data:
    if item["Success"] and item["Price"] >= 100:
        print(item)

{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}

La salida de este código muestra la única transacción que cumple ambos requisitos. Para cada elemento de la lista de operaciones, la declaración if comprueba la veracidad de dos expresiones:

• Los valores asociados a la clave "Success" en cada diccionario son True o False.
• El operador mayor o igual que en item["Price"] >= 100 también devuelve True o False.

El libro Python y los cables no cumplen el requisito del precio, ya que son inferiores a 100 $. La máquina de café supera este umbral de precio, pero esta transacción no se realizó correctamente, por lo que se excluye de la impresión.

Volveremos a este ejemplo de tienda online más adelante en este tutorial.

En el apartado siguiente, nos centraremos en el operador or.

Python: El método or Operario

El operador lógico OR de la lógica booleana necesita dos operandos. Se evalúa como verdadero si al menos uno de los operandos es verdadero:

Podemos recrear esta tabla verdadero-falso utilizando el operador or de Python:

options = True, False
for a in options:
    for b in options:
        print(f"{a} or {b} gives {a or b}")

True or True gives True
True or False gives True
False or True gives True
False or False gives False

También podemos retomar el ejemplo con nombres de personas que exploramos antes, pero sustituyendo el operador and por un or:

names = "James", "Bob", "David", "Jane", "Kate", "Mary"
for name in names:
    if len(name) < 5 or name[0] == "J":
        print(name)

James
Bob
Jane
Kate
Mary

La declaración if contiene ahora una expresión or. Por lo tanto, el bucle for imprime todos los nombres que tienen menos de cinco letras o empiezan por la letra "J". La cadena "Jane" cumple ambos requisitos. Los demás nombres impresos cumplen uno de los dos requisitos.

Python or operador: veraz y falso

El operador o también busca valores verdaderos y falsos y no sólo los booleanos True y False. Veamos algunos ejemplos:

if 42 or [10, 20, 30]:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")

At least one operand is truthy

Consideremos ahora este ejemplo:

if 42 or []:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")

At least one operand is truthy

Y consideremos también este último ejemplo:

if 0 or []:
    print("At least one operand is truthy")
else:
    print("None of the operands is truthy")

None of the operands is truthy

En el primer ejemplo, el número entero 42 y la lista no vacía [10, 20, 30] son verdaderos. Como el operador or necesita que al menos un operando sea verdadero, toda la expresión se evalúa como verdadera.

En el segundo ejemplo, 42 es verdadera, pero la lista vacía [] es falsa, ya que es una secuencia vacía. Como uno de los dos operandos es verdadero, toda la expresión or se evalúa como verdadera.

En el ejemplo final, tanto 0 como [] son falsos. Por lo tanto, toda la expresión se evalúa como falsa.

El operador or también utiliza el cortocircuito al evaluar la expresión para evitar evaluaciones innecesarias. Veamos algunos ejemplos para ilustrar este punto:

print(42 or [10, 20, 30])
print(42 or [])
print([] or 42)
print([] or 0)

42
42
42
0

En el primer ejemplo, el primer operando es 42, que es verdadero. Como or sólo necesita que un operando sea verdadero para determinar la veracidad final de toda la expresión, este primer operando se devuelve inmediatamente. El segundo operando no se evalúa, ya que su valor no influye en el resultado final. El operador o devuelve el primer operando, 42, no el booleano True. En Python, cualquier valor verdadero tiene el mismo efecto que el booleano True en situaciones como las sentencias if y las sentencias while.

En el segundo ejemplo, el primer operando también es 42, y la expresión devuelve este entero aunque el segundo operando sea falso.

En los ejemplos tercero y cuarto, el primer operando es la lista vacía, lo que es falso. Por tanto, en ambos casos se devuelve el segundo operando.

Ejemplo: La tienda online de los programadores

Volvamos a las transacciones de la tienda online que vende productos a programadores. Aquí tienes las cuatro transacciones de muestra que vamos a utilizar en este ejemplo:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]

Necesitas identificar algunas transacciones para investigar más a fondo el comportamiento del cliente. Quieres encontrar las transacciones que fallaron o incluyen un artículo con un precio inferior a 75 $. Como tienes dos condiciones y sólo exiges que una operación cumpla al menos una de ellas, puedes utilizar el operador or:

for item in data:
    if item["Success"] == False or item["Price"] < 75:
        print(item)

{'Item': 'Python Book', 'Price': 50, 'Quantity': 1, 'Success': True}
{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}

Este bucle for muestra las líneas que cumplen al menos uno de los requisitos. El libro de Python y los cables están incluidos, ya que su precio es inferior a 75 $. La máquina de café está incluida, ya que la transacción no tuvo éxito.

Hay una forma alternativa de filtrar las transacciones fallidas, que exploraremos en la sección siguiente.

Python: El método not Operario

El operador NOT se diferencia de AND y OR en que sólo necesita un operando. NOT convierte verdadero en falso y al revés. Aquí tienes la tabla verdadero-falso de NOT:

Podemos reproducirlo utilizando el operador not de Python:

options = True, False
    for a in options:
        print(f"not {a} evaluates to {not a}")

not True evaluates to False
not False evaluates to True

Python not operador: veraz y falso

Al igual que con and y or, el operando utilizado con not no tiene por qué ser booleano. Puesto que cualquier objeto es verdadero o falso, cualquier objeto puede utilizarse con not.

if not "python":
    print("The `if` statement evaluated as `True`")
else:
    print("The `if` statement evaluated as `False`")

The `if` statement evaluated as `False`

Veamos también este ejemplo:

if not "":
    print("The `if` statement evaluated as `True`")
else:
    print("The `if` statement evaluated as `False`")

The `if` statement evaluated as `True`

Los valores verdaderos se convierten a False con el operador not y los valores falsos se convierten a True.

A diferencia de and y or, el operador not siempre devuelve un objeto booleano:

print(not "python")
print(not "")

False
True

Ejemplo: La tienda online de los programadores

En los apartados anteriores, hemos utilizado las transacciones de una tienda online. En este ejemplo queremos mostrar todas las transacciones fallidas. Una opción es utilizar el operador de igualdad == para comprobar si data["Success"] es igual a False. Sin embargo, también podemos utilizar el operador not:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]

for item in data:
    if not item["Success"]:
        print(item)

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}

Como item["Success"] es igual a False para las transacciones fallidas, no item["Success"] devuelve True. Por tanto, el bucle for imprime las transacciones fallidas:

En el apartado siguiente aprenderemos a combinar varios operadores lógicos en una expresión.

Python: Precendencia del operador

En los ejemplos mostrados hasta ahora, sólo hemos utilizado uno de los operadores lógicos en cada caso. En este apartado veremos qué ocurre cuando combinamos más operadores lógicos en una misma expresión.

Python: and tiene prioridad sobre or

Seguiremos trabajando con las transacciones de la tienda online que hemos utilizado antes. Probemos la siguiente declaración condicional:

data = [
{"Item": "Python Book", "Price": 50, "Quantity": 1, "Success": True},
{"Item": "Coffee Machine", "Price": 125, "Quantity": 1, "Success": False},
{"Item": "Headphones", "Price": 250, "Quantity": 1, "Success": True},
{"Item": "Cables", "Price": 15.99, "Quantity": 3, "Success": True},
]
​
for item in data:
    if item["Price"] > 100 or item["Quantity"] > 2 and item["Success"]:
        print(item)

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}

La sentencia if contiene dos operadores lógicos. Antes de investigar cómo trata Python esta expresión, veamos una traducción al inglés de la declaración if: Si el precio del artículo es superior a 100 $ o la cantidad vendida es superior a dos y la venta se ha realizado correctamente, imprime el artículo.

Esta frase es ambigua sin más signos de puntuación y puede seguir causando confusión aunque añadamos más comas en la frase. Por ejemplo, ¿debe incluirse la transacción con la máquina de café? El precio del artículo supera el umbral requerido, pero la transacción no se ha realizado correctamente.

Python resolvió esta ambigüedad dando al operador and precedencia sobre el operador or. Esto significa que primero se evalúa la expresión and y su resultado se utiliza en la expresión or.

Por tanto, primero se evalúa la expresión item["Quantity"] > 2 and item["Success"]. Esta expresión devuelve un valor de verdad sólo para la operación que incluye cables. Se evalúa como falso para el resto de elementos.

A continuación, el valor de la expresión y se utiliza con el operador or. La expresión or devuelve un valor verdadero para cualquier artículo que devuelva verdadero para la expresión and -sólo la transacción que incluye cables- y para los artículos con un precio superior a 100 $. Hay dos artículos con precios superiores al umbral: la cafetera y los auriculares.

Python: paréntesis y operadores lógicos

Sin embargo, ¿qué ocurre si necesitamos transacciones con artículos de precio superior a 100 $ o con una cantidad superior a dos, pero también queremos asegurarnos de que la transacción se realiza correctamente? En este caso, queremos que la expresión or tenga prioridad sobre la and para que se evalúe primero. Podemos conseguirlo utilizando paréntesis alrededor de la expresión or:

for item in data:
    if (item["Price"] > 100 or item["Quantity"] > 2) and item["Success"]:
        print(item)

{'Item': 'Headphones', 'Price': 250, 'Quantity': 1, 'Success': True}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}

Los paréntesis adicionales dan precedencia a la expresión or. La transacción de la máquina de café ya no se incluye, puesto que evalúa falso para el segundo operando and.

Python: not tiene prioridad sobre and y or

El operador not tiene prioridad sobre and y or. Por lo tanto, not se evalúa antes que los otros dos operadores lógicos.

Consideremos la siguiente sentencia if, que incluye tanto not como and:

for item in data:
    if not item["Success"] and item["Price"] > 100:
        print(item)

{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}

Como not se evalúa primero, esta expresión aplicará primero el operador not a item["Success"]. El valor de la expresión not se utiliza como primer operando de la expresión y. Sólo la entrada de la máquina de café cumple esta condición: es la única transacción que ha fallado y tiene un precio superior a 100 $.

Sin embargo, podemos dar precedencia al operador and utilizando paréntesis:

for item in data:
    if not (item["Success"] and item["Price"] > 100):
        print(item)

{'Item': 'Python Book', 'Price': 50, 'Quantity': 1, 'Success': True}
{'Item': 'Coffee Machine', 'Price': 125, 'Quantity': 1, 'Success': False}
{'Item': 'Cables', 'Price': 15.99, 'Quantity': 3, 'Success': True}

En este caso, primero se evalúa la expresión and. Sólo la entrada con auriculares se evalúa en True, ya que es la única transacción exitosa con un precio superior a 100 $. Sin embargo, añadimos un operador not antes de la expresión entre paréntesis. Por lo tanto, el código emite las tres transacciones restantes.

En general, si una expresión se vuelve demasiado compleja porque tiene demasiados operadores, lo mejor es dividirla para hacerla más legible.

Conclusión

Los operadores lógicos de Python and, or, y not se utilizan ampliamente en una amplia gama de aplicaciones de programación y ciencia de datos. Estos operadores reproducen el comportamiento de los operadores lógicos booleanos Y, O y NO, utilizados ampliamente en lógica y matemáticas.

Sin embargo, los operadores de Python pueden aceptar cualquier objeto y no sólo valores booleanos. Los operadores and y or utilizan la evaluación en cortocircuito y devuelven uno de los operandos como salida.

Los operadores lógicos de Python son herramientas clave para filtrar datos, identificar características en conjuntos de datos y crear reglas complejas para controlar el flujo de un programa. Si quieres aprender más sobre esto, echa un vistazo a este itinerario profesional de nueve cursos de Analista de Datos con Python.