Cómo comprobar si un valor es verdadero (True) en Python

Introducción

En este laboratorio, aprenderás cómo verificar si un valor es True en Python. Comenzaremos explorando los valores booleanos fundamentales True y False, y entenderemos su papel en la toma de decisiones y el flujo del programa.

Luego, aprenderás a usar la comparación directa con True utilizando el operador de igualdad == para verificar si se cumple una condición. Finalmente, adquirirás una comprensión de los valores "veraces" (truthy) en Python.

Aprende sobre True y False

En este paso, exploraremos los valores booleanos fundamentales en Python: True y False. Estos valores son esenciales para tomar decisiones y controlar el flujo de tus programas.

En Python, True y False son palabras clave que representan valores booleanos. Se utilizan para representar la veracidad o falsedad de una condición. Comencemos examinando estos valores directamente en un script de Python.

Abre tu editor de VS Code.
Crea un nuevo archivo llamado boolean_values.py en tu directorio ~/project.
```
cd ~/project
```

Agrega el siguiente contenido al archivo boolean_values.py:

## Assign True and False to variables
is_true = True
is_false = False

## Print the values and their types
print("Value of is_true:", is_true)
print("Type of is_true:", type(is_true))

print("Value of is_false:", is_false)
print("Type of is_false:", type(is_false))

Este script asigna los valores booleanos True y False a las variables is_true y is_false, respectivamente. Luego, imprime los valores y sus tipos correspondientes utilizando la función print().

Ejecuta el script utilizando el comando python:
```
python boolean_values.py
```
Deberías ver la siguiente salida:
```
Value of is_true: True
Type of is_true: <class 'bool'>
Value of is_false: False
Type of is_false: <class 'bool'>
```
Esta salida confirma que True y False son valores booleanos en Python, y su tipo es <class 'bool'>.

Utiliza la comparación directa con True

En este paso, aprenderemos cómo utilizar comparaciones directas con el valor booleano True. La comparación directa es un concepto fundamental en la programación que te permite verificar si una condición es verdadera o falsa.

En Python, puedes utilizar el operador de igualdad == para comparar una variable o expresión directamente con True. Esta es una forma común de verificar si se cumple una condición. Vamos a crear un script para demostrar esto.

Abre tu editor de VS Code.
Crea un nuevo archivo llamado compare_with_true.py en tu directorio ~/project.
```
cd ~/project
```
Agrega el siguiente contenido al archivo compare_with_true.py:
```
## Assign a boolean value to a variable
is_valid = True

## Compare the variable directly with True
if is_valid == True:
    print("The condition is True.")
else:
    print("The condition is False.")

## Another example with a different variable
is_active = False

if is_active == True:
    print("The condition is True.")
else:
    print("The condition is False.")
```
En este script, primero asignamos el valor booleano True a la variable is_valid. Luego, utilizamos una declaración if para verificar si is_valid es igual a True. Si lo es, el script imprime "The condition is True.". De lo contrario, imprime "The condition is False.". Luego repetimos este proceso con una variable is_active establecida en False.
Ejecuta el script utilizando el comando python:
```
python compare_with_true.py
```
Deberías ver la siguiente salida:
```
The condition is True.
The condition is False.
```
Esta salida muestra que el script identifica correctamente cuándo una variable es igual a True y cuándo no lo es.

Entiende los valores truthy

En este paso, exploraremos el concepto de valores "veraces" (truthy) en Python. En Python, no todo es explícitamente True o False, pero ciertos valores se tratan como True en un contexto booleano, mientras que otros se tratan como False. Comprender los valores veraces es crucial para escribir declaraciones condicionales concisas y efectivas.

En Python, los siguientes valores se consideran "falsos" (falsy) (se tratan como False en un contexto booleano):

False
None
0 (cero)
"" (cadena vacía)
[] (lista vacía)
{} (diccionario vacío)
() (tupla vacía)

Todos los demás valores se consideran "veraces" (truthy) (se tratan como True en un contexto booleano). Vamos a crear un script para demostrar esto.

Abre tu editor de VS Code.
Crea un nuevo archivo llamado truthy_values.py en tu directorio ~/project.
```
cd ~/project
```

Agrega el siguiente contenido al archivo truthy_values.py:

## Examples of truthy and falsy values

## Falsy values
falsy_bool = False
falsy_none = None
falsy_int = 0
falsy_string = ""
falsy_list = []
falsy_dict = {}
falsy_tuple = ()

## Truthy values
truthy_int = 1
truthy_string = "Hello"
truthy_list = [1, 2, 3]
truthy_dict = {"key": "value"}

## Check truthiness in if statements
if falsy_bool:
    print("falsy_bool is True")
else:
    print("falsy_bool is False")

if falsy_none:
    print("falsy_none is True")
else:
    print("falsy_none is False")

if falsy_int:
    print("falsy_int is True")
else:
    print("falsy_int is False")

if truthy_int:
    print("truthy_int is True")
else:
    print("truthy_int is False")

Este script define varias variables con diferentes valores, algunos de los cuales son falsos (falsy) y otros son veraces (truthy). Luego, utiliza declaraciones if para verificar la veracidad de cada variable e imprime un mensaje en consecuencia.

Ejecuta el script utilizando el comando python:
```
python truthy_values.py
```
Deberías ver la siguiente salida:
```
falsy_bool is False
falsy_none is False
falsy_int is False
truthy_int is True
```
Esta salida demuestra cómo se tratan diferentes valores como True o False en un contexto booleano. Comprender los valores veraces te permite escribir código más conciso y legible al verificar implícitamente condiciones sin compararlas explícitamente con True o False.

Resumen

En este laboratorio, comenzamos explorando los valores booleanos fundamentales True y False en Python. Aprendimos que estos son palabras clave que representan la veracidad o falsedad de una condición y que su tipo es <class 'bool'>. Asignamos estos valores a variables e imprimimos sus valores y tipos para confirmar su naturaleza.

A continuación, comenzamos a aprender sobre la comparación directa con el valor booleano True utilizando el operador de igualdad ==. Esto nos permite verificar si se cumple una condición.