Control de flujos y colecciones de datos en Python

Los controladores de flujo o como también se les conoce estructuras de control, son fundamentales en cualquier lenguaje de programación, incluido Python. Estas estructuras permiten a los desarrolladores controlar el flujo de ejecución del código, tomar decisiones y repetir bloques de código según sea necesario. En esta sección, exploraremos las principales estructuras de control de flujo en Python, así como las colecciones de datos que nos permiten almacenar y manipular conjuntos de datos.

Sentenicias if

La sentencia de if el el controlador más común en los códigos de programación. Este controlador de flujo puede comprobar la condición decon la palabra clave if, y si la condición es verdadera, se ejecuta el bloque de código indentado debajo de la sentencia if. Si la condición es falsa, el bloque de código se omite.

La sintaxis básica de if es la siguiente:

if <conidicion>:
   sentencia 1

Comprueba la condición y si es verdadera, ejecuta la sentencia 1.

x = 10
if x > 5:
    print("x es mayor que 5")
# Salida: x es mayor que 5

Sentencia if-else

Cuando tenemos la condición falsa, poidemos utilizar la sentencia else para ejecutar un bloque de código alternativo. La sentencia en este caso es la siguiente:

if <condicion>:
   sentencia 1
else:
   sentencia 2

Si la condición es verdadera, se ejecuta la sentencia 1; de lo contrario, se ejecuta la sentencia 2.

x = 3
if x > 5:
   print("x es mayor que 5")
else:
   print("x no es mayor que 5")
# Salida: x no es mayor que 5

Sentencia if-elif-else

Cuado hay varias condiciones que tenemos que comprobar, podemos utilizar la sentencia elif (abreviatura de “else if”) para agregar condiciones adicionales. Si todas las condiciones anteriores son falsas, se ejecuta el bloque de código debajo de else.

La sintaxis es la siguiente:
if <condicion1>:
   sentencia 1
elif <condicion2>:
   sentencia 2
else:
   sentencia 3

x = 7
if x > 10:
   print("x es mayor que 10")
elif x > 5:
   print("x es mayor que 5 pero no mayor que 10")
else:
   print("x no es mayor que 5")
# Salida: x es mayor que 5 pero no mayor que 10

Sentencia while

A diferencia de la senetencia if, que ejecuta un bloque de código una sola vez si la condición es verdadera, la sentencia while repite un bloque de código mientras la condición sea verdadera. Es un bucle que comprueba al condición continuamente para un conunto de valores, por lo que necesita algunos parámetros obligatorios:

Condición: comprueba una condición para todo el cojunto de valroes. Si la condición es falsa, entonces saldrá del bucle. Si la condición es verdadera, entonces ejecutará el bloque de código indentado.
Variable contador: que decide cuantas veces iterará el bucle y debe ser incrementada después de cada iteración, de lo contrario el bucle se vuelve infinito, incluso si la condición es o no falsa.
break: Incluso si la condición es verdadera, a veces el bucle puede terminar después de realizar ciertas acciónes. La sentencia break puede ser usada para eso y saldrá del bucle cuando la dicha sentencia se ejecute.

Sintaxis:

La condición se da con la palabra clave while y antes de eso se inicializa la variable del que usaremos de contador. Dentro del bucle se escriben las setencias que se tienen que ejucar y se incrementa la variable contador para continuar con el bucle hasta que la condición se vuelva falsa.

vairable_contador = 0
while <condicion>:
   sentencia 1
   variable_contador += 1

contador = 0
while contador < 5:
    print("Contador:", contador)
    contador += 1
# Salida:
# Contador: 0
# Contador: 1
# Contador: 2
# Contador: 3
# Contador: 4

Sentencia for

Los bucles while y fortienen el mismo propósito de repetir un bloque de código, pero se utilizan en diferentes situaciones. El bucle for es más adecuado cuando se conoce de antemano el número de iteraciones o cuando se itera sobre una colección de datos, como una lista o una cadena de texto.

