Comprender y usar la función if else en Python

La función if else en Python (en español: “en caso (contrario) de”) es una función condicional y, por lo tanto, una estructura de control fundamental. El uso de un condicionante permite diferentes opciones en función de la situación que se encuentre en el momento de ejecución del código. Te explicamos cómo funciona y cómo se utiliza la función if else en Python.

Certificados SSL con IONOS

Protege tu dominio y consigue la confianza de tus clientes con una página web con encriptación SSL.

Activación fácil
Seguridad máxima
Asistencia 24/7

¿Qué es una sentencia if else?

La sentencia if else es una función condicional. Puedes imaginártela como una especie de interruptor: dependiendo de la condición que se cumpla, se activa (solamente) una parte del código. Python es un lenguaje interpretado; el intérprete lee las líneas del código fuente de arriba a abajo. En el caso más simple da lugar a un flujo estrictamente lineal del programa: todas las líneas se leen, interpretan y ejecutan una tras otra.

Sin embargo, siguiendo este sencillo modelo no se pueden desarrollar programas complejos. Solo con estructuras de control se puede conseguir la versatilidad que requiere el código en su aplicación práctica. Al cumplirse una condición, esta permite ejecutar una parte concreta del código. Otras estructuras de control comunes son los bucles de Python y los bucles while de Python; ambos permiten ejecutar partes de código repetidamente.

Consejo

Aprende a escribir en Python con nuestro tutorial de Python.

¿Cómo funciona la función if else en Python?

En general, la sentencia if else en Python se comporta de forma similar a como lo hace en otros lenguajes. Sin embargo, Python tiene algunas peculiaridades específicas. A continuación, se explica cómo funciona la sentencia if else en Python con detalle y cómo se comporta en comparación con otros lenguajes.

Sintaxis general de la sentencia if else en Python

La sintaxis general de la función if else en Python se puede expresar directamente en el propio código de Python. Se define una condición y en el cuerpo de la sentencia if se concreta una llamada a una función como ruta de código a seguir si la condición se hace cierta. Además, en el cuerpo else, se define una ruta de código a seguir en caso contrario:

if condition:
    if_body()
else:
    else_body()

La condición definida puede bien ser verdadera (True) o falsa (False). Es posible mostrar el modelo introduciendo directamente el valor True o False como condición. El resultado es un programa de flujo estático en el que se garantiza que solo uno de los dos caminos se pueda seguir:

if False:
    # este código nunca se ejecutará
    if_body()
else:
    else_body()
if True:
    if_body()
else:
    # este código nunca se ejecutará
    else_body()

Por supuesto, este código no es práctico, pero sirve a modo de ejemplo. En lugar de un valor estático verdadero/falso, se utiliza una expresión como condición. La expresión se evalúa en tiempo real durante la ejecución del programa. Se dice que la expresión es “evaluada” y, al evaluar la expresión, se obtiene un valor de veracidad. En función de si el valor obtenido es True o False, el programa deriva en una dirección u otra.

Es importante entender que el apartado else es opcional. El código dentro del cuerpo else solo se ejecuta si la condición no se cumple. Sin embargo, no es absolutamente necesario. Muchas veces basta con una sentencia if individual:

if condition:
    if_body()

Un pequeño apunte sobre la nomenclatura: hemos utilizado los términos “sentencia” y “expresión” sin explicarlos. Es importante entender lo que significan estos términos. Estos dos términos básicos se utilizan en todos los lenguajes de programación. A continuación, un resumen del significado de los términos:

Término Equivalencia en inglés Explicación
Sentencia Statement Acción a ejecutar; suele influir en el desarrollo del programa
Expresión Expression Término que retorna un valor al ser evaluado

Realiza una consulta múltiple de condiciones excluyentes con la sentencia elif en Python

