Blog

Los condicionales son una parte fundamental de la programación que nos permite controlar el flujo de ejecución de un programa. En Python se utilizan principalmente tres tipos de condicionales: if, elif (opcional) y else. A continuación mostraremos cómo utilizarlos con ejemplos para comprender mejor su funcionamiento.

Condicionales «if»

El condicional if se utiliza para ejecutar un bloque de código solo si una condición es verdadera. En el siguiente ejemplo, si la variable edad es mayor o igual a 18, se imprimirá «Eres mayor de edad.»:

edad = 18

if edad >= 18:
    print("Eres mayor de edad.")

Condicionales «if» y «else»

El condicional else se utiliza para ejecutar un bloque de código cuando la condición del if es falsa. En el siguiente ejemplo, si la variable edad es mayor o igual a 18, se imprimirá «Eres mayor de edad.», y en caso contrario, se imprimirá «Eres menor de edad.»:

edad = 15

if edad >= 18:
    print("Eres mayor de edad.")
else:
    print("Eres menor de edad.")

Condicionales «if», «elif» y «else»

El condicional elif (abreviatura de «else if») se utiliza para evaluar múltiples condiciones. Se verifica solo si la condición del if anterior es falsa. En el siguiente ejemplo, el programa evalúa la variable calificacion y muestra diferentes mensajes dependiendo del rango en el que se encuentre:

calificacion = 85

if calificacion >= 90:
    print("Tienes una A.")
elif calificacion >= 80:
    print("Tienes una B.")
elif calificacion >= 70:
    print("Tienes una C.")
else:
    print("Tienes una calificación inferior a C.")

Uso de operadores lógicos en condicionales

Podemos combinar múltiples condiciones utilizando los operadores lógicos and (y), or (o) y not (no). En el siguiente ejemplo se evalúa tanto la temperatura como si es un día soleado o no, utilizando el operador and. Si ambas condiciones son verdaderas, se imprimirá «Hace calor y es un día soleado.» Si al menos una de las condiciones es verdadera (usando el operador or), se imprimirá «Hace calor o es un día soleado.» De lo contrario, se imprimirá «No hace calor y no es un día soleado.»:

temperatura = 25
dia_soleado = True

if temperatura > 30 and dia_soleado:
    print("Hace calor y es un día soleado.")
elif temperatura > 30 or dia_soleado:
    print("Hace calor o es un día soleado.")
else:
    print("No hace calor y no es un día soleado.")

Condicionales anidados

Se pueden anidar condicionales dentro de otros condicionales para manejar situaciones más complejas. En el siguiente ejemplo, se verifica primero si la persona es mayor o igual a 18 años. Si es así, se verifica si tiene carnet de conducir para determinar si puede conducir o no:

edad = 25
carnet_conducir = True

if edad >= 18:
    if carnet_conducir:
        print("Puedes conducir.")
    else:
        print("Eres mayor de edad, pero no puedes conducir.")
else:
    print("Eres menor de edad.")

Sentencia match-case

Antes de Python 3.10, las comparaciones múltiples se realizaban utilizando la estructura if-elif-else, lo que podía llevar a una sintaxis un tanto repetitiva y menos legible en ciertos casos. El nuevo match case resuelve este problema ya que permite realizar comparaciones más elegantes y fáciles de leer.

Sintaxis básica

La sintaxis del match case se asemeja a una declaración switch en otros lenguajes de programación. Su forma básica es la siguiente:

match valor:
    case patron1:
        # código a ejecutar si el valor coincide con patron1
    case patron2:
        # código a ejecutar si el valor coincide con patron2
    ...
    case patronN:
        # código a ejecutar si el valor coincide con patronN
    case _:
        # código a ejecutar si no se cumple ninguno de los patrones anteriores

Un ejemplo muy sencillo

En su forma más sencilla, el match case permite comprobar coincidencias con valores específicos de cualquier tipo (números, cadenas, etc). Por ejemplo, utilizando el código del siguiente ejemplo podemos determinar el estado civil de una persona basándonos en el valor de la variable codigo:

match codigo:
    case "S":
        print("Soltero/a")
    case "C":
        print("Casado/a")
    case "D":
        print("Divorciado/a")
    case "V":
        print("Viudo/a")
    case _:
        print("Código inválido")

