Una expresión booleana es una expresión que es verdadera o falsa. En el siguiente ejemplo se utiliza el operador ==, que compara dos operandos y produce True si son iguales o falsos si son diferentes.
5 == 5
5 == 6
Verdadero y falso son valores especiales que pertenecen a la clase bool; no son palabras o caracteres.
type(True)
type(False)
El operador == es uno de los operadores de comparación; los otros lo son:
x != y # x no es igual a y
x > y # x es mayor que y
x < y # x es menos que y
x >= y # x es mayor o igual que y
x <= y # x es menor o igual que y
x is y # x es lo mismo que y
x is not y # x no es lo mismo que y
Aunque estas operaciones probablemente le resulten familiares, los símbolos de Python son diferentes de los símbolos matemáticos para las mismas operaciones. Un error común es utilizar un solo signo igual (=) en lugar de un doble signo igual (==). Recuerde que = es un operador de asignación y == es un operador de comparación. No existe tal cosa como =< o =>.
Hay tres operadores lógicos: y (and), o (or), y no (not). La semántica (significado) de estos operadores es similar a su significado en inglés. Por ejemplo,
x = #escribe algo acá
x > 0 and x < 10
es cierto sólo si x es mayor que 0 y menor que 10.
n%2 == 0 or n%3 == 0
es cierto si cualquiera de las condiciones es verdadera, es decir, si el número es divisible entre 2 o 3.
Finalmente, el operador not niega una expresión booleana, por lo que no (x > y) es verdadero si x > y es falso; es decir, si x es menor o igual que y.
En sentido estricto, los operandos de los operadores lógicos deberían ser expresiones booleanas, pero Python no es muy estricto. Cualquier número que no sea cero se interpreta como "verdadero".
17 and True
Esta flexibilidad puede ser útil, pero hay algunas sutilezas en ella que pueden ser confusas. Puede que quieras evitarlo hasta que estés seguro de lo que estás haciendo.
Para escribir programas útiles, casi siempre necesitamos la capacidad de comprobar las condiciones y cambiar el comportamiento del programa en consecuencia. Las declaraciones condicionales nos dan esta habilidad. La forma más simple es la declaración de "si" o "if":
x = 10
if x > 0 :
print('x es positivo')
Una segunda forma de la declaración de if es una ejecución alternativa, en la que hay dos posibilidades y la condición determina cuál de ellas se ejecuta. La sintaxis tiene este aspecto:
x = 10
if x%2 == 0 :
print('x es par')
else :
print('x es inpar')
Si el residuo cuando x se divide por 2 es 0, entonces sabemos que x es par, y el programa muestra un mensaje a tal efecto. Si la condición es falsa, se ejecuta el segundo conjunto de declaraciones.
Ya que la condición debe ser verdadera o falsa, se ejecutará exactamente una de las alternativas. Las alternativas se llaman ramas, porque son ramas en el flujo de la ejecución.
A veces hay más de dos posibilidades y necesitamos más de dos ramas. Una forma de expresar un cálculo como ese es un condicional encadenado:
x=
y=
if x < y:
print('"x" es menor que "y"')
elif x > y:
print('"x" is mayor que "y"')
else:
print('"x" y "y" sons iguales')
elif es una abreviatura de "else if". De nuevo, se ejecutará exactamente una rama. No hay límite en el número de declaraciones de elif. Si hay una cláusula "else if", tiene que ser al final, pero no tiene que haber una.
letra =
if letra == 'a':
print('Malas resultado')
elif letra == 'b':
print('Buen resultado ')
elif letra == 'c':
print('Cerca, pero no es correcto')
Cada condición se comprueba en orden. Si la primera es falsa, la siguiente se comprueba, y así sucesivamente. Si una de ellas es verdadera, la rama correspondiente se ejecuta, y la declaración termina. Incluso si más de una condición es cierta, sólo la primera rama verdadera se ejecuta.
Un condicional también puede anidarse dentro de otro. Podríamos haber escrito el ejemplo de las tres ramas así:
if x == y:
print('x y y son iguales')
else:
if x < y:
print('x es menos que y')
else:
print('x es mayor que y')
El condicional exterior contiene dos ramas. La primera rama contiene una declaración simple. La segunda rama contiene otra declaración if, que tiene dos ramas propias. Esas dos ramas son ambas declaraciones simples, aunque también podrían haber sido declaraciones condicionales.
Aunque la indentación de las declaraciones hace que la estructura sea aparente, los condicionales anidados se vuelven difíciles de leer muy rápidamente. En general, es una buena idea evitarlos cuando se pueda.
Los operadores lógicos suelen ser una forma de simplificar las declaraciones condicionales anidadas. Por ejemplo, podemos reescribir el siguiente código utilizando un solo condicional:
if 0 < x:
if x < 10:
print('x es un número positivo de un solo dígito.')
La declaración print se ejecuta sólo si pasamos los dos condicionales, para que podamos obtener el mismo efecto con el operador y:
if 0 < x and x < 10:
print('es un número positivo de un solo dígito')
#Para explicar Try y Except utilizaremos de ejemplo una función que convierte la temperatura en grados Fahrenheit a una temperatura en grados Celsius:
temperatura_fahr = input('Ingrese la temperatura en grados Fahrenheit: ')
fahr = float(temperatura_fahr)
cel = (fahr - 32.0) * 5.0 / 9.0
print(cel)
Ingrese la temperatura en grados Fahrenheit: 32 0.0
Si ejecutamos este código y le damos una entrada inválida, simplemente falla con un mensaje de error poco amistoso como por ejemplo ingresando una palabra "Grado" en la entrada:
temperatura_fahr = input('Ingrese la temperatura en grados Fahrenheit: ')
fahr = float(temperatura_fahr)
cel = (fahr - 32.0) * 5.0 / 9.0
print(cel)
Ingrese la temperatura en grados Fahrenheit: 101 grados
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-2-44e1ffdccc92> in <module> 1 temperatura_fahr = input('Ingrese la temperatura en grados Fahrenheit: ') ----> 2 fahr = float(temperatura_fahr) 3 cel = (fahr - 32.0) * 5.0 / 9.0 4 print(cel) ValueError: could not convert string to float: '101 grados'
Esto ocurre por que cuando el programa detecta un error no pasa a la linea siguiente, sino simplemente se detiene.
Hay una estructura de ejecución condicional incorporada en Python para manejar estos tipos de errores esperados e inesperados llamada "try / except". La idea de try y except es que se sabe que alguna secuencia de instrucción(es) puede tener un problema y se quiere añadir algunas declaraciones para ser ejecutadas si se produce un error. Estas declaraciones adicionales (el bloque except) se ignoran si no hay ningún error. Puedes pensar en la característica try y except de Python como una "póliza de seguro" en una secuencia de declaraciones.
Podemos reescribir nuestro convertidor de temperatura de la siguiente manera:
temperatura_fahr = input('Enter Fahrenheit Temperature:')
try:
fahr = float(temperatura_fahr)
cel = 5.0 / (9.0 * (fahr - 32.0))
print(cel)
except:
print('Please enter a number')
Enter Fahrenheit Temperature:32 Please enter a number
Python comienza ejecutando la secuencia de declaraciones en el bloque de prueba. Si todo va bien, se salta el bloque de excepción y procede. Si se produce una excepción en el bloque de prueba, Python salta del bloque de prueba y ejecuta la secuencia de sentencias en el bloque de excepción.
Manejar una excepción con una declaración de intento se llama atrapar una excepción. En este ejemplo, la cláusula "except" imprime un mensaje de error. En general, capturar una excepción le da la oportunidad de arreglar el problema, o intentarlo de nuevo, o al menos terminar el programa con gracia.
Cuando Python está procesando una expresión lógica como x >= 2 and (x/y) > 2, se evalúa la expresión de izquierda a derecha. Debido a la definición de y, si x es menos de 2, la expresión x >= 2 es Falsa y por lo tanto toda la expresión es Falsa sin importar si (x/y) > 2 evalúa a Verdadero o Falso.
Cuando Python detecta que no hay nada que ganar evaluando el resto de una expresión lógica, detiene su evaluación y no hace los cálculos en el resto de la expresión lógica. Cuando la evaluación de una expresión lógica se detiene porque el valor global ya se conoce, se llama cortocircuito de la evaluación.
Mientras que esto puede parecer un buen punto, el comportamiento de cortocircuito lleva a una inteligente técnica llamada el patrón del guardián. Considere la siguiente secuencia de códigos en el Intérprete de Python:
x = 6
y = 2
x >= 2 and (x/y) > 2
x = 1
y = 0
x >= 2 and (x/y) > 2
x = 6
y = 0
x >= 2 and (x/y) > 2
El tercer cálculo falló porque Python estaba evaluando (x/y) y "y" era cero, lo que causa un error de tiempo de ejecución. Pero el segundo ejemplo no falló porque la primera parte de la expresión x >= 2 evaluada da Falso por lo que el (x/y) nunca se ejecutó y no hubo regla de cortocircuito (no hubo error).
Podemos construir la expresión lógica para colocar estratégicamente una evaluación del guardia justo antes de la evaluación que podría causar un error de la siguiente manera:
x = 1
y = 0
x >= 2 and y != 0 and (x/y) > 2
x = 6
y = 0
x >= 2 and y != 0 and (x/y) > 2
x >= 2 and (x/y) > 2 and y != 0
En la primera expresión lógica, x >= 2 es Falso, por lo que la evaluación se detiene en el y. En la segunda expresión lógica, x >= 2 es Verdadero pero y != 0 es Falso por lo que nunca llegamos a (x/y). En la tercera expresión lógica, la y != 0 está después del cálculo (x/y) por lo que la expresión falla con un error. En la segunda expresión, decimos que y != 0 actúa como un guardián para asegurar que sólo ejecutamos (x/y) si y no es cero
Un matemático perezoso desea conocer de manera sencilla la énesima potencia a la cual debe elevar un numero x para que de exactamente un numero y. Para esto necesita una función que le permita resolver su problema.
Desarrolle una función que dados dos número enteros x y y, calcule si existe un número entero n que permita elevar a x dé como resultado y.
Como precaución, cuando y sea 1, 0 o un número negativo, siempre se debe retornar False.
Nombre de la función: pereira_es_potencia
Parámetros
| Nombre | Tipo | Descripción |
|---|---|---|
| x | int | Número que elevado al número misterioso da y |
| y | int | Resultado de elevar x al número misterioso |
| Tipo del retorno | Descipción del retorno |
|---|---|
| bool | Valor booleano que indica si existe un número entero que permita elevar x, dando como resultado y |
En la fábrica de chocolates de Caliche, el CTU (Chief Technology Umpa-Lumpa) ha decidido implementar un nuevo sistema de clasificación de chocolates, para facilitar la organización de los mismos. Cada presentación tiene ahora un identificador numérico único. El identificador es un número entero entre 100 y 999, y sirve para clasificar los chocolates de la siguiente manera.
Si el número es palíndromo e impar, la presentacion corresponde a un chocolate amargo.
Si el número es palíndromo y par, la presentacion corresponde a un chocolate dulce.
Si el número es par, pero no palíndromo, la presentación corresponde a un chocolate con canela y clavos.
Si el número es impar, pero no palíndromo, la presentacion corresponde a un chocolate bajo en grasa.
Escriba una función que ayude al CTU a calcular, dado un identificador único de presentación, a que tipo de chocolate corresponde dicha presentación.
Nombre de la función: clasificar_chocolate
Parámetros
| Nombre | Tipo | Descripción |
|---|---|---|
| id | int | El identificador de la presentacion cuyo tipo de chocolate se quiere calcular. |
| Tipo del retorno | Descipción del retorno |
|---|---|
| str | Si el número es Palíndromo e impar, la presentacion corresponde a un chocolate amargo, y se retorna "BITTER". Si el número es Palíndromo y par, la presentacion corresponde a un chocolate dulce, y se retorna "SWEET". Si el número es par, pero no palíndromo, la presentación corresponde a un chocolate con canela y clavos, y se retorna "CINNAMON". Si el número es impar, pero no palíndromo,la presentacion corresponde a un chocolate bajo en grasa, y se retorna "LIGHT" |
def palidromo(numero:int)->bool:
centena=numero//100
decena=(numero-centena*100)//10
unidad=numero-centena*100-decena*10
if centena == unidad:
resultado = True
else:
resultado = False
return resultado
def espar(numero:int)->bool:
if numero % 2 == 0:
resultado = True
else:
resultado = False
return resultado
def clasificar_chocolate(codigo:int)->str:
if palidromo(codigo):
if espar(codigo):
resultado = "SWEET"
else:
resultado = "BITTER"
else:
if espar(codigo):
resultado = "CINNAMON"
else:
resultado = "LIGHT"
return resultado
print(clasificar_chocolate(123))
print(clasificar_chocolate(222))
print(clasificar_chocolate(111))
print(clasificar_chocolate(505))
print(clasificar_chocolate(576))