En relación con la conocida función if else, Python también dispone de la función elif. Una sentencia if se puede seguir de varias sentencias elif y opcionalmente de una sentencia else. Una sentencia elif solo se ejecuta si ninguna de las otras condiciones se cumple. Esto garantiza que solamente se pueda seguir una única ruta de código definida:

if condition:
    if_body()
elif other_condition:
    elif_body()
elif another_condition:
    another_elif_body()
else:
    else_body()

Estas son las reglas para crear una sentencia condicional encadenada if elif else:

Sentencias condicionales Cantidad de combinaciones
if Solamente una
elif Entre ninguna y varias
else Una o ninguna

¿Cómo se utiliza if else en Python?

La función if else es una función básica tanto en Python como en otros lenguajes. Como es natural, tiene una gran variedad de usos. Te vamos a mostrar los ejemplos más comunes, incluyendo buenas prácticas y antipatrones.

Uso correcto de la condición if en Python

En primer lugar, hay que ver cómo funciona una sentencia condicional. La condición se interpreta como una expresión booleana que se evalúa como verdadera o falsa. Por lo tanto, no es necesario comprobar de forma explícita si es igual a otro valor booleano:

if expression == True:
    ...

Aunque igualar el valor booleano a True no es un error como tal, el código parece poco profesional. En su lugar, los programadores más experimentados lo redactan de la siguiente manera:

if expression:
    ...

A continuación, una sentencia equivalente con otro ejemplo. La función is_odd() devuelve el valor True si evalúa un número que resulta ser impar. De lo contrario, la función is_odd devuelve el valor False. Se usa la función dentro del cuerpo de una sentencia if y se emite la frase correspondiente:

if is_odd(number) == True:
    print("The number is odd.")

¿Qué ocurriría si el código analiza un número impar? En primer lugar, la sentencia 'is_odd(number) == True' se convierte en 'True == True'. Al cumplirse la igualdad, el código ejecuta el cuerpo de la sentencia if. Tiene más sentido utilizar el valor booleano devuelto por la función is_odd directamente como condición:

if is_odd(number):
    print("The number is odd.")

Ejecutar código opcional con la sentencia if en Python

Se presenta la siguiente situación: se cuenta con un bloque de código con una función determinada. Las líneas de código se ejecutan una tras otra. Sin embargo, una parte del código no debe ejecutarse siempre, sino solamente cuando se cumpla una condición. Para implementar esta condición, solo es necesaria una sentencia if. Se presenta un ejemplo de registro de usuarios:

def register_user(user_data, do_newsletter_signup = False):
    # create user account
    user_account = create_account(user_data)
    # sign up for newsletter — only if requested by user
    if do_newsletter_signup:
        signup_newsletter(user_account)
    # send confirmation mail
    send_confirmation_mail(user_account)

Distinguir dos condiciones diferentes con la función if else en Python

Los programas suelen tener que distinguir entre dos casos mutuamente excluyentes. Si es evidente que no puede haber ningún otro caso, tiene sentido utilizar una sentencia if else. Por ejemplo, se comprueba si una persona ha alcanzado una determinada edad y se emite un resultado adecuado para cada caso:

def is_of_age(person, age_limit = 18):
    if person.age >= age_limit:
        print("You're old enough")
    else:
        print("Sorry, wait some more")

Distinguir varios casos excluyentes con sentencias elif en Python

Si hay más de dos casos mutuamente excluyentes entre los que queremos distinguir, podemos utilizar sentencias elif encadenadas. Se utiliza una última sentencia else si no se cumple ninguna condición de las establecidas previamente. Es posible asignar nombres de países a sus códigos correspondientes:

def get_country_from_code(country_code):
    if country_code == 'DE':
        country = "Deutschland"
    elif country_code == 'ES':
        country = "España"
    elif country_code == 'FR':
        country = "France"
    elif country_code == 'GB':
        country = "Great Britain"
    elif country_code == 'IT':
        country = "Italia"
    else:
        country = None
    return country