Equivalencia entre «if-elif-else» y «match-case»

Supongamos que queremos determinar el día de la semana correspondiente a un número del 1 al 7, donde 1 representa el lunes y 7 representa el domingo.

Usando if-elif-else:

if numero == 1:
    print("Lunes")
elif numero == 2:
    print("Martes")
elif numero == 3:
    print("Miércoles")
elif numero == 4:
    print("Jueves")
elif numero == 5:
    print("Viernes")
elif numero == 6:
    print("Sábado")
elif numero == 7:
    print("Domingo")
else:
    print("Número inválido")

Usando match case:

match numero:
    case 1:
        print("Lunes")
    case 2:
        print("Martes")
    case 3:
        print("Miércoles")
    case 4:
        print("Jueves")
    case 5:
        print("Viernes")
    case 6:
        print("Sábado")
    case 7:
        print("Domingo")
    case _:
        print("Número inválido")

Como se puede apreciar, el uso del match case reduce significativamente la cantidad de consultas que se realizan para comprobar el valor de la variable numero y hace que el código resultante sea más fácil de leer.

Combinación de patrones

El match case también permite combinar múltiples patrones utilizando la sintaxis case patron1 | patron2 | ...:. En el siguiente ejemplo agrupamos diversos valores de una nota numérica con el propósito de mostrar el texto descriptivo de la calificación que se haya obtenido:

match nota:
    case 0 | 1 | 2 | 3 | 4:
        print("Suspendido")
    case 5 | 6:
        print("Aprobado")
    case 7 | 8:
        print("Notable")
    case 9 | 10:
        print("Sobresaliente")
    case _:
        print("Nota no válida")

Además Python nos permite comprobar coincidencias con datos de cualquier tipo (cadenas, listas, tuplas, diccionarios, etc). Vamos a ver un ejemplo en el que tenemos una lista de alimentos representados por cadenas de texto. Utilizamos el match case para clasificar cada alimento en diferentes categorías: «Frutas», «Verduras», «Proteínas» o «Carbohidratos». Si el alimento no coincide con ninguna de estas categorías, lo clasificamos como «Desconocido». De esta forma, el match case nos permitirá clasificar rápidamente cada alimento en su respectiva categoría sin tener que escribir múltiples sentencias if-elif-else, y por lo tanto obtenemos un código más simple y fácil de entender:

match alimento:
    case "manzana" | "pera" | "plátano" | "uva":
        print("Frutas")
    case "zanahoria" | "tomate" | "espinaca" | "lechuga":
        print("Verduras")
    case "pollo" | "pescado" | "res" | "cerdo":
        print("Proteínas")
    case "arroz" | "pasta" | "pan" | "patata":
        print("Carbohidratos")
    case _:
        print("Desconocido")

Consideraciones adicionales

Es importante tener en cuenta que el match case es una característica introducida en Python 3.10, por lo que si estamos utilizando una versión anterior, esta funcionalidad no estará disponible. Además, es recomendable utilizar el match case sólo cuando el código resulte más legible o apropiado para el problema en cuestión. En muchos casos, la estructura if-elif-else tradicional puede ser resultar más adecuada por motivos de compatibilidad o en caso de que podamos resolver nuestro problema utilizando expresiones booleanas sencillas.

Test

Evalúa tus conocimientos mediante este test que incluye preguntas relacionadas con esta unidad.

En Python se pueden convertir datos de un tipo a otro utilizando funciones integradas o métodos específicos para cada tipo de dato. Estas conversiones son útiles cuando necesitamos operar con diferentes tipos de datos o cuando queremos mostrar información en un formato específico. A continuación detallaremos las conversiones más comunes en Python, y proporcionaremos ejemplos prácticos para cada caso.

Conversión a enteros (int)

Podemos convertir datos a enteros utilizando la función int():

# Convertir un número decimal a entero
decimal = 5.75
entero = int(decimal)  # 5 (se descarta la parte decimal)

# Convertir una cadena numérica a entero
cadena_numero = "123"
entero_desde_cadena = int(cadena_numero)  # 123

Conversión a flotantes (float)

Podemos convertir datos a números flotantes utilizando la función float():

