Saltar al contenido
Portada » Lenguajes » 4. Estructuras de Datos

4. Estructuras de Datos

Estructuras de Datos. En este capítulo profundizaremos en las estructuras de datos más comunes y útiles en Python. Aunque ya hemos visto alguna ligeramente como las listas, ahora exploraremos en mayor detalle sus métodos y funcionalidades avanzadas para manipular grandes conjuntos de datos de manera eficiente. Además, aprenderemos a trabajar con otras estructuras importantes como las tuplas, los conjuntos y los diccionarios, cada uno con características específicas que los hacen útiles en distintos contextos.

Estas estructuras son esenciales para almacenar y organizar datos, permitiendo realizar operaciones como la búsqueda, la modificación o la eliminación de elementos. Comprender cuándo y cómo utilizar cada una de ellas te ayudará a desarrollar programas más robustos y optimizados.

Este capítulo te proporcionará las herramientas necesarias para gestionar datos de forma efectiva, adaptando la estructura adecuada según el tipo de problema que enfrentes.

Listas (list)

Las listas son colecciones ordenadas y mutables, lo que significa que puedes modificar sus elementos después de haberlas creado. Son una de las estructuras de datos más flexibles y usadas en Python.

Características:
  • Se definen con corchetes [].
  • Pueden almacenar cualquier tipo de datos (incluso mezclados).
  • Permiten duplicados.
Ejemplo de creación de una lista:
mi_lista = [1, 2, 3, "cuatro", 5.0, True]
Acceso a elementos:
  • Puedes acceder a los elementos de una lista por su índice.
print(mi_lista[0])  
# Salida: 1
Modificación de elementos:
  • Al ser mutables, puedes cambiar el valor de un elemento en cualquier posición.
mi_lista[1] = "dos" 
# Ahora mi_lista = [1, 'dos', 3, 'cuatro', 5.0, True]
Métodos útiles para listas:

append(): Añade un elemento al final de la lista.

mi_lista.append(6) 
# Ahora mi_lista = [1, 'dos', 3, 'cuatro', 5.0, True, 6]

insert(): Inserta un elemento en una posición específica.

mi_lista.insert(2, "manzana") 
# Ahora mi_lista = [1, 'dos', "manzana", 3, 'cuatro', 5.0, True]

remove(): Elimina la primera aparición de un elemento.

mi_lista.remove("cuatro")
# Ahora mi_lista = [1, 'dos', "manzana", 3, 5.0, True]

pop(): Elimina y devuelve el último elemento o el elemento en el índice especificado.

mi_lista.pop(0)  
# Elimina el primer elemento
# Ahora mi_lista = ['dos', "manzana", 3, 5.0, True]

sort(): Ordena la lista en orden ascendente.

mi_lista2 = [3, 4, 1, 5, 7]
mi_lista2.sort()
# Ahora mi lista = [1, 3, 4, 5, 7]

Tuplas (tuple)

Las tuplas son similares a las listas, pero son inmutables, lo que significa que no se pueden modificar una vez creadas. Son útiles cuando se necesita asegurar que los datos no cambien.

Características:
  • Se definen con paréntesis ().
  • También pueden contener diferentes tipos de datos.
  • No permiten modificaciones ni reordenamientos.
Ejemplo de creación de una tupla:
mi_tupla = (1, 2, 3, "cuatro", 5.0, True)
Acceso a elementos:
  • Igual que con las listas, los elementos de las tuplas se acceden por su índice.
print(mi_tupla[2])  
# Salida: 3
Métodos útiles para tuplas:
  1. count(): Cuenta cuántas veces aparece un elemento en la tupla.
mi_tupla.count(3)
# Devuelve un 1, pues el elemento 3 aparece solo una vez en la tupla

index(): Devuelve el índice de la primera aparición de un elemento.

mi_tupla.index(3)
# Devuelve el valor 2
Ventajas de las tuplas:
  • Al ser inmutables, son más rápidas que las listas.
  • Son más seguras para almacenar datos que no deben ser modificados accidentalmente.

Conjuntos (set)

Los conjuntos son colecciones no ordenadas y sin elementos duplicados. Se utilizan cuando se requiere garantizar que los elementos sean únicos.