Si lo que queremos hacer en un bucle for es iterar sobre una colección de datos debemos usar range() o directamente la colección de datos. For puede tener hasta tres parámetros.

Sintaxis:

range(n): Devuelve un cojunto de números desde el 0 hasta n-1.
range(inicio, fin): Devuelve un conjunto de números desde el valor de inicio hasta fin-1.
range(inicio, fin, paso): Devuelve un conjunto de números desde el valor de inicio hasta fin-1, incrementando en cada iteración el valor del paso.

list(range(7)) # Devuelve [0, 1, 2, 3, 4, 5, 6] list(range(3, 8)) # Devuelve [3, 4, 5, 6, 7] list(range(2, 10, 2)) # Devuelve [2, 4, 6, 8]

La sintaxis del bucle for es la siguiente: for variable in range(n): sentencia 1

for i in range(5):
    print("Número:", i)
# Salida:
# Número: 0
# Número: 1
# Número: 2
# Número: 3
# Número: 4

Cómo podemos ver le valor se incremaente automáticamente en cada iteracción esperado en la función range(). EL conjunto de números pares puede imprimirse fácilmente fácilmente utilizando el bucle for configurando la función range().

for i in range(2, 10, 2):
    print("Número par:", i)
# Salida:
# Número par: 2
# Número par: 4
# Número par: 6
# Número par: 8

Bucle for anidado

Los bucles for pueden anidarse dentro de otros bucles for para iterar sobre múltiples dimensiones o niveles de datos. Esto es útil cuando se trabaja con estructuras de datos más complejas, como listas de listas o matrices.

for i in range(3):
    for j in range(2):
        print(f"i: {i}, j: {j}")
# Salida:
# i: 0, j: 0
# i: 0, j: 1
# i: 1, j: 0
# i: 1, j: 1
# i: 2, j: 0
# i: 2, j: 1

Bucles anidados complejos:

Los bucles while y for pueden anidarse en cualquier orden. El bucle extrerior pueden ser while o for y el bucle interior puede ser while o for.

contador = 0
while contador < 2:
    for i in range(3):
        print(f"Contador: {contador}, i: {i}")
    contador += 1
# Salida:
# Contador: 0, i: 0
# Contador: 0, i: 1
# Contador: 0, i: 2
# Contador: 1, i: 0
# Contador: 1, i: 1
# Contador: 1, i: 2

tuplas

La tupla es la estructura de datos que recogen un conjunto de alementos de diferentes tipos de datos. Una de las principales diferencias de las tuplas con otros tipos de datos es que, una vez las creamos no las podemos modificar, es decir, son inmutables. Las tuplas se crean utilizando paréntesis () y los elementos se separan por comas. Podemos acceder a los elementos de una tupla utilizando índices, comenzando desde 0.

mi_tupla = (1, "hola", 3.14, True)
print(mi_tupla)
# Salida: (1, 'hola', 3.14, True)
print(type(mi_tupla))
# Salida: <class 'tuple'>
print(mi_tupla[1])
# Salida: hola

Aunque las tuplas son inmutables, podemos realizar algunas operaciones como concatenación y repetición.

tupla1 = (1, 2, 3)
tupla2 = (4, 5, 6)
tupla_concatenada = tupla1 + tupla2
print(tupla_concatenada)
# Salida: (1, 2, 3, 4, 5, 6)
tupla_repetida = tupla1 * 2
print(tupla_repetida)
# Salida: (1, 2, 3, 1, 2, 3)

Conversión entre listas y tuplas

Una tupla puede convertir en una lista utilizando la función list(), y una lista puede convertirse en una tupla utilizando la función tuple().

mi_tupla = (1, 2, 3)
mi_lista = list(mi_tupla)
print(mi_lista)
# Salida: [1, 2, 3]
nueva_tupla = tuple(mi_lista)
print(nueva_tupla)
# Salida: (1, 2, 3)

El contenido de la tupla ahora se convierte en lista y se pueden hacer otras operaciones con los datos fácilmente. también el contenido de la lista se puede convertir en tupla.

Conjuntos