# Convertir un entero a número flotante
entero = 10
flotante_desde_entero = float(entero)  # 10.0

# Convertir una cadena numérica a número flotante
cadena_numero = "3.14"
flotante_desde_cadena = float(cadena_numero)  # 3.14

Conversión a cadenas (str)

Podemos convertir datos a cadenas utilizando la función str():

# Convertir un número entero a cadena
entero = 42
cadena_desde_entero = str(entero)  # "42"

# Convertir un número flotante a cadena
flotante = 3.14
cadena_desde_flotante = str(flotante)  # "3.14"

Conversión a booleanos (bool)

Podemos convertir datos a booleanos utilizando la función bool(). En general, los siguientes valores se evaluarán como False en Python, y todo lo demás se evaluará como True:

• Cualquier número que sea 0 (entero o flotante).
• Cadenas vacías.
• Listas, tuplas, diccionarios o conjuntos vacíos.
• El valor especial None.

# Convertir un número entero a booleano
entero = 10
booleano_desde_entero = bool(entero)  # True

# Convertir un número flotante a booleano
flotante = 0.0
booleano_desde_flotante = bool(flotante)  # False

# Convertir una cadena a booleano
cadena_vacia = ""
booleano_desde_cadena = bool(cadena_vacia)  # False

# Convertir una lista vacía a booleano
lista_vacia = []
booleano_desde_lista = bool(lista_vacia)  # False

# Convertir un valor None a booleano
valor_nulo = None
booleano_desde_nulo = bool(valor_nulo)  # False

Conversión a otras bases o representaciones

En Python también podemos convertir datos a representaciones en formato binario, octal o hexadecimal utilizando las funciones bin(), oct() y hex():

numero = 42

# Convertir a binario
binario = bin(numero)  # '0b101010'

# Convertir a octal
octal = oct(numero)    # '0o52'

# Convertir a hexadecimal
hexadecimal = hex(numero)  # '0x2a'

Es importante tener en cuenta que no todos los tipos de datos se pueden convertir a todas las representaciones. Por ejemplo, no podemos convertir una cadena a binario directamente.

Test

Evalúa tus conocimientos mediante este test que incluye preguntas relacionadas con esta unidad.

Las cadenas de texto (también conocidas como strings) son secuencias de caracteres encerradas entre comillas simples o comillas dobles, y nos permiten almacenar y manipular texto en los programas. En Python, las cadenas son objetos inmutables, lo que significa que no se pueden modificar una vez creadas, pero podemos crear nuevas cadenas a partir de ellas con diferentes manipulaciones. Vamos a detallar a continuación la sintaxis básica relacionada con las cadenas, e incluiremos ejemplos prácticos.

Creación de cadenas

Podemos crear una cadena asignando un valor entre comillas (simples o dobles) a una variable:

mensaje = "Hola, Python!"
nombre = 'María'
direccion = "Calle San José, 123"

También podemos utilizar triples comillas (simples o dobles) para crear cadenas de varias líneas:

parrafo = """Este es un ejemplo
de una cadena con varias líneas.
Puedes usar triples comillas para ello."""

Operaciones con cadenas

Longitud de una cadena

Podemos obtener la longitud de una cadena utilizando la función len():

mensaje = "Hola, Python!"
longitud = len(mensaje)  # 13 (incluyendo espacios y signos de puntuación)

Concatenación

Podemos unir cadenas utilizando el operador +:

saludo = "Hola, "
nombre = "María"
mensaje_completo = saludo + nombre  # "Hola, María"

Repetición

Podemos repetir una cadena utilizando el operador *:

cadena = "abc"
repetida = cadena * 3  # "abcabcabc"

Indexación y segmentación

Las cadenas son secuencias de caracteres, lo que significa que podemos acceder a caracteres individuales utilizando índices y también podemos segmentar la cadena para obtener subcadenas:

texto = "Python es genial"

primer_caracter = texto[0]  # "P" (el primer carácter tiene índice 0)
ultimo_caracter = texto[-1]  # "l" (el último carácter tiene índice -1)

segmento = texto[7:9]  # "es" (segmento desde el índice 7 hasta el índice 8, no incluye el índice 9)