La cadena elif siempre debe estar dentro de una función, aunque a veces es mejor utilizar varias sentencias if independientes. De esta manera es posible ahorrarse el designarla en el cuerpo de elif. Con la sentencia return se sale de la función si se cumple alguna de las condiciones establecidas. En lugar de la sentencia else final, se utiliza una sentencia return que solo se alcanza si ninguna de las condiciones previas se cumple:

def get_country_from_code(country_code):
    if country_code == 'DE':
        return "Deutschland"
    if country_code == 'ES':
        return "España"
    if country_code == 'FR':
        return "France"
    if country_code == 'GB':
        return "Great Britain"
    if country_code == 'IT':
        return "Italia"
    return None

Las sentencias elif encadenadas son un patrón bien conocido de los lenguajes más clásicos. En Python, suele ser más directo utilizar un “Dictionary lookup”. Se asigna directamente cada código a su país correspondiente, para luego extraer el nombre del país en función del código evaluado. En lugar del último else se utiliza la función get que, como segundo parámetro, toma un valor por defecto:

def get_country_from_code(country_code):
    countries = {
        'DE': "Deutschland",
        'ES': "España",
        'FR': "France",
        'GB': "Great Britain",
        'IT': "Italia",
    }
    country = countries.get(country_code, None)
    return country

Usar la función if en Python para comprobar si un objeto contiene datos

Python es un lenguaje dinámico y muy ligero. En lugar de variables, los diferentes tipos de datos están vinculados a valores. Dependiendo del uso, pueden producirse conversiones involuntarias entre los diferentes tipos de datos. Dentro del contexto de las expresiones booleanas, también se habla de verdadero y falso como una extensión de los valores “truthy” y “falsy”.

Esto significa que la condición de una sentencia if en Python no tiene que evaluarse de forma explícita como True o False. Más bien, se pueden utilizar otros tipos de datos como condiciones, los cuales se interpretarán como valores booleanos según ciertas reglas.

Cita

”Any object can be tested for truth value, for use in an if or while condition or as operand of the Boolean operations […]

[...] An object is considered true unless its class defines either a __bool__() method that returns False or a __len__() method that returns zero [...]” – Fuente: https://docs.python.org/3/library/stdtypes.html#truth-value-testing

Traducción: “Cualquier objeto puede ser evaluado para determinar si este es verdadero, para utilizarlo en una condición if o while o como operador de las operaciones booleanas [...]

[...] Un objeto se considera verdadero a menos que su clase defina un método __bool__() que retorne un valor False o un método __len__() que retorne un cero [...]” (traducido por IONOS)

Se usa este patrón para comprobar si un objeto contiene datos. Como a continuación el texto está vacío, se emite el mensaje correspondiente:

text = ''
if not text:
    print("No text given")

Los siguientes objetos se evalúan como False en un contexto booleano y, por tanto, se denominan “falsy”:

Objeto Explicación
False, None Constantes que son falsas según la definición
0, 0.0, Decimal(0), Fraction(0, 1), etc. Número que representa el cero
'', (), [], {}, set(), range(0), etc. Secuencia o colección vacía

Otro ejemplo con una lista vacía:

books_in_library = []
if not books_in_library:
    print("Library is empty")

Todos los demás objetos se evalúan como True:

number = 42
if number:
    print("Number exists")

Implementar un interruptor binario if else en Python

Una sentencia if else también se utiliza para alternar entre dos condiciones mutuamente excluyentes. El principio es similar al de un interruptor de luz, se le llama “toggle” en inglés. Se define una función que conmuta el estado de una bombilla:

def toggle_light(light):
    if light == 'on':
        return 'off'
    else:
        return 'on'

Quizás ya te has dado cuenta de que se puede hacer de manera aún más fácil. Si el estado no se representa como un string, sino como un valor booleano, es buena idea prescindir de la sentencia if por completo. En su lugar, utilizamos el operador lógico NOT para invertir el valor booleano:

def toggle(boolean):
    return not boolean

