No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Booleans

12/38
Recursos

Aportes 138

Preguntas 12

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Es importante conocer en muchos casos cuando una variable o tipo de dato es interpretada como True o False, les comparto algunos ejemplos interesantes:

Respectivos resultados:
True False False
False True True True
False False
2

Resumen SM 🚀


Booleans


Los Booleanos son un tipo de dato que solo tiene 2 estados; True (verdadero) ó False (falso), y nos permiten saber si un objeto tiene o no un estado especifico.
Booleans: En python los estados siempre se escriben iniciando en mayúscula.

is_single = True
print(type(is_single))
is_single = False
print(is_single)
  • Podremos invertir el estado utilizando el operador lógico not.
is_single = not is_single
print(is_single)


By SsimorPro

Juego sencillo usando solo el tipo de dato booleano

# Importamos la función randint para generar números aleatorios
from random import randint

# Generamos un número aleatorio entre 1 y 10
numero_secreto = randint(1, 10)

# Inicializamos la variable que indica si el usuario ha adivinado el número
adivinado = False

# Pedimos al usuario que adivine el número
while not adivinado:
  adivinanza = int(input("Adivina el número entero entre 1 y 10: "))
  
  # Comparamos la adivinanza con el número secreto
  if adivinanza == numero_secreto:
    print("¡Felicidades! Adivinaste el número secreto.")
    adivinado = True
  else:
    print("Lo siento, el número secreto es diferente.")

El not viene de la tabla lógica NOT donde los estados cambian a su contrario

print("Ejercicion No 3")

ene = 2000
feb = 2500
mar = 2800
abr = 2900

promedio = (ene + feb + mar + abr)/(4)

print(promedio)

Buenas chicos, espero estén bien.

Un dato que les quería compartir y no se el profe Nico lo diga más adelante es que con los booleans, a veces se hacen comparaciones y con ellos se usan los operadores lógicos como el not que mencionó, los otros son AND y OR y tiene una regla particular

cuando comparas dos variables con el operador AND, python imprimirá True siempre y cuando los dos valores guardados en las variables sean True, pero con el operador OR al comparase dos valores, python regresará True si al menos uno de esos valores está definido como True.

Espero que les sea de ayuda

""" Booleans"""
is_alien = True
print(f"Are you an alien? {is_alien}")
print(type(is_alien))

# Operator "not"
is_alien = not is_alien
print(f"Are you an alien? {is_alien}")
print(type(is_alien))

Después de varias pruebas y ensayo pude Obtener el promedio en automatico compañeros. Se los comparto. Éxitos y bendiciones codeando

# Global values
months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "November", "December"]
budgets = []
average = 0

# start
print("*****Software Budget Average*****")
for month in months:
    print("\b")
    budget = float(input(f"{month} budget: "))
    budgets.append(budget)
    answer = input(f"{months[len(budgets)]} budget? Y / N ? ").upper()
    if answer == "N":
      break

for budget in budgets:
  average += budget

print(f"The average is {average / len(budgets)}")

Enero = 700
Febrero = 800
Marzo = 1200
Resultado = (Enero + Febrero + Marzo)
print (Resultado)
Promedio = (Enero + Febrero + Marzo) /3
print (Promedio)

MI aporte en notion Da click por favor

Además de True y False, también existen otros valores que se pueden evaluar como verdaderos o falsos en Python, como una lista vacía ([]), una cadena de texto vacía (""), el número cero (0), entre otros. En general, cualquier valor que no sea False, None, 0, “”, (), [] o {} se evaluará como verdadero.

saludos compañeros para quienes vean este texto

enero = int(input("money enero: "))
febrero = int(input("money febrero: "))
marzo = int(input("money maro: "))

