Pensamiento Computacional · Unidad 3 — Estructuras de control
Booleanos y comparaciones
Una comparación no devuelve un número: devuelve True o False. Con eso, y con and / or / not, se arma cualquier condición.
La explicación
Comparar da un booleano
!= distinto de 5 != 3 → True
> mayor 5 > 3 → True
< menor 5 < 3 → False
>= mayor o igual 5 >= 5 → True
<= menor o igual 5 <= 3 → False
x = 5 le pone 5 a x;
x == 5 pregunta si vale 5. Confundirlos es el error de sintaxis más común de la
materia. Python lo marca como error de sintaxis y, como revisa todo el programa antes de
arrancar, no llega a correr ni una línea: ni siquiera las de arriba del if.
Los tres operadores lógicos
or True si al menos una es True
not da vuelta el valor
es_finde or es_feriado → cualquiera de las dos
not llueve → True cuando no llueve
Encadenar comparaciones
Python permite escribir lo que uno escribiría en matemática, y significa exactamente eso:
Es de las pocas cosas donde Python se parece más a la matemática que otros lenguajes.
Qué cuenta como verdadero
Cualquier valor se puede usar como condición, y Python decide si es verdadero:
Verdaderos: todo lo demás
bool("0") da True. El cero como
número es falso, pero "0" es un string con un carácter adentro, y todo string no
vacío es verdadero. Lo mismo con "False": es texto, y da True.
Cuidado al comparar tipos distintos
"10" == 10 → False (un texto nunca es igual a un número)
El segundo caso vuelve a ser el problema de input(): si comparás lo que entró por
teclado con un número sin convertirlo, siempre va a dar False.
Escribir la condición para que alguien pueda votar: tiene que tener 16 años o más y estar empadronado.
Traducir la frase. "y" es and: tienen que cumplirse las dos.
return edad >= 16 and empadronado
Por qué >= y no >. "16 años o más" incluye a los de 16.
Con > dejarías afuera justo a los que cumplen el mínimo. Ese corrimiento de
uno es de los errores que más cuestan, porque el programa anda bien para casi todos los casos
y falla sólo en el borde.
Por qué empadronado va solo. Si ya es un booleano, escribir
empadronado == True es redundante. La variable ya vale True o False.
edad >= 16 and edad <= 70 and empadronado, y se lee igual que en matemática.
El control que hay que hacer siempre con condiciones: probá los bordes. Con 15, 16, 70 y 71. Si funciona en los bordes, funciona en el medio; al revés no.
Una persona puede cursar Física II si tiene aprobada Análisis, o bien si tiene aprobada Álgebra y además está en segundo año. Escribir la condición en Python, y escribir también su negación (cuándo NO puede cursar) usando las leyes de De Morgan.
Primero hay que leer bien el enunciado. Tiene un "o" y un "y", y el orden en que se agrupan cambia todo:
(analisis o algebra) y segundo ← otra cosa
La diferencia se ve con un caso: alguien que aprobó Análisis pero está en primer año. Con la primera versión puede cursar; con la segunda, no. El enunciado dice que la condición de estar en segundo año acompaña solo a Álgebra, así que va la primera.
En Python, con los paréntesis explícitos:
return analisis or (algebra and segundo)
Los paréntesis no son opcionales aunque Python los sobreentienda. El and tiene más precedencia que el or, así que sin paréntesis Python agrupa igual — pero quien lee el código no tiene por qué saberlo, y en el parcial los paréntesis son parte de la respuesta.
La tabla de verdad, con las 8 combinaciones:
V V V V
V V F V
V F V V
V F F V
F V V V
F V F F
F F V F
F F F F
Cinco verdaderas de ocho. Las cuatro primeras son "tiene Análisis", que alcanza solo; la quinta es el único caso donde entra por el otro camino.
Ahora la negación, con De Morgan. Las dos leyes que hay que aplicar:
not (p and q) ≡ (not p) or (not q)
Se aplica de afuera hacia adentro. La condición es un or, así que primero se usa la primera ley:
≡ (not analisis) and not(algebra and segundo)
Y ahora la segunda ley sobre el and que quedó adentro:
return (not analisis) and ((not algebra) or (not segundo))
En castellano: no puede cursar quien no tenga Análisis y además le falte Álgebra o no esté en segundo año. Los dos "no" del final salen del "y" que se convirtió en "o".
La verificación es comparar las dos columnas en las 8 filas, y coinciden en las 8. Ese es el control completo: con solo tres variables booleanas se puede probar exhaustivamente, y conviene hacerlo.
El error que De Morgan evita: negar cambiando los "o" por "y" pero olvidando negar cada término, o negar cada término pero dejando el conector igual. Las dos cosas van juntas: se niegan los términos y se da vuelta el conector.
Dónde se pierde el punto: escribir la negación como not analisis or not algebra and not segundo, sin paréntesis. Con la precedencia de Python eso se agrupa como (not analisis) or ((not algebra) and (not segundo)), que es otra condición y da distinto en dos de las ocho filas.
Dónde se cae la mayoría
- Escribir = en vez de == dentro de una condición.
- Suponer que "0" o "False" son falsos: son strings no vacíos, y dan True.
- Comparar el resultado de input() con un número sin convertirlo: siempre da False.
Hasta acá la explicación. La práctica es la otra mitad: 8 ejercicios de este tema, en cuatro niveles, que no te dicen sólo si está bien al final sino que te corrigen en cada paso y te explican por qué. Y uno para escribir el programa vos, que se prueba ejecutándolo en Python ahí mismo, en el navegador. Además trae una animación que muestra la idea en movimiento.
Practicar Booleanos y comparaciones →Los otros temas de la unidad 3
Estructuras de control