Acordeón de los Índices
Lección: 17 - Python If ... Else
Python If ... Else
🐍 Python If ... Else: Controlando el Flujo de Ejecución
La estructura if ... else es una de las herramientas fundamentales en programación para tomar decisiones. Permite ejecutar un bloque de código si una condición es verdadera (`True`) y otro bloque de código diferente si la condición es falsa (`False`).
La Sentencia `if`:
Como vimos en el tema anterior, la sentencia `if` evalúa una condición y ejecuta un bloque de código si esa condición es verdadera.
x = 10
if x > 5:
print("x es mayor que 5") # Output: x es mayor que 5
La Sentencia `else`:
La sentencia `else` se utiliza en conjunto con la sentencia `if`. Especifica un bloque de código que se ejecutará si la condición del `if` es falsa.
y = 3
if y > 5:
print("y es mayor que 5")
else:
print("y no es mayor que 5") # Output: y no es mayor que 5
Sintaxis de `if ... else`:
if condicion:
# Bloque de código a ejecutar si la condición es True
instrucciones_if
else:
# Bloque de código a ejecutar si la condición es False
instrucciones_else
Al igual que con la sentencia `if`, la indentación es crucial para definir los bloques de código que pertenecen al `if` y al `else`.
Ejemplo Completo de `if ... else`:
edad = 15
if edad >= 18:
print("Eres mayor de edad. ¡Puedes votar!")
else:
print("Aún no eres mayor de edad. Te faltan", 18 - edad, "años para votar.")
# Output: Aún no eres mayor de edad. Te faltan 3 años para votar.
numero = 7
if numero % 2 == 0:
print(f"{numero} es un número par.")
else:
print(f"{numero} es un número impar.")
# Output: 7 es un número impar.
La estructura `if ... else` permite que tus programas tomen caminos diferentes en la ejecución basándose en la evaluación de condiciones, lo que añade una gran flexibilidad a tu código.
Python Conditions and If statements
🚦 Python Conditions and If Statements: Tomando Decisiones en el Código
En programación, a menudo necesitamos que nuestro código ejecute diferentes bloques de instrucciones dependiendo de si ciertas condiciones son verdaderas o falsas. Python utiliza las condiciones y las sentencias `if` para implementar esta lógica de toma de decisiones.
Condiciones en Python:
Las condiciones son expresiones que evalúan a `True` (verdadero) o `False` (falso). Se utilizan comúnmente para comparar valores.
Python soporta los siguientes operadores de comparación:
==: Igual a!=: No igual a>: Mayor que<: Menor que>=: Mayor o igual que<=: Menor o igual que
La Sentencia `if`:
La sentencia `if` se utiliza para ejecutar un bloque de código solo si una condición especificada es verdadera. La sintaxis básica es:
if condicion:
# Bloque de código a ejecutar si la condición es True
instruccion1
instruccion2
...
Es crucial notar la indentación. En Python, la indentación (generalmente cuatro espacios) se utiliza para definir el bloque de código que pertenece a la sentencia `if`. Si la condición es `True`, todas las instrucciones indentadas se ejecutarán. Si la condición es `False`, el bloque de código se omitirá.
Ejemplos de la Sentencia `if`:
edad = 20
if edad >= 18:
print("Eres mayor de edad.") # Output: Eres mayor de edad.
temperatura = 15
if temperatura < 20:
print("Hace frío.") # Output: Hace frío.
es_estudiante = True
if es_estudiante == True:
print("Eres estudiante.") # Output: Eres estudiante.
# También se puede escribir de forma más concisa:
if es_estudiante:
print("Sigues estudiando.") # Output: Sigues estudiando.
Las sentencias `if` son la base para crear lógica condicional en tus programas de Python, permitiendo que tu código reaccione de manera diferente según las circunstancias.
Indentation
📏 Indentación en Python: La Sintaxis Silenciosa
En muchos lenguajes de programación, como C++, Java o JavaScript, se utilizan llaves {} para definir bloques de código (por ejemplo, el cuerpo de una sentencia `if`, un bucle `for`, o una función). Sin embargo, Python adopta un enfoque diferente y utiliza la indentación para delimitar estos bloques.
La indentación consiste en el espacio en blanco (generalmente cuatro espacios o una tabulación, aunque se recomienda usar cuatro espacios para consistencia) que se coloca al principio de una línea de código para indicar que pertenece a un bloque específico.
Importancia de la Indentación:
- Define la estructura del código: La indentación no es solo para legibilidad; es parte de la sintaxis de Python. El intérprete de Python utiliza la indentación para determinar qué líneas de código pertenecen a qué bloque de control (como `if`, `else`, `for`, `while`, `def`, `class`, etc.).
- Mejora la legibilidad: Un código correctamente indentado es mucho más fácil de leer y entender, ya que la estructura lógica del programa se visualiza claramente.
- Evita ambigüedades: Al no depender de símbolos como llaves, la indentación fuerza una estructura visual clara y evita posibles ambigüedades en la interpretación del código.
Reglas de Indentación:
- Bloques después de dos puntos: Después de una sentencia que introduce un bloque de código (como `if`, `else`, `for`, `while`, `def`, `class`), la siguiente línea y las que le sigan deben estar indentadas.
- Indentación consistente: Todas las líneas dentro del mismo bloque deben tener el mismo nivel de indentación. Mezclar espacios y tabulaciones puede llevar a errores. Se recomienda usar siempre cuatro espacios.
- Fin del bloque: Un bloque de código termina cuando la indentación vuelve al nivel del inicio del bloque.
Ejemplos de Indentación Correcta e Incorrecta:
# Indentación correcta
if 5 > 2:
print("Cinco es mayor que dos") # Esta línea está indentada y pertenece al bloque if
valor = 10 # Esta línea también pertenece al bloque if
# Indentación incorrecta (causará un IndentationError)
# if 5 > 2:
# print("Cinco es mayor que dos") # Error: línea inesperadamente no indentada
# valor = 10 # Error: indentación inconsistente
# Bloques anidados
if edad >= 18:
print("Eres mayor de edad.")
if tiene_licencia:
print("Puedes conducir.") # Esta línea está doblemente indentada
else:
print("Necesitas una licencia para conducir.") # Esta línea también está doblemente indentada
else:
print("Aún no puedes votar ni conducir.") # Esta línea está al mismo nivel que el primer if
Dominar la indentación es fundamental para escribir código Python válido y legible. Presta mucha atención a los espacios en blanco al estructurar tus programas.
Elif
🪜 Elif: Múltiples Condiciones en Cadena
La palabra clave elif en Python es una abreviatura de "else if". Se utiliza para verificar múltiples condiciones en secuencia. Si la condición del `if` es falsa, el intérprete evalúa las condiciones de los bloques `elif` en orden. El bloque de código asociado con la primera condición `elif` que sea verdadera se ejecuta.
Puedes tener múltiples bloques `elif` después de un `if` inicial.
Sintaxis de `if ... elif ... else`:
if condicion1:
# Bloque de código a ejecutar si la condición1 es True
instrucciones_if
elif condicion2:
# Bloque de código a ejecutar si la condición1 es False y la condición2 es True
instrucciones_elif_1
elif condicion3:
# Bloque de código a ejecutar si la condición1 y condición2 son False y la condición3 es True
instrucciones_elif_2
else:
# Bloque de código a ejecutar si todas las condiciones anteriores son False
instrucciones_else
El bloque `else` al final es opcional. Si se incluye, se ejecutará si ninguna de las condiciones `if` o `elif` anteriores es verdadera.
Flujo de Ejecución con `elif`:
- Se evalúa la `condicion1` del `if`. Si es `True`, se ejecuta el bloque de código del `if` y se salta el resto de la estructura (`elif` y `else`).
- Si la `condicion1` es `False`, se evalúa la `condicion2` del primer `elif`. Si es `True`, se ejecuta su bloque de código y se salta el resto.
- Este proceso continúa para cada bloque `elif`.
- Si ninguna de las condiciones (`if` o `elif`) es `True`, y hay un bloque `else`, se ejecuta el código dentro del `else`.
- Si ninguna condición es `True` y no hay un bloque `else`, no se ejecuta ningún bloque adicional.
Ejemplo de Uso de `elif`:
puntuacion = 75
if puntuacion >= 90:
print("¡Excelente! Obtuviste una A.")
elif puntuacion >= 80:
print("Muy bien, obtuviste una B.")
elif puntuacion >= 70:
print("Bien, obtuviste una C.") # Output: Bien, obtuviste una C.
elif puntuacion >= 60:
print("Aprobado, obtuviste una D.")
else:
print("Necesitas mejorar, obtuviste una F.")
dia_de_la_semana = "Martes"
if dia_de_la_semana == "Lunes":
print("¡Comienza la semana!")
elif dia_de_la_semana == "Viernes":
print("¡Por fin es viernes!")
elif dia_de_la_semana == "Sábado" or dia_de_la_semana == "Domingo":
print("¡Es fin de semana!")
else:
print("Es un día laborable.") # Output: Es un día laborable.
La estructura `if ... elif ... else` es fundamental para implementar lógica de decisión más compleja en tus programas, permitiendo manejar diferentes casos de manera organizada y eficiente.
Else
➡️ Else: El Camino Alternativo
La palabra clave else se utiliza al final de una estructura condicional `if` o `if ... elif ...`. Define un bloque de código que se ejecutará si ninguna de las condiciones previas (`if` o `elif`) ha sido verdadera.
Un bloque `else` es opcional y solo puede haber uno al final de una estructura condicional.
Sintaxis de `else`:
if condicion:
# Bloque de código si la condición es True
instrucciones_if
else:
# Bloque de código si la condición es False
instrucciones_else
if condicion1:
# Bloque de código si la condición1 es True
instrucciones_if
elif condicion2:
# Bloque de código si la condición1 es False y la condición2 es True
instrucciones_elif
else:
# Bloque de código si ambas condiciones (condicion1 y condicion2) son False
instrucciones_else
Cuándo Usar `else`:
Utiliza el bloque `else` cuando quieras especificar una acción por defecto que se debe realizar si ninguna de las condiciones anteriores se cumple. Es útil para cubrir todos los casos posibles en tu lógica condicional.
Ejemplos de Uso de `else`:
numero = -5
if numero > 0:
print("El número es positivo.")
else:
print("El número no es positivo (es cero o negativo).") # Output: El número no es positivo (es cero o negativo).
usuario_conectado = False
if usuario_conectado:
print("Bienvenido, usuario.")
else:
print("Por favor, inicia sesión.") # Output: Por favor, inicia sesión.
nivel_bateria = 25
if nivel_bateria > 50:
print("Batería alta.")
elif nivel_bateria > 20:
print("Batería media.")
else:
print("Batería baja. ¡Carga tu dispositivo!") # Output: Batería baja. ¡Carga tu dispositivo!
El bloque `else` proporciona una manera clara y concisa de definir el comportamiento predeterminado cuando ninguna de las condiciones específicas se cumple, haciendo que tu código sea más robusto y fácil de entender.
Short Hand If
✍️ Short Hand If: Sentencias `if` en una Sola Línea
Cuando solo tienes una instrucción para ejecutar dentro de un bloque `if`, puedes escribir toda la sentencia en una sola línea. Esta es una forma de "taquigrafía" para hacer tu código más conciso en ciertos casos.
Sintaxis de Short Hand If:
if condicion: instruccion
Aquí, si la `condicion` es verdadera, se ejecutará la `instruccion`. Si la condición es falsa, no se hará nada.
Ejemplos de Short Hand If:
edad = 20
if edad > 18: print("Es adulto") # Output: Es adulto
temperatura = 18
if temperatura < 20: print("Está fresco") # Output: Está fresco
es_soleado = True
if es_soleado: print("¡Qué buen día!") # Output: ¡Qué buen día!
Consideraciones al Usar Short Hand If:
- Legibilidad: Si bien puede hacer que el código sea más corto, usarlo en exceso o para instrucciones complejas puede dificultar la lectura. Úsalo con moderación y para instrucciones sencillas.
- Solo una instrucción: La sintaxis de short hand `if` está diseñada para ejecutar una sola instrucción. Si necesitas ejecutar múltiples instrucciones basadas en una condición, es mejor usar la estructura `if` con indentación en múltiples líneas.
El short hand `if` puede ser útil para simplificar tu código en situaciones donde la lógica condicional es simple y directa.
Short Hand If ... Else
⚡ Short Hand If ... Else: Condicionales en una Línea con Alternativa
Similar al short hand `if`, puedes escribir una sentencia `if ... else` completa en una sola línea cuando las instrucciones para ambos casos (verdadero y falso) son simples.
Sintaxis de Short Hand If ... Else:
instruccion_si_verdadero if condicion else instruccion_si_falso
Aquí, primero se evalúa la `condicion`. Si es verdadera, se ejecuta `instruccion_si_verdadero`. Si es falsa, se ejecuta `instruccion_si_falso`.
Ejemplos de Short Hand If ... Else:
edad = 17
mensaje = "Es adulto" if edad >= 18 else "No es adulto"
print(mensaje) # Output: No es adulto
numero = 6
tipo = "Par" if numero % 2 == 0 else "Impar"
print(tipo) # Output: Par
llueve = False
estado = "Quedarse en casa" if llueve else "Salir a pasear"
print(estado) # Output: Salir a pasear
Consideraciones al Usar Short Hand If ... Else:
- Legibilidad: Al igual que con el short hand `if`, la legibilidad puede verse comprometida si las instrucciones o la condición son demasiado complejas. Utilízalo para casos sencillos.
- Una instrucción por caso: Esta sintaxis está diseñada para ejecutar una sola instrucción para el caso verdadero y una sola para el caso falso. Para bloques de código más extensos, es preferible la estructura `if ... else` en múltiples líneas.
- Expresiones, no sentencias completas: Ten en cuenta que lo que va antes y después del `if` y el `else` deben ser expresiones que devuelvan un valor, no sentencias completas (como otra sentencia `if` anidada de forma compleja).
El short hand `if ... else` puede hacer que tu código sea más compacto y expresivo para condicionales simples con una alternativa clara.
And
🔗 And: Combinando Condiciones con Lógica "Y"
El operador lógico and se utiliza para evaluar si ambas condiciones que conecta son verdaderas. La expresión que utiliza el operador and será `True` solo si las dos condiciones a su izquierda y a su derecha son verdaderas. Si una o ambas condiciones son falsas, la expresión completa será `False`.
Sintaxis con `and`:
if condicion1 and condicion2:
# Bloque de código a ejecutar si tanto condicion1 como condicion2 son True
instrucciones
Tabla de Verdad del Operador `and`:
| Condición 1 | Condición 2 | Condición 1 and Condición 2 |
|---|---|---|
| True | True | True |
| True | False | False |
| False | True | False |
| False | False | False |
Ejemplos de Uso de `and`:
edad = 25
tiene_licencia = True
if edad >= 18 and tiene_licencia:
print("Puedes votar y conducir.") # Output: Puedes votar y conducir.
es_fin_de_semana = True
esta_soleado = True
if es_fin_de_semana and esta_soleado:
print("¡Es un día perfecto para ir a la playa!") # Output: ¡Es un día perfecto para ir a la playa!
nivel_bateria = 80
tiene_wifi = True
if nivel_bateria > 50 and tiene_wifi:
print("Puedes ver videos en línea.") # Output: Puedes ver videos en línea.
x = 7
if x > 5 and x < 10:
print("x está entre 6 y 9.") # Output: x está entre 6 y 9.
El operador and es esencial cuando necesitas que se cumplan múltiples condiciones simultáneamente para ejecutar un cierto bloque de código. Te permite crear lógica condicional más precisa y compleja.
Or
✨ Or: Combinando Condiciones con Lógica "O"
El operador lógico or se utiliza para evaluar si al menos una de las condiciones que conecta es verdadera. La expresión que utiliza el operador or será `True` si cualquiera de las condiciones a su izquierda o a su derecha (o ambas) es verdadera. Solo será `False` si ambas condiciones son falsas.
Sintaxis con `or`:
if condicion1 or condicion2:
# Bloque de código a ejecutar si al menos una de las condiciones es True
instrucciones
Tabla de Verdad del Operador `or`:
| Condición 1 | Condición 2 | Condición 1 or Condición 2 |
|---|---|---|
| True | True | True |
| True | False | True |
| False | True | True |
| False | False | False |
Ejemplos de Uso de `or`:
es_fin_de_semana = True
esta_lloviendo = False
if es_fin_de_semana or esta_lloviendo:
print("Puedes relajarte en casa o salir si no llueve.") # Output: Puedes relajarte en casa o salir si no llueve.
tiene_descuento = True
es_miembro_premium = False
if tiene_descuento or es_miembro_premium:
print("¡Calificas para un beneficio especial!") # Output: ¡Calificas para un beneficio especial!
x = 3
if x < 0 or x > 10:
print("x está fuera del rango de 0 a 10.") # Output: x está fuera del rango de 0 a 10.
usuario_logueado = False
tiene_permisos = True
if usuario_logueado or tiene_permisos:
print("Acceso concedido.") # Output: Acceso concedido.
El operador or es muy útil cuando necesitas que se cumpla al menos una de varias condiciones para ejecutar un bloque de código. Amplía las posibilidades de tu lógica condicional.
Not
🚫 Not: Negando una Condición
El operador lógico not se utiliza para invertir el valor de una condición. Si una condición es `True`, al aplicarle el operador not se convierte en `False`, y si es `False`, se convierte en `True`.
El operador not se coloca delante de la condición que se quiere negar.
Sintaxis con `not`:
if not condicion:
# Bloque de código a ejecutar si la condición es False
instrucciones
Tabla de Verdad del Operador `not`:
| Condición | not Condición |
|---|---|
| True | False |
| False | True |
Ejemplos de Uso de `not`:
esta_lloviendo = False
if not esta_lloviendo:
print("¡Hoy no llueve!") # Output: ¡Hoy no llueve!
usuario_logueado = False
if not usuario_logueado:
print("Por favor, inicia sesión para continuar.") # Output: Por favor, inicia sesión para continuar.
nivel_bateria_bajo = True
if not nivel_bateria_bajo:
print("La batería está bien.")
else:
print("¡Necesitas cargar tu dispositivo!") # Output: ¡Necesitas cargar tu dispositivo!
numero = 7
es_par = numero % 2 == 0
if not es_par:
print(f"{numero} no es un número par.") # Output: 7 no es un número par.
El operador not es útil para expresar condiciones de forma negativa, lo que a veces puede hacer que la lógica de tu código sea más clara y concisa.
Nested If
🧱 Nested If: Sentencias Condicionales Anidadas
Una sentencia `if` anidada es una sentencia `if` que se coloca dentro del bloque de código de otra sentencia `if` (o `elif` o `else`). Esto te permite verificar múltiples condiciones de manera jerárquica, donde la segunda condición solo se evalúa si la primera condición es verdadera.
Sintaxis de Nested If:
if condicion1:
# Bloque de código si la condicion1 es True
instrucciones_externas
if condicion2:
# Bloque de código si la condicion1 es True Y la condicion2 es True
instrucciones_internas
# ... más código dentro del primer if
elif otra_condicion:
# ...
else:
if otra_condicion_anidada:
# ...
Es importante mantener la indentación correcta para que el intérprete de Python pueda determinar a qué bloque pertenece cada sentencia `if`.
Ejemplos de Uso de Nested If:
edad = 22
tiene_licencia = True
tiene_coche = True
if edad >= 18:
print("Eres mayor de edad.")
if tiene_licencia:
print("Tienes licencia de conducir.")
if tiene_coche:
print("¡Puedes ir donde quieras!") # Output: ¡Puedes ir donde quieras!
else:
print("Pero no tienes coche.")
else:
print("Pero no tienes licencia de conducir.")
else:
print("Aún no eres mayor de edad.")
nivel_bateria = 60
tiene_internet = True
if nivel_bateria > 50:
print("Batería suficiente.")
if tiene_internet:
print("Tienes conexión a internet.")
print("Puedes navegar y ver videos.") # Output: Puedes navegar y ver videos.
else:
print("Pero no tienes internet.")
else:
print("Batería baja.")
Consideraciones al Usar Nested If:
- Legibilidad: Anidar demasiadas sentencias `if` puede hacer que el código sea difícil de leer y entender. En algunos casos, puede ser mejor usar operadores lógicos (`and`, `or`) para combinar condiciones.
- Complejidad: A medida que aumenta el nivel de anidación, la complejidad lógica del código también se incrementa, lo que puede llevar a errores más difíciles de depurar.
- Alternativas: A menudo, se pueden simplificar las estructuras anidadas utilizando `elif` o combinando condiciones con operadores lógicos.
Las sentencias `if` anidadas son una herramienta poderosa para manejar escenarios con múltiples niveles de condiciones, pero deben usarse con cuidado para mantener la claridad y la legibilidad del código.
The pass Statement
🤫 The pass Statement: No Hacer Nada
En Python, a veces necesitas tener un bloque de código sintácticamente correcto pero que no ejecute ninguna instrucción. Para estos casos, se utiliza la sentencia pass. Es una operación nula; cuando se ejecuta, no sucede nada.
Cuándo Usar `pass`:
- Bloques de código vacíos: Python requiere que los bloques de código después de ciertas sentencias (como `if`, `elif`, `else`, `for`, `while`, `def`, `class`) estén indentados y contengan al menos una instrucción. Si por alguna razón necesitas un bloque vacío, puedes usar `pass` para evitar un error de sintaxis.
- Marcadores de posición (placeholders): Puedes usar `pass` como un marcador de posición para código que planeas escribir más tarde. Esto te permite estructurar tu programa sin tener que implementar todos los detalles de inmediato.
- Clases o funciones mínimas: A veces, necesitas definir una clase o una función sin ninguna funcionalidad por el momento. En estos casos, puedes usar `pass` dentro de su cuerpo.
Ejemplos de Uso de `pass`:
edad = 15
if edad < 18:
pass # No hacer nada si la edad es menor de 18
else:
print("Eres mayor de edad.")
def mi_funcion_pendiente():
pass # Implementación futura
class MiClaseBase:
pass # Sin funcionalidad por ahora
for i in range(10):
if i % 2 == 0:
# Procesamiento de números pares (se implementará después)
pass
else:
print(f"{i} es impar.") # Output: 1 es impar. 3 es impar. 5 es impar. 7 es impar. 9 es impar.
La sentencia pass es una herramienta simple pero útil para manejar situaciones donde se requiere sintácticamente un bloque de código, pero no se necesita ninguna acción en ese momento.
0 Comentarios
Si desea contactar comigo, lo puede hacer atravez deste formulario gracias