Utilizar Early Return para resolver sentencias if anidadas en Python

En la práctica, es habitual ejecutar un determinado código cuando varias condiciones se cumplen al mismo tiempo. Esto lleva a los programadores inexpertos a anidar sentencias if. Sin embargo, se trata de un mal método, y se debe a que las sentencias condicionales entrelazadas son difíciles de seguir y de manipular.

Un ejemplo: se escribe una función que retorna una afirmación sobre si una persona tiene derecho a votar. Primero se comprueba si la persona tiene un documento de identidad. A continuación, se comprueba si la persona ya ha alcanzado la mayoría de edad para votar. Una primera implementación de la función contiene declaraciones if anidadas:

def person_may_vote(person, voting_age = 18):
    if person.has_id():
        if person.get_age() >= voting_age:
            return True

El mayor problema que muestra este sistema es que la parte más importante de este código es también la parte más integrada. Para sustituir las sentencias if anidadas, lo mejor es utilizar el “Early Return”. Al principio de la función se comprueba si se cumplen las condiciones correspondientes. Si alguna de las condiciones no se cumple, se sale de la función mediante la sentencia return.

A continuación se rescribe el código con Early Returns. A menudo, esto obliga a revertir o negar las condiciones previamente definidas. En este caso es útil conocer los operadores booleanos en Python. Si no se cumple ninguna de las condiciones negadas, se ejecuta el código verdaderamente de interés:

def person_may_vote(person, voting_age = 18):
    if not person.has_id():
        return False
    if person.age < voting_age:
        return False
    # if we made it here, the person may vote
    return True

Simplificar y sustituir las sentencias if de Python con operadores lógicos

Como ya se ha visto, a menudo es necesario que se cumplan varias condiciones. Suele ser poco óptimo utilizar sentencias if anidadas entre sí para establecer múltiples condiciones. A continuación, se presenta un ejemplo de un código poco optimizado para determinar si una persona puede votar:

if has_id(person):
    if is_adult(person):
        print("You may vote")

Las condiciones encadenadas pueden representarse de forma más atractiva mediante operadores lógicos. Dado que se quiere comprobar si ambas condiciones se aplican al mismo tiempo, se utiliza el operador lógico AND. De esta forma, solo es necesaria una sentencia if:

if has_id(person) and is_adult(person):
    print("You may vote")

A continuación, se presenta un listado de los operadores lógicos más importantes en Python:

Operador lógico Significado Sintaxis en Python Otros idiomas    
Y La expresión es verdadera si todos los operandos son verdaderos; retorna el último operando evaluado. and &&    
O La expresión es verdadera si al menos uno de los operandos es verdadero; retorna el último operando evaluado. or      
NO Invierte el valor de la expresión. not !    

Además de vincular los diferentes operandos en las condiciones, los operadores lógicos se utilizan para sustituir ciertas sentencias if. Esta es la configuración de los valores por defecto.

Se presenta un ejemplo: un usuario puede especificar una divisa para realizar un cálculo financiero. Por facilidad de uso, la elección debería ser opcional. Si el usuario no selecciona una moneda, se utilizará el euro como valor predeterminado. Se presenta este ejemplo en el código visto a continuación:

# user made no currency choice
currency = None
...
# further down in the program flow
if not currency:
    # set default if value missing
    currency = 'EUR'

Utilizando el operador lógico OR, se puede prescindir de la sentencia if. Reescribimos el código; cuando se ejecuta, la variable de la divisa contiene el valor 'EUR':

# user made no currency choice
currency = None
...
# further down in the program flow
# set default if value missing
currency = currency or 'EUR'

¿Qué ocurre aquí exactamente? En la última línea, se asigna un nuevo valor a la variable 'currency'. Para ello, se evalúa en primer lugar la expresión 'currency or 'EUR'' situada a la derecha del signo igual. El operador lógico OR evalúa primero la expresión de la izquierda, en este caso 'currency'. Dado que en el ejemplo contiene 'None' y, por tanto, es “falsy”, se evalúa la expresión correcta 'EUR' y se utiliza como valor de retorno para asignar la divisa.