Los conjuntos es otra estructura de datos que recoge los elementos dentro de los corchetes. La principal característica de los conjutos es que son desordenados y la indexación no funciona.

Sintaxis:

nombre_conjunto = {elemento1, elemento2, elemento3, ...}

mi_conjunto = {1, 2, 3, 4, 5}
print(mi_conjunto)
# Salida: {1, 2, 3, 4, 5}
print(type(mi_conjunto))
# Salida: <class 'set'>

Diccionarios

Los diccionarios son otro tipo de estructura de datos. Cada elemento del diccionario tienen dos parámetros: una clave y un valor. Los diccionarios son mutables, lo que significa que podemos modificar, agregar o eliminar elementos después de su creación. Los diccionarios se definen utilizando llaves {}, y los pares clave-valor están separados por comas. La clave y el valor dentro de cada par están separados por dos puntos :.

A cada valor le corresponde una clave.

Sintaxis:

nombre_diccionario : {
   clave1: valor1,
   clave2: valor2,
   clave3: valor3,
   ...
}

mi_diccionario = {
   "nombre": "Juan",
   "edad": 30,
   "ciudad": "Madrid"
   }
print(mi_diccionario)
# Salida: {'nombre': 'Juan', 'edad': 30, 'ciudad': 'Madrid'}
print(type(mi_diccionario))
# Salida: <class 'dict'>

Entrada y salida de datos

Hay diferentes funciones incorporadas para realizar las operaciones de entrada/salida de datos en python.

Entradas de datos

En python los daots pueden ser ingresados direcatmente por el operador de asignación o hardcodeando los valores en el código.

x = 10
nombre = "Ana"

Otra opción es introducir los datos por teclado utilizando la función input(). Esta función lee una línea de entrada desde el usuario y devuelve una cadena de texto.

nombre = input("Introduce tu nombre: ")
print("Hola,", nombre)
# Si el usuario introduce "JaviLázaro", la salida será: Hola, JaviLázaro

Pero si el valor que se introduce es un número y queremos hacer operaciones matemáticas con él, tenemos que convertirlo al tipo de dato adecuado utilizando las funciones int() o float().

edad = int(input("Introduce tu edad: "))
año_nacimiento = 2024 - edad
print("Naciste en el año:", año_nacimiento)
# Si el usuario introduce 30, la salida será: Naciste en el año: 1994

Otra de las formas que tenemos para introducir los datos es con la función raw_input(), que se utiliza para leer un carácter o cadena de números desde el teclaro. Siempre devuelve una cadena de texto.

caracter = raw_input("Introduce un carácter: ")
print("El carácter introducido es:", caracter)
# Si el usuario introduce "A", la salida será: El carácter introducido es: A

Salida de datos

Para mostrar datos en la consola, Python utiliza la función print(). Esta función puede tomar múltiples argumentos y los imprime en la consola separados por espacios.

nombre = "Javi"
edad = 30
print("Nombre:", nombre, "Edad:", edad)
# Salida: Nombre: Javi Edad: 30

También podemos formatear cadenas de texto utilizando f-strings (cadenas literales formateadas) para incluir variables dentro de una cadena de texto de manera más legible.

nombre = "Javi"
edad = 30
print(f"Nombre: {nombre}, Edad: {edad}")
# Salida: Nombre: Javi, Edad: 30

Otra de las formas que podemos mostrar el dato es:

nombre = "Javi"
edad = 30
print("Nombre: {}, Edad: {}".format(nombre, edad))
# Salida: Nombre: Javi, Edad: 30

Pero print() también puede tomar parámetros opcionales como:

sep: Especifica el separador entre los argumentos. Por defecto es un espacio.
end: Especifica el carácter que se imprime al final. Por defecto es un salto de línea (\n).

print("Hola", "Mundo", sep=", ", end="!\n")
# Salida: Hola, Mundo!

Aquí te dejo el video del directo que tuvimos

¿Listo para hacer crecer tu negocio?

Analicemos tu proyecto y definamos la estrategia perfecta para alcanzar tus objetivos

Solicitar consultoría gratuita