Características:
  • Se definen con llaves {} o usando la función set().
  • No permiten elementos duplicados.
  • Son mutables, pero sus elementos deben ser inmutables.
Ejemplo de creación de un conjunto:
mi_conjunto = {1, 2, 3, "cuatro", 5.0 }
Acceso a elementos:
  • Los conjuntos no tienen un índice, ya que no están ordenados.
Métodos útiles para conjuntos:
  1. add(): Añade un elemento al conjunto.
mi_conjunto.add(6)
# Ahora mi_conjunto = {1, 2, 3, 5.0, 6 }

remove(): Elimina un elemento del conjunto. Si el elemento no existe, lanza un error.

mi_conjunto.remove(5.0)
# Ahora mi_conjunto = { 1, 2, 3, 6 }

discard(): Elimina un elemento del conjunto sin lanzar un error si no existe.

mi_conjunto.discard(3)
# Ahora mi_conjunto = { 1, 2, 6 }

union(): Retorna un nuevo conjunto que es la unión de dos conjuntos (todos los elementos, sin duplicados).

otro_conjunto = {7, 8, 9}
union_conjuntos = mi_conjunto.union(otro_conjunto)
# Ahora union_conjuntos = { 1, 2, 3, 7, 8, 9 }

intersection(): Retorna un conjunto con los elementos comunes a ambos conjuntos.

interseccion = union_conjuntos.intersection(otro_conjunto)
# Ahora interseccion = { 7, 8, 9 }

@Tip. Con los conjuntos podemos hacer uso de los operadores Intersección (&) para obtener un conjunto de los elementos que están en los dos conjutos, Unión (|) para obtener otro conjunto con la suma de los elementos de ambos conjuntos y Diferencia (-) para obtener un conjunto con los elementos que están en el primer conjunto pero no en el segundo.

Ventajas de los conjuntos:
  • Son útiles para operaciones de conjuntos matemáticos (unión, intersección, diferencia).
  • Ideales para eliminar duplicados de una lista de manera eficiente.

Diccionarios (dict)

Los diccionarios son colecciones no ordenadas de pares clave-valor. Cada elemento tiene una clave única asociada con un valor, lo que los hace extremadamente útiles para buscar datos rápidamente.

Características:
  • Se definen con llaves {} y los pares clave-valor se separan con dos puntos :.
  • Las claves deben ser únicas e inmutables (como cadenas o números), mientras que los valores pueden ser de cualquier tipo.
Ejemplo de creación de un diccionario:
mi_diccionario = {"nombre": "Ana", "edad": 25, "ciudad": "Madrid"}
Acceso a elementos:
  • Los elementos se acceden mediante la clave, no por índice.
print(mi_diccionario["nombre"])  
# Salida: Ana
Modificación de valores:
  • Los valores de los diccionarios son mutables, por lo que puedes modificar los valores asociados a las claves.
mi_diccionario["edad"] = 26
# Ahora mi_diccionario = {"nombre": "Ana", "edad": 26, "ciudad": "Madrid"}
Métodos útiles para diccionarios:
  1. get(): Devuelve el valor de una clave, y si no existe, devuelve un valor predeterminado.
print(mi_diccionario.get("nombre", "Desconocido"))
# Devuelve "Ana"

print(mi_diccionario.get("apellido", "Desconocido"))
# Devuelve "Desconocido"

keys(): Retorna una lista de todas las claves en el diccionario.

print(mi_diccionario.keys())
# Devuelve ['nombre','edad',ciudad']

values(): Retorna una lista de todos los valores en el diccionario.

print(mi_diccionario.values())
# Devuelve ['Ana',26,'Madrid']

items(): Retorna una lista de tuplas con los pares clave-valor.

print(mi_diccionario.items())
# Devuelve [('nombre','Ana'),('edad',26),('ciudad','Madrid')]

update(): Actualiza el diccionario con pares clave-valor de otro diccionario.

mi_diccionario.update({"nombre": "Luis", "apellido": "Gómez"})
# Ahora mi_diccionario = {"nombre": "Luis", "edad": 26, "ciudad": "Madrid", "apellido": "Gómez"}

len(): Devuelve el número de elementos clave-valor

len(mi_diccionario)
# Devuelve 4

Ejemplo de uso de un diccionario:

persona = {
    "nombre": "Carlos",
    "edad": 30,
    "trabajo": "Ingeniero"
}