El operador condicional if else en Python

Además de las sentencias condicionales, las palabras if else tienen otra utilidad en Python. Se trata del operador condicional, también conocido como operador “ternario”. El operador condicional se utiliza habitualmente a la hora de distinguir entre dos posibles valores a asignar.

En primer lugar, se presenta un ejemplo utilizando la sentencia if else en Python. En función del sistema de medición seleccionado, el código que se muestra a continuación define la unidad a utilizar (Celsius o Fahrenheit) para la medición de la temperatura:

if system == 'metric':
    unit = 'C'
else:
    unit = 'F'

Si se utiliza el operador condicional, es posible simplificar el código a una única sentencia:

unit = 'C' if system == 'metric' else 'F'

Como su nombre expresa, el operador ternario requiere tres operandos: los dos valores posibles y una expresión como condición.

Operador Aridad Explicación Ejemplo
Unario El operador requiere un operando. not boolean_operand
Binario El operador requiere dos operandos. left_operand + right_operand
Ternario El operador requiere tres operandos. some_value if condition else other_value

Sustituir if else en Python por la sentencia match case

Con el lanzamiento de la versión 3.10 de Python, se introdujo la sentencia match case. A primera vista, esta se parece a la sentencia switch case de otros lenguajes. En ellos se utiliza switch case para sustituir las grandes estructuras if elif else.

Conocido por ser propenso a generar errores, switch case jamás ha llegado a existir en Python. Más bien, la función match case en Python realiza el “Structural Pattern Matching” basado en lenguajes funcionales como Haskell. Su utilidad va mucho más allá de la de switch case.

A continuación, se muestra el principio de match case con un ejemplo: podemos imaginar que queremos procesar datos de diferentes maneras. Una persona se puede representar simplemente con su nombre o por un dictionary que contenga su nombre y, si procede, su edad, o como una tupla con su nombre y apellidos. Además, se quiere considerar el nombre concreto “Jack” especial:

# the name 'Jack'
person1 = 'Jack'
# just a name
person2 = 'John'
# name and age in a dict
person3 = {'name': 'Jim', 'age': 42}
# name in a dict, but no age
person4 = {'name': 'Walter', 'email': 'walter.white@example.com'}
# tuple of first and last name
person5 = ('Walther', 'White')

Primero, se presenta una función que da la bienvenida a una persona de una forma concreta. Se recurre a una cadena if elif else y a la función isinstance para distinguir entre los diferentes formatos. Además, se utilizan condiciones encadenadas con el operador AND y una sentencia if else anidada. El resultado final del código no parece especialmente limpio:

def greet_person(person):
    if isinstance(person, str):
        if person == 'Jack':
            print('Jack himself has arrived')
        else:
            print(f"Hi there, {person}")
    elif isinstance(person, dict) and 'name' in person and 'age' in person:
        print(f"It's, {person['name']}. Born {person['age']} years ago")
    elif isinstance(person, dict) and 'name' in person:
        print(f"It's {person['name']}")
    elif isinstance(person, tuple) and len(person) == 2:
        first, last = person
        print(f"Hello, {first} {last}")
    else:
        print('Not sure what kind of person this is')

El código se puede estructurar de forma más sencilla con la función match case. Se redacta la estructura de los formatos individuales de forma directa; los valores individuales pueden extraerse como variables. El código es más claro, menos complejo y más fácil de leer:

def match_person(person):
    match person:
        case 'Jack':
            print('Jack himself has arrived')
        case str() as name:
            print(f"Hi there, {name}")
        case {'name': name, 'age': age}:
            print(f"It's, {name}. Born {age} years ago")
        case {'name': name}:
            print(f"It's {name}")
        case (first, last):
            print(f"Hello, {first} {last}")
        case _:
            print('Not sure what kind of person this is')