# También puedes omitir el índice de inicio o de fin para segmentar desde el principio o hasta el final, respectivamente.
inicio_omitiendo = texto[:6]  # "Python"
fin_omitiendo = texto[10:]   # "genial"

Búsqueda en cadenas

Podemos buscar subcadenas dentro de una cadena utilizando los métodos find() e index():

texto = "Python es un lenguaje de programación"
posicion_find = texto.find("lenguaje")  # 13 (posición de la primera ocurrencia)
posicion_index = texto.index("lenguaje")  # 13 (posición de la primera ocurrencia)

# Si la subcadena no se encuentra, find() devuelve -1, mientras que index() genera una excepción ValueError.
posicion_find_no_encontrada = texto.find("Java")  # -1
posicion_index_no_encontrada = texto.index("Java")  # ValueError: substring not found

Reemplazo y formato

Podemos reemplazar subcadenas en una cadena utilizando el método replace():

mensaje = "Hola, NAME!"
nuevo_mensaje = mensaje.replace("NAME", "María")  # "Hola, María!"

También podemos utilizar el método format() para que la cadena incluya los valores de diferentes variables:

nombre = "Juan"
edad = 30
saludo = "Hola, mi nombre es {} y tengo {} años.".format(nombre, edad)
# "Hola, mi nombre es Juan y tengo 30 años."

Caracteres especiales

Python admite varios caracteres especiales que se pueden incluir en las cadenas, como por ejemplo:

• \n: Nueva línea.
• \t: Tabulación.
• \': Comilla simple.
• \": Comilla doble.
• \\: Barra invertida.

mensaje_multilinea = "Hola,\nPython!"
print(mensaje_multilinea)
# Salida:
# Hola,
# Python!

mensaje_tabs = "Hola,\tPython!"
print(mensaje_tabs)
# Salida: Hola,    Python!

mensaje_comillas = "Ella dijo: \"Hola, Python!\""
print(mensaje_comillas)
# Salida: Ella dijo: "Hola, Python!"

Métodos útiles para cadenas

Python incluye varios métodos para trabajar con cadenas. Algunos de los más útiles son:

texto = "Python es un lenguaje de programación"

# Convertir a mayúsculas y minúsculas
texto_mayusculas = texto.upper()  # "PYTHON ES UN LENGUAJE DE PROGRAMACIÓN"
texto_minusculas = texto.lower()  # "python es un lenguaje de programación"

# Capitalizar la primera letra de la cadena
texto_capitalizado = texto.capitalize()  # "Python es un lenguaje de programación"

# Contar ocurrencias de una subcadena
ocurrencias = texto.count("a")  # 3 (número de veces que aparece "a" en la cadena)

# Verificar si una cadena comienza o termina con una subcadena
comienza_con = texto.startswith("Python")  # True
termina_con = texto.endswith("programación")  # True

# Separar una cadena en una lista de subcadenas por un carácter específico
palabras = texto.split(" ")  # ['Python', 'es', 'un', 'lenguaje', 'de', 'programación']

# Eliminar espacios en blanco al principio y al final de la cadena
texto_limpio = "   Hola, Python!   "
texto_sin_espacios = texto_limpio.strip()  # "Hola, Python!"

F-strings

Las f-strings (o cadenas formateadas) nos proporcionan una forma muy legible para construir cadenas en Python (están disponibles a partir de la versión 3.6). Las f-strings nos permiten incorporar expresiones dentro de las cadenas, lo que facilita la inclusión de variables y otros valores en ellas sin tener que utilizar métodos de formato o concatenación. Para usar f-strings, simplemente debemos colocar una «f» o «F» antes del inicio de la cadena y luego añadimos las expresiones utilizando llaves {} dentro de la cadena:

nombre = "Juan"
edad = 30

# Usando f-string para formatear la cadena
mensaje = f"Hola, mi nombre es {nombre} y tengo {edad} años."
print(mensaje)
# Salida: "Hola, mi nombre es Juan y tengo 30 años."

Las expresiones dentro de las llaves serán evaluadas y su valor se incluirá en la cadena final. Se puede incluir cualquier tipo de expresión válida dentro de las llaves, como operaciones matemáticas, llamadas a funciones, y más:

a = 10
b = 5