promedio = enero + febrero + marzo
print(promedio // 3)

Ejercicio promedio 3 meses
ene=100
feb=200
mzo=300
trimestre=(ene+feb+mzo)/3
print(trimestre)

Con este código se consigue el promedio trimestral de un presupuesto:

print("Calculemos cual es el promedio de tu presupuesto trimestral")

enero = int(input("¿Cuanto tienes en Enero?: "))
febrero = int(input("¿Cuanto tienes en Febrero?: "))
marzo = int(input("¿Cuanto tienes en marzo?: "))

print(f"Sí en Enero tienes {enero}, en Febrero tienes {febrero} y en Marzo tienes {marzo}")

trimestre = enero + febrero + marzo
promedio = trimestre / 3

print(f"Tu promedio trimestral es {promedio}")
<code> 
#valores booleanos, Tiene que se mayúscula la primera letra
Casado  = True
print("¿Estás casado ?", Casado)
print("")

#Problemas de infidelidad en la pareja, se separan
#Tiene que ser mayúscula en False
Casado = False
print("¿Estás casado ?", Casado)
print("")

#Reconciliación
inversión = not Casado
print(f"Reconcilación es {inversión}")
print("")

#Resumen
Amor = True
Infidelidad = False
print(f"La indifelidad hace que el amor se invierta, que el vínculo sea {not Amor}")
print("")
print(f"El perdón hace que el infidelidad se invierta, que el vínculo sea {not Infidelidad}")
print("")
![](https://static.platzi.com/media/user_upload/image-9c42b85e-6fa9-4734-a45f-3efa9a9d43bb.jpg)

I Love Python

El NOT ayuda bastante para las cadenas de Ifs

presuEne = int(input('¿Cual es tu presupuesto de Enero?'))
presuFeb = int(input('¿Cual es tu presupuesto de Febrero?'))
presuMar = int(input('¿Cual es tu presupuesto de Marzo?'))

q1 = (presuEne + presuFeb + presuMar)
print(q1)
promedioQ1 = q1 / 3

print(promedioQ1)

Python al ser un lenguaje dinámico y algunos datos numéricos al ser interpretados como str hace necesario que los hagamos de tipado estricto es decir que en algunos campos solo se lean int o float y en otros el str

is_single = True
print(type(is_single))
is_single = False
print(type(is_single))

print(not True)
print(not False)

is_single = not is_single
print(is_single)

Resultado del reto de la clase
enero = 2000000
febrero = 2500000
marzo = 3000000

suma = enero + febrero + marzo
print(suma)

promedio = suma / 3
print(promedio)

budget_enero = 100
budget_feb = 150
budget_marzo = 200
budget_trimester = budget_enero + budget_feb + budget_marzo
promedio = budget_trimester/3
print(promedio)

is_single = True
print(type(is_single))
is_single = False
print(is_single)

print(not True)
print(not False)

is_single = not is_single
print(is_single)

gasto_enero=100
gasto_febrero=200
gasto_marzo=300

promedio = (gasto_enero+gasto_febrero+gasto_marzo)/(3)
print(promedio)

```python #Because input is a string variable then I modified it to integer january = int(input ("write your january income ")) february = int(input ("write your february income ")) march = int(input ("write your march income ")) template = f"Your overall of this 3 months is {(january+february+march)/3}" print(template) ```
estos tipos de datos son los mas importantes, ya que al avanzar se usaran mucho en el código, mas que todo en la lógica. is\_single = True print(type(is\_single)) is\_single = False print(is\_single) print(not True) print(not False) is\_single = not is\_single print(is\_single)
Programa que calcula el promedio de 3 gastos. ![](https://static.platzi.com/media/user_upload/image-968805aa-9bf0-455e-b1a6-4e6d4af2b324.jpg)
Gracias Platzi! Necesitaba un curso completamente desde cero :) \# ejercicio: programa que calcule el promedio del gasto de ciertos meses print ("Presupuesto promedio") gastos\_enero = int(input("cuál es el presupuesto de enero :")) gastos\_febrero = int(input ("cuál es el presupuesto de febrero :")) gastos\_marzo = int(input ("cuál es el presupuesto de marzo :")) calculo = (gastos\_enero + gastos\_febrero + gastos\_marzo)/3 print (calculo)
alguien me puede explicar por que no sale ?? enero = 20.00 febrero = 50.00 marzo = 100.00 abril = 150.00 ganancias = enero + febrero + marzo + abril print(ganancias) ganancias = f"1, {enero}" + "2, {febrero}" + "3,{marzo} "+ "4, {abril}" print(ganancias)
```python # imput Gasto_enero=100 Gasto_febrero=242 Gasto_marzo = 300 #promedio promedio= Gasto_enero+Gasto_febrero+Gasto_marzo promedio= promedio /3 print('El promedio de gasto del primer trimestre es',promedio) ```
![](https://static.platzi.com/media/user_upload/image-79078e5d-b602-4275-819a-a89cd36e5f92.jpg)
![](https://static.platzi.com/media/user_upload/image-9acc599f-8e64-420f-bc09-e7ed1f8f4578.jpg)![](https://static.platzi.com/media/user_upload/image-a82372b1-cb35-42e6-9e24-351e140fa669.jpg)
*En Python, los tipos de datos booleanos son True y False, y se pueden operar con los operadores lógicos **and, or y not.** Aquí te dejo algunos ejemplos:* \# Operador AND print(True and False)  # Devuelve False print(True and True)   # Devuelve True \# Operador OR print(True or False)   # Devuelve True print(False or False)  # Devuelve False \# Operador NOT print(not True)  # Devuelve False print(not False) # Devuelve True *Estos operadores se utilizan frecuentemente en estructuras de control de flujo, como los condicionales if, elif y else. Aquí tienes un ejemplo de aplicación:* edad = 20 mayor\_de\_edad = edad >= 18 if mayor\_de\_edad:     print("Eres mayor de edad.") else:     print("No eres mayor de edad.")
Hola a todos, no sé si vean este comentario, pero encontré este \[libro]\(https://ellibrodepython.com/) que se puede usar en paralelo con este curso. Espero les sirva.
Hola a todos, no se si vean este comentario, pero encontré este libro que puede ser de mucha ayuda mientras se trabaja en paralelo con este curso <https://ellibrodepython.com/>
presupuesto\_enero = int(input("1.¿Cual fue tu presupuesto el mes de Enero? $")) elemento = 1 presupuesto\_febrero = int (input("2.¿Cual fue tu presupuesto el mes de Febrero? $")) elemento +=1 presupuesto\_marzo = int( input("3.¿Cual fue tu presupuesto el mes de Marzo? $")) elemento +=1 suma\_trimestre = presupuesto\_enero + presupuesto\_febrero + presupuesto\_marzo promedio\_trimestre = suma\_trimestre/elemento print (f"En conclusion al haber percibido durante el mes de Enero la cantidad de ${presupuesto\_enero}, el mes de Febrero la cantidad de ${presupuesto\_febrero} y el mes de Marzo la cantidad de ${presupuesto\_marzo}. Podemos concluir que el total percibido en el trimestre fue de ${suma\_trimestre} y el promedio de los presupuestos fue de ${promedio\_trimestre}")
estado = True estado1 = False print(f"--La variable 'estado' tiene como valor booleano inicial {estado}, pero si antecedemos el operador 'not' cambiará su valor. Ahora el valor de la variable 'estado'es ==>> {not estado}. Y su tipo de dato es ==>>" , type(estado))
Creo que igualmente es importante conocer los valores Falsy: En Python, un valor se considera "falsy" si, al evaluarse en un contexto booleano, se considera False. Los valores "falsy" en Python son aquellos que son tratados como False cuando se utilizan en una expresión booleana o en estructuras de control de flujo como `if` o `while`. Aquí están los valores que se consideran "falsy" en Python: **False**: El booleano False en sí mismo es falsy. 1. **None**: El valor None es tratado como False en un contexto booleano. 2. **Cero numérico**: Cualquier valor numérico igual a 0 se considera falsy. Esto incluye enteros (0), flotantes (0.0) y números complejos (0+0j). 3. **Cadenas de caracteres vacías**: Las cadenas de caracteres vacías, es decir, las cadenas que no contienen ningún carácter, se consideran falsy. 4. **Secuencias vacías**: Las secuencias vacías, como las listas vacías `[]`, las tuplas vacías `()`, los conjuntos vacíos `set()`, los diccionarios vacíos `{}`, etc., se consideran falsy. 5. **Objetos personalizados con un método** `__bool__` **o** `__len__` **que devuelve False o 0**: Si un objeto personalizado implementa el método `__bool__()` o `__len__()` y ese método devuelve False o 0, respectivamente, entonces el objeto se considera falsy.
```js #Opcion 1 budget_enero = input( "¿Cual es tu presupuesto para enero?") budget_febrero = input("¿Cual es tu presupuesto para febrero?") budget_marzo = input("Cual es tu presupuestos para marzo") print ("tu promedio presupuestario es de", (int(budget_enero) + int(budget_febrero) + int(budget_marzo)) / 3) #Opcion 2 budget_enero = input( "¿Cual es tu presupuesto para enero?") budget_febrero = input("¿Cual es tu presupuesto de febrero?") budget_marzo = input ("¿cual es tu presupuesto de marzo?") promedio_presupu = (int(budget_enero) + int(budget_febrero)+ int(budget_marzo)) / 3 print ("tu promedio presupuestario es de", promedio_presupu) ```
\# Declaración de variables booleanas verdadero = True falso = False \# Evaluaciones lógicas print(5 > 3) # True print(10 == 5) # False \# Operaciones lógicas print(verdadero and falso) # False print(verdadero or falso) # True print(not verdadero) # False \# Declaración condicional if verdadero: print("Esta declaración se ejecuta porque la variable 'verdadero' es verdadera.") else: print("Esta declaración se ejecuta si la variable 'verdadero' es falsa.") \# Asignación condicional resultado = "Verdadero" if verdadero else "Falso" print(resultado) # "Verdadero"
Programa para saber si es mayor de edad: ```python def es_mayor_de_edad(edad): if edad >= 18: return True else: return False edad_usuario = int(input("Por favor, ingresa tu edad: ")) es_mayor = es_mayor_de_edad(edad_usuario) print("¿Eres mayor de edad?", es_mayor) ```
```js num = int(input("Escribe un numero entero: ")) greater = False if num < 10: print(not greater) elif num > 10: print(greater) else: print("error") ```num = int(input("Escribe un numero entero: "))greater = Falseif num < 10: print(not greater)elif num > 10: print(greater)else: print("error")
![](https://static.platzi.com/media/user_upload/image-86c884e1-c46b-4907-bd7d-ed33e6725e43.jpg)![](https://static.platzi.com/media/user_upload/image-e2baff6b-a1e6-4952-b842-365ab70a3d32.jpg)
estado\_civil = True print(type(estado\_civil)) estado\_civil = False print(estado\_civil) \# usamos not para invertir el valor print(not False) print(not True) estado\_civil = not estado\_civil print(estado\_civil)
![](https://static.platzi.com/media/user_upload/imagen-c4915088-da0f-41cc-a5eb-2c31593e8d1f.jpg)
Los booleanos son una maravilla
`print('promedio de presupuesto')` `budget_january = input('¿cual es tu presupuesto para enero ')` `budget_february = input('¿cual es tu presupuesto para febrero ')` `budget_march = input('¿cual es tu presupuesto para marzo ')` `budget_january = int(budget_january)` `budget_february = int(budget_february)` `budget_march = int(budget_march)` `budget_total = budget_january + budget_february + budget_march` `print('la suma de los presupuestos es: ', budget_total)` `budget_total = int(budget_total)` `avg_budget = budget_total / 3` `print('el promedio es: ',int(avg_budget))` solucion de la clase anterior, no se si se habian dado cuenta pero en replit se va completando el codigo solito con la primera linea, es increible, yo solo le agrego unas cosas y ya
Enero=400000 febrero=250000 marzo=500000 promedio= (Enero+febrero+marzo)/3 print(promedio)
is\_single = True \#las variables booleanas se escriben con mayuscula inicial print(type(is\_single)) is\_single = False print(is\_single) print(not True) print(not False) is\_single = not is\_single print(is\_single)
comparto mi avance, voy a pasitos de bebé: \# practica budget = 1700 print('enero', budget) budget += 1800 print ('febero', budget) budget +=1500 print ('marzo', budget) budget /=3 print ('promedio', budget)
P\_enero = 125000 p\_febrero = 200000 p\_marzo = 300000 P\_trimestre = P\_enero + p\_febrero + p\_marzo print(P\_trimestre) Promedio\_presupuestario = P\_trimestre / 3 print(Promedio\_presupuestario)

not es == a ! en javascript

los tipos de datos booleanos son simples (verdadero=true, falso=false) y se pueden invertir colocando o agregando un no, o not

jan=float(input("Enter January sueldo: ")) feb=float(input("Enter february sueldo: ")) march=float(input("Enter marchsueldo: ")) average=(jan+feb+march)/3 print("average sueldo: ",average)
jan=float(input("Enter January sueldo: ")) feb=float(input("Enter February sueldo: ")) march=float(input("Enter March sueldo: ")) average=(jan+feb+march)/3 print("Average sueldo: ",average)
![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202023-11-06%20162950-18328670-e98b-4cd4-9f57-98d7e365d972.jpg) Mi aporte de como personalice el ejercicio anterior.

Estimados como ejercicio para resolver sobre promedio de gastos de tres meses, comparto código:

Curso demasiado GOD, estoy repasando Python antes de tomar un diplomado en Inteligencia Artificial
presupuesto1 = 1000 presupuesto2 = 1000 presupuesto3 = 1000 print(f"presupuesto Enero {presupuesto1}") print(f"presupuesto Febrero {presupuesto2}") print(f"presupuesto Marzo {presupuesto3}") presupuesto4 = int(input("presupuesto Abril = ")) presupuestofinal = presupuesto1+presupuesto2+presupuesto3+presupuesto4 print("Total presupuesto = ",presupuestofinal) print("Promedio presupuesto = ",presupuestofinal/4)
![](https://static.platzi.com/media/user_upload/image-31bc8411-5c80-4994-9424-3e91d79ef20a.jpg)
**Bucles:** Los valores booleanos a menudo se utilizan en bucles para controlar cuándo debe continuar o detenerse la iteración. Por ejemplo, puedes usar un `while` loop con una condición booleana para repetir una acción hasta que la condición sea `False`.```js seguir = True while seguir: respuesta = input("¿Quieres continuar? (Sí/No) ") if respuesta.lower() == "no": seguir = False ```seguir = True while seguir: respuesta = input("¿Quieres continuar? (Sí/No) ") if respuesta.lower() == "no": seguir = False
En Python, los tipos de datos booleanos (`bool`) se utilizan principalmente para realizar operaciones lógicas y control de flujo en programas. Un ejemplo: **Condicionales:** Los valores booleanos se utilizan en declaraciones condicionales, como `if`, `elif` y `else`, para tomar decisiones basadas en si una condición es verdadera (`True`) o falsa (`False`). condicion = True ```js if condicion: True print("La condición es verdadera") else: print("La condición es falsa") ```
**NOTAS** ![](https://static.platzi.com/media/user_upload/image-61fecb89-95a0-42b6-9193-a147336b4ced.jpg)**CODE** ![](https://static.platzi.com/media/user_upload/image-ada521d9-ebb2-468d-8350-d2e1a056b8ba.jpg) **OUTPUT** ![](https://static.platzi.com/media/user_upload/image-b2355963-b6f7-47a1-8cd7-07fc704dc49d.jpg)
![](https://static.platzi.com/media/user_upload/image-0e927085-ce15-47ee-820c-266fbee95c95.jpg)

`#Registrar los presupuestos mensuales` `pres_enero=2500` `pres_febre=4600` `pres_marzo=1800` `pres_abril=2600` `#Calcular presupuesto promedio` `pres_pro=(pres_enero+pres_febre+pres_marzo)/4` `print(pres_pro)`
```python #ejercicio 3 Enero = 100 Febrero = 200 Marzo = 300 SumaMeses = Enero+Febrero+Marzo promedio = SumaMeses /3 template_promedio = f"El promedio mensual es {promedio}" print(template_promedio) ```
```python is_single = True print(is_single) #True is_single = False print(is_single) #False # ' not ' operator flips the value of the given variable print(not True) print(not False) is_single = not is_single print(is_single) #True print(not(not(not is_single))) # False → True → False ```

Están geniales las clases…

Programa que calcule el presupuesto de ciertos meses con salida booleana y 2 digitos

1.- variable de enero
2.- variable de febrero
3.- variable de marzo
4.- suma los presupuestos 1, 2 , 3 y saca el promedio

p_e = input("presupuesto de enero : ")
p_f = input("presupuesto de febrero : ")
p_m = input("presupuesto de marzo : ")
p_t = round((float(p_e) + float(p_f) + float(p_m))/ 3,2)
print(f"enero: {p_e}, febrero: {p_f}, marzo: {p_m}, promedio total: {p_t}")```

january= 100
febrery=200
march= 150
promedio = (january + febrery + march)
print(promedio)
print(promedio/3)

Importante! El valor de las variables booleanas en python se escriben con la primera letra en minuscula (True o False)

Booleanos

Es un tipo binario que solo pueden tener dos variables True o False.

is_single = True
print(type(is_single)) #@ True
is_single = False
print(is_single) #@ False

Invertir el valor del Booleano

Utilizando el operador not podemos invertir el valor del booleano

print(not True) #@ False
print(not False) #@ True
#solo pueden tener dos valores, True or False
is_single = True
print(type(is_single))
#cambiando el valor
is_single = False
print(is_single)

#se pueden invertir, depende del estado de la
#variable, usando el operador NOT, tambien existen
#AND y OR
print(not True)
print(not False)

is_single = not is_single
print(is_single)


#Algunos ejemplos de obejtos evaluados como falsos son:
#1 las constantes None y False
#2 los valores numericos interpretados por cero: o, o.o, o.n
#3Objetos varios: '', "", dict(), set(), range (0), []

#juego sencillo usando booleanos

# Importamos la función randint para generar números aleatorios
from random import randint

# Generamos un número aleatorio entre 1 y 10
numero_secreto = randint(1, 10)

# Inicializamos la variable que indica si el usuario ha adivinado el número
adivinado = False

# Pedimos al usuario que adivine el número
while not adivinado:
  adivinanza = int(input("Adivina el número entero entre 1 y 10: "))
  
  # Comparamos la adivinanza con el número secreto
  if adivinanza == numero_secreto:
    print("¡Felicidades! Adivinaste el número secreto.")
    adivinado = True
  else:
    print("Lo siento, el número secreto es diferente.")
jan_budgt = 3000000
feb_budgt = 5000000
march_budgt = 1000000

bud_month_avg = (jan_budgt + feb_budgt + march_budgt)/3

print('budget month avg =>', bud_month_avg)

#numbers promedio trimestral
budget_january = 100000
budget_february = 250000
budget_march = 600000
budget_average = budget_january + budget_february + budget_march / 3
currency = “dolares”

print(budget_average , currency)

debo un simple ejercicio en python con el cual compara las entradas de dos variables, y imprime si son iguales, mayor o menor

<code> 
###comparaciones para saber si x es mayor, menor o igual a y


x = int(input("Cuanto es el valor de x: "))

y = int(input("Cuanto es el valor de y: "))


esMayor = x > y
esMenor = x < y
esIgual = x == y

print(f'x({x}) es mayor a y({y}): {esMayor}')
print(f"x({x}) es menor a y({y}): {esMenor}")
print(f" x({x}) es igual a y{y}: {esIgual}") 

Hola, dejo mi solución cumpliendo el requerimiento, se puede hacer más pero el requerimiento fue claro, si a penas estás aprendiendo a programar no lo entenderás.

budg_jan = 15200
budg_feb = 23700
budg_mar = 93600

# Redondeado con round()
print( f"El promedio del presupuesto de los 3 meses es: { round(((budg_jan + budg_feb + budg_mar) / 3), 2) }" )

# Redondeado con el format specifier
print( f"El promedio del presupuesto de los 3 meses es: { ( (budg_jan + budg_feb + budg_mar) / 3 ):.2f}" )

Listo!

Booleanos

Dato = True
Print(not Dato)

#Booleans
#Archivo 06_booleas.py

is_single = True
print(type(is_single))

is_single = False
print(is_single)

print(not True)

print(not False)

is_single = not is_single
print(is_single)


muy basico pero da el resultado
ppto_enero= 1000
ppto_febrero=2000
ppto_marzo=3000
ppto_prom_trim= ((ppto_enero+ppto_febrero+ppto_marzo)/3)
print(ppto_prom_trim)

Truey False. Los booleanos se utilizan a menudo en declaraciones condicionales y operaciones lógicas para

is_true = True
is_false = False

Los valores booleanos también pueden ser el resultado de una comparación y lógica.

x = 5
y = 10

# Comparison operations
is_equal = x == y  # Result: False
is_not_equal = x != y  # Result: True
is_greater = x > y  # Result: False
is_less = x < y  # Result: True
is_greater_equal = x >= y  # Result: False
is_less_equal = x <= y  # Result: True

# Logical operations
logical_and = is_true and is_false  # Result: False
logical_or = is_true or is_false  # Result: True
logical_not = not is_true  # Result: False

tambien se puede cambiar el boleano de esta manera

<print(not is_single)> 

Es interesante que el tipo de dato de un mayor o menor es un bool. Y asi mismo se en condicionales.


Esta es mi solución:

budget_january = float(input('Presupuesto de enero: '))
budget_february = float(input('Presupuesto de febrero: '))
budget_march = float(input('Presupuesto de marzo: '))

budget_total = budget_january + budget_february + budget_march
print('Presupuesto total: {:.3f}'.format(budget_total))

budget_average = budget_total / 3
print('Promedio presupuesto: {:.3f}'.format(budget_average))

Tanto el operador “not” en Python como el operador “!” (negación lógica) en JavaScript son operadores de negación lógica que cambian el valor de verdad de una expresión booleana.

Valores basicos booleans sin modificaciones

is_single = True
print (type(is_single))
is_single = False
print (type(is_single))

Valores transformandolos a su contrario con “not”

print(not True)
print(not False)

valores transformandolos a lo contraio de el ultimo valor de “is_single”

Cuyo valor ultimó fué “False”

is_single = not is_single
print(is_single)

boolean = False
print("She Loves Me? ", boolean)
print("😭💔")

print("She Loves Me? ", not boolean)
print("💖😎👌")
#Los booleanos solo pueden tener 2 valores y empiezan en mayúscula
is_single = True
print(type(is_single))
is_single = False
print(is_single)
#El operador not invierte el valor
print(not True)
print(not False)

is_single = not is_single
print(is_single)

enero = 1500
febrero = 1500
marzo = 2000
print(enero + febrero + marzo)

#Presupuesto promedio de 3 meses
pre_enero = 300
pre_febrero = 500
pre_marzo = 200

prom_pre = (pre_enero +pre_febrero+pre_marzo) /3
print(f"El presupuesto promedio es {prom_pre}")
print(type(prom_pre))

print(‘ingresa el presupuesto de 3 meses’)

mes1 = input(’¿Presupuesto del mes 1 ?’)
mes2 = input(’¿Presupuesto del mes 2 ?’)
mes3 = input(’¿presupuesto del mes 3 ?’)

mes1 = float(mes1)
mes2 = float(mes2)
mes3 = float(mes3)

promedio = round((mes1 + mes2 + mes3)/3,2)

print('El promedio de los tres meses es: ',promedio)

Python Truthiness and Truth Table

budget_1=100
budget_2=300
budget_3=400
budget_total=budget_1+budget_2+budget_3
promedio=budget_total/3
print(promedio)

Vamos para adelante.