Python: Los operadores lógicos y sus tablas de verdad

Objetivo: presentar los operadores lógicos de Python e ilustrar el uso de bucles for anidados para mostrar sus tablas de verdad.

Aunque ya hay una amplia colección de artículos dedicados a Python, debemos admitir que hay bastantes elementos del lenguaje que aún no han sido presentados en familia. Es el caso, por ejemplo, de los operadores lógicos, de los que nos ocuparemos hoy. Mostraremos los distintos tipos y dejaremos que Python construya las respectivas tablas de verdad, ejemplo que nos servirá, a su vez, para ilustrar la anidación de un bucle for dentro de otro.

Con toda certeza que te has cruzado alguna vez en tu vida con los operadores lógicos o, como también se los conoce, booleanos. No tengo intención de darte una clase de álgebra booleana, de modo que nos centraremos directamente en su representación en Python.

Los tres operadores lógicos básicos son O, Y y NO, representados en Python por or, and y not, respectivamente.

Podemos incluir también el O EXCLUSIVO, que es verdadero cuando uno y solo uno de los operandos lo es, pero estrictamente debes saber que se deriva a partir de los tres básicos. Su representación es ^, el sombrero o caret.

Como ejercicio práctico, vamos a realizar un programa que construya las tablas de verdad correspondientes.

booleanos = [False, True]

# Tabla de verdad de or

print('x\ty\tx or y')
print('-'*22)
for x in booleanos:
    for y in booleanos:
        print(x, y, x or y, sep = '\t')

print()

# Tabla de verdad de and

print('x\ty\tx and y')
print('-'*22)
for x in booleanos:
    for y in booleanos:
        print(x, y, x and y, sep = '\t')
        
print()

# Tabla de verdad de not

print('x\tnot x')
print('-'*13)
for x in booleanos:
    print(x, not x, sep = '\t')

print()

# Tabla de verdad de ^

print('x\ty\tx ^ y')
print('-'*21)
for x in booleanos:
    for y in booleanos:
        print(x, y, x ^ y, sep = '\t') 

No te preocupes si algo no te queda claro en el código, en breve lo explicaremos. Antes quiero que observes el resultado final:

Las tablas de verdad hablan por sí solas:

– El resultado de or es verdadero cuando cualquiera de los operandos lo es.
– El resultado de and es verdadero solo cuando ambos operandos lo es.
– El operador not invierte el valor del operando.
– La o exclusiva, ^, es cierta cuando uno y solo uno de los operandos lo es.

El programa no debe de suponerte ningún misterio:

Comenzamos creando una lista con los dos posibles valores booleanos, False y True, que utilizaremos para iterar sobre ellos:

booleanos = [False, True]

Observa que no hemos rodeado los elementos entre comillas, pues no son strings.

A continuación imprimimos los títulos para la operación or:

print('x\ty\tx or y')
print('-'*22)

Los \t en la primera línea no son más que tabuladores. La extraña operación de la segunda, multiplicando un string por un número, no hace más que repetir 22 veces el carácter ‘-‘.

El quid de la cuestión recae en la doble iteración usando el bucle for:

for x in booleanos:
    for y in booleanos:
        print(x, y, x or y, sep = '\t')

La variable x recorrerá la lista booleanos, tomando en la primera iteración el valor False y en la siguiente True. Pero, por cada iteración, aparece una nueva variable y que también recorrerá booleanos de izquierda a derecha. Así garantizamos que se alcanzan las cuatro combinaciones posibles de x e y.

En la impresión con print, hemos empleado el argumento sep = ‘t’ para que separe cada elemento mediante un tabulador, en lugar de usar un espacio en blanco, valor por omisión. Aprecia el uso de la expresión x or y para que muestre el resultado del or.

El resto de las tablas se calcula del mismo modo, simplemente teniendo en cuenta que hay que emplear, naturalmente, la expresión lógica adecuada.

Debes saber que los operadores lógicos de Python son del tipo cortocircuitados, término que quizás te resulte familiar si conoces otros lenguajes de programación. Esto significa que, si a partir del primer operando ya se puede deducir el resultado final, Python ni se molestará en evaluar el segundo, con el consiguiente ahorro de tiempo.

En un or, si el primer operando es verdadero, sabemos que el resultado lo será ya, por lo que no es necesario que Python se moleste en comprobar la veracidad del segundo.

Del mismo modo, en un and, si el primer operando es falso, el resultado inmediatamente lo será y tampoco será necesario saber lo que ocurre con el segundo.

Para finalizar, una pequeña advertencia: es un error común confundir los operadores lógicos (or y and) con los operadores de unión e intersección de conjuntos (| y &). No te equivoques.

Javier Montero Gabarró


Python: Los operadores lógicos y sus tablas de verdad


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Consulta el índice completo de artículos relacionados con Python.

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.plugin cookies

ACEPTAR
Aviso de cookies