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.

7 opiniones en “Python: Los operadores lógicos y sus tablas de verdad”

  1. Buenas noches, en dado caso la expresion: “a” or “b” devuelve “a”
    “” or “b” devuelve “b”
    podrias explicar porqué?, gracias.

  2. cordial saludo.
    Me refiero a evaluar otro tipo de expresiones que no sean tan “logicas” como si 2 > 1 or 3>1 sino otro tipo de expresiones, puedes abrir el interprete y ver el valor que devuelve cada una. en el ejemplo: “a” or “b” te devolerá “a” y si le paso una cadena vacía: ” ” or “b” devolverá “b” pero no se el porqué ni cual es la regla que maneja python para comparar de esta forma, en el caso del operador and es lo siguiente: “a” and “b” devuelve “b” y si se pasa la cadena vacía es: ” ” and “b” devuelve ” ” , espero haberme explicado bien. saludos.

    1. Sí, ahora entiendo tu duda:
      Para comprender cómo se comporta Python debes tener en cuenta dos factores:
      1) En expresiones lógicas, cualquier cadena de caracteres evalúa a sí misma, considerada como True, salvo si es la cadena nula, que se considera como False.
      2) Los operadores lógicos son cortocirtuitados. Esto significa que tan pronto como Python conoce la respuesta deja de evaluar.
      Así pues “a” or “b”, al ser “a” verdadero, la respuesta ya va a ser verdadera independientemente de lo que venga después. De modo que se detiene ahí y no sigue evaluando, devolviendo “a”.
      En el segundo ejemplo “” and b, puesto que “” se considera False, vuelve a suceder lo mismo: independientemente de lo que venga después el resultado ya es falso, y no necesita seguir evaluando, de modo que devuelve el resultado de la primera evaluación: “”.
      Espero que te quede claro.
      Saludos

      1. ok, y en la expresión “a” and “b” porqué devuelve “b” ? , sé que son cortocircuitados y por eso en el operador or cualquier expresión que venga después ya no la evaluará si es cierta la primera,pero mirando este otro ejemplo:
        “a” and ” ” or “c” and “d” devuelve “d”. osea, porqué con el operador and devuelve el ultimo valor?, se que parezco tiquismiquis pero quiero saber el porqué, auqnue pienso que al ser la ultima expresión evaluada almacenará ese último valor. Gracias.

        1. Tú mismo te has respondido…
          La expresión sólo puede devolver un string. “a” and “b” es “b” porque al ser considerado verdad el primer término necesita evaluar el segundo para conocer el resultado que, al ser considerado verdad también, provoca que se devuelva ese string.
          En el segundo ejemplo, los and tienen mayor orden de precedencia que los or, de modo que:

          “a” and “b” devuelve “b”, como vimos antes;
          “c” and “d” devuelve “d”, de igual modo, y ahora:
          “b” or “d”, al ser cortocircuitado, devuelve “b”, sin necesidad de evaluar el segundo argumento.

Deja un comentario