# Acceder a un valor
print(persona["nombre"])  # Salida: Carlos

# Añadir un nuevo par clave-valor
persona["ciudad"] = "Barcelona"

# Eliminar una clave
del persona["edad"]

# Actualizar un valor
persona["trabajo"] = "Doctor"
EstructuraMétodos clave
Listasappend(), insert(), remove(), pop(), sort()
Tuplascount(), index()
Conjuntosadd(), remove(), discard(), union(), intersection()
Diccionariosget(), keys(), values(), items(), update()

@Tip: Podemos hacer uso de la función len() con cada estructura de datos. Esta función nos devolverá el número de elementos que la componen. P.E. Para imprimir la longitud de una lista sería de la siguiente manera:

mi_lista=[1, 3, 5, 7, 9]
print(len(mi_lista))
# Devolverá 5

En este capítulo, hemos explorado las principales estructuras de datos que ofrece Python, profundizando en el manejo de listas y ampliando nuestro conocimiento sobre tuplas, conjuntos y diccionarios. Cada una de estas estructuras es fundamental para organizar y gestionar datos de manera eficiente en nuestros programas.

Las listas nos permiten trabajar con colecciones dinámicas y flexibles, mientras que las tuplas, al ser inmutables, resultan útiles cuando necesitamos proteger los datos de modificaciones accidentales. Los conjuntos ofrecen una forma eficiente de gestionar colecciones sin elementos duplicados, y los diccionarios nos proporcionan una estructura clave-valor ideal para representar asociaciones o datos más complejos.

Dominar estas estructuras es clave para escribir código optimizado y resolver problemas de manera más eficiente. ¡En los próximos capítulos veremos cómo utilizarlas en conjunto con otros conceptos para crear soluciones aún más poderosas!

A continuación te dejo unos ejercicios con lo que hemos visto en la lección para que puedas seguir practicando.

Ejercicio 1: Operaciones con Listas
Escribe un programa que haga lo siguiente:
Cree una lista con los números del 1 al 10.
Multiplique cada número de la lista por 2.
Filtre los números que sean mayores a 10 y guárdalos en una nueva lista.
Muestra la lista original y la lista filtrada.
# Crear una lista con los números del 1 al 10
lista_numeros = list(range(1, 11))  # Usamos range para generar números del 1 al 10

# Multiplicamos cada número de la lista por 2 
lista_multiplicada = [num * 2 for num in lista_numeros]

# Filtramos los números mayores a 10
lista_filtrada = [num for num in lista_multiplicada if num > 10]

# Mostramos las listas
print(f"Lista original: {lista_numeros}")
print(f"Lista multiplicada: {lista_multiplicada}")
print(f"Lista filtrada (mayores a 10): {lista_filtrada}")

Explicación:

  1. Usamos range para crear una lista con números del 1 al 10.
  2. Creamos con for la lista para multiplicar cada número por 2.
  3. Filtramos los números mayores a 10 con otra lista.
  4. Finalmente, mostramos la lista original, la lista multiplicada y la lista filtrada.
Ejercicio 2: Uso de Diccionarios
Escribe un programa que simule una libreta de contactos. El programa debe:
Crear un diccionario vacío para almacenar los contactos (clave: nombre, valor: teléfono).
Solicitar al usuario que ingrese 3 contactos (nombre y teléfono).
Permitir al usuario buscar un contacto por nombre y mostrar el número asociado, o un mensaje si el contacto no existe.
# Crear un diccionario vacío para los contactos
contactos = {}

# Pedimos al usuario que ingrese 3 contactos
for i in range(3):
    nombre = input(f"Ingrese el nombre del contacto {i+1}: ")
    telefono = input(f"Ingrese el teléfono de {nombre}: ")
    contactos[nombre] = telefono  # Guardamos el nombre y teléfono en el diccionario

# Pedimos al usuario que busque un contacto
busqueda = input("Ingrese el nombre del contacto a buscar: ")

# Verificamos si el contacto existe en el diccionario
if busqueda in contactos:
    print(f"El número de {busqueda} es: {contactos[busqueda]}")
else:
    print(f"No se encontró un contacto con el nombre {busqueda}")