# Operaciones matemáticas dentro de una f-string
resultado = f"La suma de {a} y {b} es {a + b}, y el producto es {a * b}."
print(resultado)
# Salida: "La suma de 10 y 5 es 15, y el producto es 50."

También se puede aplicar formato a las expresiones dentro de las llaves. Por ejemplo, podemos especificar la cantidad de decimales para un número flotante o el ancho para un número entero:

precio = 9.99

# Formato de número flotante dentro de una f-string
mensaje_precio = f"El precio es: ${precio:.2f}"
print(mensaje_precio)
# Salida: "El precio es: $9.99"

cantidad = 100

# Formato de número entero dentro de una f-string
mensaje_cantidad = f"La cantidad es: {cantidad:05d}"
print(mensaje_cantidad)
# Salida: "La cantidad es: 00100"

En el ejemplo anterior, :.2f indica que queremos mostrar el número flotante con dos decimales, mientras que :05d indica que queremos que el número entero tenga un ancho de 5 dígitos, rellenando con ceros a la izquierda si es necesario.

Test

Evalúa tus conocimientos mediante este test que incluye preguntas relacionadas con esta unidad.

Los operadores en Python son símbolos especiales que se emplean para realizar diferentes acciones y cálculos utilizando variables y valores. Estas operaciones pueden ser matemáticas, de comparación, lógicas, de asignación, etc. Los operadores son fundamentales en la programación, ya que nos permiten realizar cálculos, tomar decisiones y manipular datos de manera eficiente.

Operadores Aritméticos

Los operadores aritméticos se utilizan para realizar operaciones matemáticas en números. Aquí están los principales operadores aritméticos en Python:

• Suma (+): Suma dos valores.
• Resta (-): Resta el segundo valor del primero.
• Multiplicación (*): Multiplica dos valores.
• División (/): Divide el primer valor por el segundo. Siempre devuelve un flotante.
• División entera (//): Divide el primer valor por el segundo y redondea el resultado hacia abajo al entero más cercano.
• Módulo (%): Devuelve el resto de la división entera entre el primer valor y el segundo.
• Potencia (**): Eleva el primer valor a la potencia del segundo.

a = 10
b = 3

suma = a + b          # 13
resta = a - b         # 7
producto = a * b      # 30
division = a / b      # 3.3333333333333335
division_entera = a // b  # 3
resto = a % b         # 1
potencia = a ** b     # 1000

Operadores de Comparación

Los operadores de comparación se utilizan para comparar dos valores y devuelven un valor booleano (True o False). Aquí están los principales operadores de comparación en Python:

• Igual que (==): Comprueba si los valores son iguales.
• Diferente que (!=): Comprueba si los valores son diferentes.
• Mayor que (>): Comprueba si el primer valor es mayor que el segundo.
• Menor que (<): Comprueba si el primer valor es menor que el segundo.
• Mayor o igual que (>=): Comprueba si el primer valor es mayor o igual que el segundo.
• Menor o igual que (<=): Comprueba si el primer valor es menor o igual que el segundo.

x = 10
y = 5

igual_que = x == y               # False
diferente_que = x != y           # True
mayor_que = x > y                # True
menor_que = x < y                # False
mayor_o_igual_que = x >= y       # True
menor_o_igual_que = x <= y       # False

Operadores Lógicos

Los operadores lógicos se utilizan para combinar expresiones booleanas y devuelven un valor booleano. Aquí están los principales operadores lógicos en Python:

• and (y): Devuelve True si ambas expresiones son verdaderas.
• or (o): Devuelve True si al menos una de las expresiones es verdadera.
• not (no): Devuelve el valor opuesto de la expresión.

a = True
b = False

resultado_and = a and b         # False
resultado_or = a or b           # True
resultado_not_a = not a         # False
resultado_not_b = not b         # True

Operadores de Pertenencia

Los operadores de pertenencia se utilizan para comprobar si un valor está presente en una secuencia, como una lista, tupla o cadena.

• in: Devuelve True si el valor está presente en la secuencia.
• not in: Devuelve True si el valor no está presente en la secuencia.

mi_lista = [1, 2, 3, 4, 5]

esta_en_lista = 3 in mi_lista         # True
no_esta_en_lista = 6 not in mi_lista  # True

mi_cadena = "Hola, Python!"

esta_en_cadena = "Python" in mi_cadena          # True
no_esta_en_cadena = "Java" not in mi_cadena     # True

Operadores de Identidad

Los operadores de identidad se utilizan para comparar si dos variables se refieren al mismo objeto en memoria.

• is: Devuelve True si ambas variables apuntan al mismo objeto.
• is not: Devuelve True si ambas variables no apuntan al mismo objeto.

a = [1, 2, 3]
b = a  # b apunta a la misma lista en memoria que a

es_mismo_objeto = a is b         # True

c = [1, 2, 3]

es_distinto_objeto = a is not c  # True

Operadores de Asignación

Los operadores de asignación se utilizan para asignar valores a variables.

• = : Asignación básica.
• += : Asignación con suma.
• -= : Asignación con resta.
• *= : Asignación con multiplicación.
• /= : Asignación con división.

a = 10

a = 5   # Ahora a tiene el valor de 5
a += 2  # Ahora a tiene el valor de 7
a -= 3  # Ahora a tiene el valor de 4
a *= 2  # Ahora a tiene el valor de 8
a /= 4  # Ahora a tiene el valor de 2.0

Operador Ternario

El operador ternario nos permite escribir una expresión condicional de una forma muy concisa:

edad = 18

es_mayor_edad = True if edad >= 18 else False

En este caso, es_mayor_edad será True si la edad es mayor o igual a 18, y False en caso contrario.

Test

Evalúa tus conocimientos mediante este test que incluye preguntas relacionadas con esta unidad.

Las variables en Python son etiquetas o nombres que se utilizan para almacenar datos en la memoria del ordenador. Son fundamentales en la programación, ya que nos permiten guardar y manipular información de manera dinámica. A continuación explicaremos cómo declarar variables, los tipos de datos que pueden almacenar y proporcionaremos diversos ejemplos.

Declaración de variables

En Python no necesitas especificar el tipo de datos al declarar una variable, ya que es un lenguaje de tipado dinámico. Simplemente asignas un valor a un nombre de variable y Python determinará automáticamente el tipo de datos.

Para declarar una variable, se utiliza el símbolo = y luego se asigna el valor deseado:

# Declaración de variables
edad = 30
nombre = "Juan"
promedio = 9.5
es_estudiante = True

Tipos de datos básicos en Python

Números

• int: Números enteros (por ejemplo, 10, -5, 0).
• float: Números decimales (por ejemplo, 3.14, -2.5).

# Números
edad = 25
altura = 1.75

Texto

• str: Cadenas de caracteres (por ejemplo, «Hola», ‘Python’).

# Texto
nombre = "María"
mensaje = '¡Hola, Python!'

Booleanos

• bool: Puede ser True o False.

# Booleanos
es_estudiante = True
aprobo_examen = False

Operaciones con variables

Las variables se pueden utilizar en operaciones matemáticas y en la manipulación de datos:

# Operaciones con variables numéricas
a = 10
b = 5
suma = a + b
resta = a - b
producto = a * b
division = a / b
modulo = a % b
potencia = a ** b

# Operaciones con variables de texto (concatenación)
nombre = "Ana"
apellido = "Gómez"
nombre_completo = nombre + " " + apellido

# Operaciones con variables booleanas
es_dia_soleado = True
es_dia_frio = False
dia_ideal = es_dia_soleado and not es_dia_frio

Cambio del valor de una variable

Puedes cambiar el valor de una variable simplemente asignándole un nuevo valor:

edad = 30
print(edad)  # Salida: 30

edad = 40
print(edad)  # Salida: 40

Convenciones para nombrar variables

• Los nombres de las variables deben ser descriptivos y estar en minúsculas.
• Si un nombre de variable tiene varias palabras, se recomienda usar guiones bajos entre las palabras (snake_case).
• Evita usar nombres reservados por Python, como if, else, for, while, etc.

Ejemplos:

# Ejemplo de nombres de variables apropiados
nombre_completo = "Juan Pérez"
numero_telefono = "1234567890"
total_puntos = 100

# Evitar nombres de variables no descriptivos
a = "Hola"
b = 50
x = True

Test

Evalúa tus conocimientos mediante este test que incluye preguntas relacionadas con esta unidad.