Explicación:

  1. Creamos un diccionario vacío llamado contactos para almacenar pares nombre-teléfono.
  2. Usamos un bucle for para pedir 3 contactos al usuario y almacenarlos en el diccionario.
  3. Permitimos al usuario buscar un contacto por nombre, y usamos una estructura condicional para comprobar si el nombre existe en el diccionario. Si lo encuentra, muestra el teléfono; de lo contrario, avisa que no está registrado.
Ejercicio 3: Operaciones con Conjuntos
Escribe un programa que:
Cree dos conjuntos de números, uno con los números del 1 al 5 y otro con los números del 4 al 8.
Encuentre la intersección, la unión y la diferencia entre ambos conjuntos.
Muestra los resultados de cada operación.
Solución:
# Crear dos conjuntos de números
conjunto1 = {1, 2, 3, 4, 5}
conjunto2 = {4, 5, 6, 7, 8}

# Realizamos las operaciones con conjuntos
interseccion = conjunto1 & conjunto2  # Intersección: elementos comunes a ambos conjuntos
union = conjunto1 | conjunto2  # Unión: todos los elementos de ambos conjuntos
diferencia = conjunto1 - conjunto2  # Diferencia: elementos que están en conjunto1 pero no en conjunto2

# Mostramos los resultados de las operaciones
print(f"Conjunto 1: {conjunto1}")
print(f"Conjunto 2: {conjunto2}")
print(f"Intersección: {interseccion}")
print(f"Unión: {union}")
print(f"Diferencia (Conjunto1 - Conjunto2): {diferencia}")

Explicación:

  1. Creamos dos conjuntos, conjunto1 y conjunto2, con elementos parcialmente superpuestos.
  2. Usamos las operaciones propias de los conjuntos:
    • Intersección (&): elementos que están en ambos conjuntos.
    • Unión (|): todos los elementos presentes en cualquiera de los dos conjuntos.
    • Diferencia (-): elementos que están en el primer conjunto, pero no en el segundo.
  3. Mostramos los resultados de cada operación.
Ejercicio 4: Operaciones con Tuplas
Escribe un programa que:
Cree una tupla con cinco elementos: una mezcla de números y cadenas de texto.
Acceda a los primeros tres elementos de la tupla y los muestre.
Verifique si un valor dado por el usuario está presente en la tupla.
Concatenar la tupla original con otra tupla de tres elementos nuevos.
# Crear una tupla con cinco elementos (mezcla de números y cadenas de texto)
mi_tupla = (10, "Python", 3.14, "Hola", 42)

# Acceder y mostrar los primeros tres elementos de la tupla (slicing)
primeros_tres = mi_tupla[:3]
print(f"Los primeros tres elementos de la tupla son: {primeros_tres}")

# Pedir al usuario un valor para verificar si está en la tupla
valor = input("Ingresa un valor para verificar si está en la tupla: ")

# Convertir el valor a número si es posible
try:
    valor = int(valor)  # Intenta convertir a entero
except ValueError:
    try:
        valor = float(valor)  # Si no es entero, intenta convertir a flotante
    except ValueError:
        pass  # Si no se puede convertir a número, queda como cadena de texto

# Verificar si el valor ingresado está en la tupla
if valor in mi_tupla:
    print(f"El valor '{valor}' está en la tupla.")
else:
    print(f"El valor '{valor}' NO está en la tupla.")

# Concatenar la tupla original con una nueva tupla de tres elementos
nueva_tupla = ("Nuevo", 99, 5.5)
tupla_concatenada = mi_tupla + nueva_tupla

# Mostrar la tupla resultante
print(f"La tupla concatenada es: {tupla_concatenada}")

Explicación:

  1. Creación de la tupla: Se define una tupla llamada mi_tupla con una mezcla de enteros, cadenas de texto y un número flotante.
  2. Acceso a los primeros tres elementos: Se usa slicing ([:3]) para extraer los primeros tres elementos de la tupla y se muestran.
  3. Verificación de presencia: Se solicita un valor al usuario y se intenta convertirlo a número. Luego se comprueba si ese valor está presente en la tupla usando el operador in.
  4. Concatenación de tuplas: La tupla original se concatena con otra tupla de tres nuevos elementos, y el resultado se muestra.

Anterior

Índice

Siguiente

Bibliografía de Python de interés.

Logo Python. 4. Estructuras de Datos

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *