Estructuras de Datos en Python

Introducción

En este laboratorio, explorarás las estructuras de datos fundamentales de Python: listas, tuplas, conjuntos (sets) y diccionarios. Partiendo de los conocimientos adquiridos en laboratorios anteriores, aprenderás a crear, manipular y utilizar estas versátiles estructuras. Esta experiencia práctica profundizará tu comprensión de los conceptos básicos de Python y te preparará para manejar datos más complejos en tus programas.

Trabajando con Listas

En este paso, aprenderás sobre las listas, que son colecciones de elementos ordenadas y mutables en Python.

Abre el intérprete de Python escribiendo el siguiente comando en tu terminal:

python

Deberías ver el prompt de Python (>>>), lo que indica que ya estás dentro del shell interactivo de Python.

Comencemos creando una lista. En el intérprete de Python, escribe lo siguiente:

fruits = ["apple", "banana", "cherry"]
print(fruits)

Salida:

['apple', 'banana', 'cherry']

Las listas en Python se crean utilizando corchetes [], con los elementos separados por comas.

Puedes acceder a los elementos de la lista utilizando su índice. Recuerda que Python utiliza una indexación basada en cero:

print(fruits[0])  ## First item

Salida:

apple

print(fruits[-1])  ## Last item

Salida:

cherry

Las listas son mutables, lo que significa que puedes cambiar su contenido:

fruits[1] = "blueberry"
print(fruits)

Salida:

['apple', 'blueberry', 'cherry']

Puedes añadir elementos a una lista usando el método append() o insertar elementos en una posición específica con el método insert():

fruits.append("date")
print(fruits)

Salida:

['apple', 'blueberry', 'cherry', 'date']

fruits.insert(1, "banana")
print(fruits)

Salida:

['apple', 'banana', 'blueberry', 'cherry', 'date']

Para eliminar elementos, puedes usar el método remove() o la instrucción del:

fruits.remove("cherry")
print(fruits)

Salida:

['apple', 'banana', 'blueberry', 'date']

del fruits[0]
print(fruits)

Salida:

['banana', 'blueberry', 'date']

Las listas pueden contener elementos de diferentes tipos, incluyendo otras listas:

mixed_list = [1, "hello", 3.14, [1, 2, 3]]
print(mixed_list)

Salida:

[1, 'hello', 3.14, [1, 2, 3]]

Las listas son extremadamente versátiles y se utilizan ampliamente en Python para almacenar colecciones de objetos.

Entendiendo las Tuplas

En este paso, aprenderás sobre las tuplas, que son secuencias ordenadas e inmutables en Python.

En el intérprete de Python, vamos a crear una tupla:

coordinates = (3, 4)
print(coordinates)

Salida:

(3, 4)

Las tuplas se crean utilizando paréntesis ().

Al igual que con las listas, puedes acceder a los elementos de una tupla mediante su índice:

print(coordinates[0])

Salida:

3

print(coordinates[1])

Salida:

4

Sin embargo, a diferencia de las listas, las tuplas son inmutables. Esto significa que no puedes cambiar su contenido después de haberlas creado:

coordinates[0] = 5  ## This will raise an error

Salida:

Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Las tuplas pueden contener elementos de diferentes tipos:

person = ("Alice", 25, "Engineer")
name, age, occupation = person  ## Tuple unpacking
print(f"{name} is {age} years old and works as an {occupation}.")

Salida:

Alice is 25 years old and works as an Engineer.

El desempaquetado de tuplas (tuple unpacking) es una forma muy cómoda de asignar múltiples variables a la vez.

Puedes crear una tupla con un solo elemento, pero recuerda incluir una coma al final:

single_item_tuple = (42,)
print(type(single_item_tuple))

Salida:

<class 'tuple'>

Sin la coma, Python lo interpretará simplemente como un valor normal entre paréntesis.

Las tuplas se utilizan a menudo para devolver múltiples valores desde una función:

def get_dimensions():
    return (1920, 1080)

width, height = get_dimensions()
print(f"Width: {width}, Height: {height}")

Salida:

Width: 1920, Height: 1080

Las tuplas son útiles cuando quieres crear una colección de elementos que no debe ser modificada.

Explorando los Conjuntos (Sets)

En este paso, aprenderás sobre los conjuntos o sets, que son colecciones desordenadas de elementos únicos en Python.

Vamos a crear un conjunto en el intérprete de Python:

fruits = {"apple", "banana", "cherry"}
print(fruits)

Salida:

{'cherry', 'banana', 'apple'}

Los conjuntos se crean usando llaves {} o la función set(). Ten en cuenta que el orden de los elementos puede variar al imprimir un conjunto.

Los conjuntos eliminan automáticamente los elementos duplicados:

numbers = {1, 2, 2, 3, 3, 4}
print(numbers)

Salida:

{1, 2, 3, 4}

Puedes añadir elementos a un conjunto usando el método add():

fruits.add("date")
print(fruits)

Salida:

{'cherry', 'banana', 'apple', 'date'}

Para eliminar elementos, utiliza el método remove():

fruits.remove("banana")
print(fruits)

Salida:

{'cherry', 'apple', 'date'}

Los conjuntos admiten operaciones matemáticas de conjuntos como la unión, la intersección y la diferencia:

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.union(set2))  ## Union

Salida:

{1, 2, 3, 4, 5}

print(set1.intersection(set2))  ## Intersection

Salida:

{3}

print(set1.difference(set2))  ## Difference

Salida:

{1, 2}

Puedes comprobar si un elemento pertenece a un conjunto utilizando la palabra clave in:

print("apple" in fruits)

Salida:

True

print("banana" in fruits)

Salida:

False

Los conjuntos son muy útiles cuando necesitas almacenar elementos únicos o realizar operaciones de álgebra de conjuntos.

Trabajando con Diccionarios

En este paso, aprenderás sobre los diccionarios, que son colecciones desordenadas de pares clave-valor en Python.

Creemos un diccionario en el intérprete de Python:

person = {"name": "Alice", "age": 25, "occupation": "Engineer"}
print(person)

Salida:

{'name': 'Alice', 'age': 25, 'occupation': 'Engineer'}

Los diccionarios se crean utilizando llaves {} con pares clave-valor separados por dos puntos :.

Puedes acceder a los valores del diccionario utilizando sus claves:

print(person["name"])

Salida:

Alice

print(person["age"])

Salida:

25

Los diccionarios son mutables, por lo que puedes añadir o modificar pares clave-valor:

person["city"] = "New York"
person["age"] = 26
print(person)

Salida:

{'name': 'Alice', 'age': 26, 'occupation': 'Engineer', 'city': 'New York'}

Para eliminar un par clave-valor, utiliza la instrucción del:

del person["city"]
print(person)

Salida:

{'name': 'Alice', 'age': 26, 'occupation': 'Engineer'}

Puedes verificar si una clave existe en un diccionario usando la palabra clave in:

print("name" in person)

Salida:

True

print("city" in person)

Salida:

False

Los diccionarios tienen métodos útiles como keys(), values() e items():

print(person.keys())

Salida:

dict_keys(['name', 'age', 'occupation'])

print(person.values())

Salida:

dict_values(['Alice', 26, 'Engineer'])

print(person.items())

Salida:

dict_items([('name', 'Alice'), ('age', 26), ('occupation', 'Engineer')])

Puedes usar la comprensión de diccionarios para crearlos de forma concisa:

squares = {x: x**2 for x in range(5)}
print(squares)

Salida:

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Los diccionarios son extremadamente útiles para almacenar y recuperar datos mediante claves únicas.

Poniéndolo Todo en Práctica

En este paso final, crearás un programa que utiliza todas las estructuras de datos que has aprendido en este laboratorio.

Sal del intérprete de Python escribiendo exit() o presionando Ctrl+D.

Abre el WebIDE en el entorno de la VM de LabEx.

Crea un nuevo archivo llamado contact_manager.py en el directorio ~/project:

touch ~/project/contact_manager.py

Abre el archivo recién creado en el editor del WebIDE y añade el siguiente contenido:

def add_contact(contacts, name, phone, email):
    contacts[name] = {"phone": phone, "email": email}
    print(f"Contact {name} added successfully.")

def remove_contact(contacts, name):
    if name in contacts:
        del contacts[name]
        print(f"Contact {name} removed successfully.")
    else:
        print(f"Contact {name} not found.")

def display_contacts(contacts):
    if contacts:
        print("\nContact List:")
        for name, info in contacts.items():
            print(f"Name: {name}, Phone: {info['phone']}, Email: {info['email']}")
    else:
        print("Contact list is empty.")

def main():
    contacts = {}
    favorite_contacts = set()

    while True:
        print("\nContact Manager")
        print("1. Add Contact")
        print("2. Remove Contact")
        print("3. Display Contacts")
        print("4. Add to Favorites")
        print("5. Display Favorites")
        print("6. Exit")

        choice = input("Enter your choice (1-6): ")

        if choice == "1":
            name = input("Enter name: ")
            phone = input("Enter phone number: ")
            email = input("Enter email: ")
            add_contact(contacts, name, phone, email)
        elif choice == "2":
            name = input("Enter name to remove: ")
            remove_contact(contacts, name)
        elif choice == "3":
            display_contacts(contacts)
        elif choice == "4":
            name = input("Enter name to add to favorites: ")
            if name in contacts:
                favorite_contacts.add(name)
                print(f"{name} added to favorites.")
            else:
                print(f"Contact {name} not found.")
        elif choice == "5":
            print("\nFavorite Contacts:")
            for name in favorite_contacts:
                print(name)
        elif choice == "6":
            print("Thank you for using Contact Manager. Goodbye!")
            break
        else:
            print("Invalid choice. Please try again.")

if __name__ == "__main__":
    main()

Este programa demuestra el uso de diccionarios, conjuntos y listas para crear un sistema sencillo de gestión de contactos.

Guarda el archivo (el guardado automático está activado en WebIDE) y ejecútalo usando el siguiente comando en la terminal:

python ~/project/contact_manager.py

Interactúa con el programa añadiendo contactos, eliminándolos, mostrando la lista, añadiendo contactos a favoritos y visualizando tus favoritos. Aquí tienes un ejemplo de interacción:

Contact Manager
1. Add Contact
2. Remove Contact
3. Display Contacts
4. Add to Favorites
5. Display Favorites
6. Exit
Enter your choice (1-6): 1
Enter name: Alice
Enter phone number: 123-456-7890
Enter email: alice@example.com
Contact Alice added successfully.

Contact Manager
1. Add Contact
2. Remove Contact
3. Display Contacts
4. Add to Favorites
5. Display Favorites
6. Exit
Enter your choice (1-6): 1
Enter name: Bob
Enter phone number: 987-654-3210
Enter email: bob@example.com
Contact Bob added successfully.

Contact Manager
1. Add Contact
2. Remove Contact
3. Display Contacts
4. Add to Favorites
5. Display Favorites
6. Exit
Enter your choice (1-6): 3

Contact List:
Name: Alice, Phone: 123-456-7890, Email: alice@example.com
Name: Bob, Phone: 987-654-3210, Email: bob@example.com

Contact Manager
1. Add Contact
2. Remove Contact
3. Display Contacts
4. Add to Favorites
5. Display Favorites
6. Exit
Enter your choice (1-6): 4
Enter name to add to favorites: Alice
Alice added to favorites.

Contact Manager
1. Add Contact
2. Remove Contact
3. Display Contacts
4. Add to Favorites
5. Display Favorites
6. Exit
Enter your choice (1-6): 5

Favorite Contacts:
Alice

Contact Manager
1. Add Contact
2. Remove Contact
3. Display Contacts
4. Add to Favorites
5. Display Favorites
6. Exit
Enter your choice (1-6): 6
Thank you for using Contact Manager. Goodbye!

Este programa ilustra la aplicación práctica de los diccionarios (para almacenar la información de contacto), los conjuntos (para guardar los contactos favoritos) y las listas (utilizadas implícitamente en el sistema de menús).

Resumen

En este laboratorio, has explorado las estructuras de datos fundamentales de Python: listas, tuplas, conjuntos y diccionarios. Has aprendido a crear, manipular y utilizar estas versátiles herramientas, que son esenciales para una gestión eficiente de los datos en la programación con Python.

Comenzaste trabajando con listas, aprendiendo a crear, acceder y modificar colecciones ordenadas de elementos. Luego exploraste las tuplas, comprendiendo su naturaleza inmutable y sus casos de uso para representar colecciones fijas de elementos. A continuación, profundizaste en los conjuntos, descubriendo su capacidad para almacenar elementos únicos y realizar operaciones matemáticas de conjuntos. Finalmente, trabajaste con diccionarios, aprendiendo a gestionar pares clave-valor para la búsqueda y el almacenamiento eficiente de datos.

Para reforzar estos conceptos, creaste un programa práctico de gestión de contactos que utilizaba múltiples estructuras de datos. Este programa demostró cómo diferentes estructuras pueden trabajar juntas en una aplicación del mundo real, mostrando la potencia y flexibilidad de las estructuras de datos de Python.

Estas estructuras forman la columna vertebral de muchos programas en Python, permitiéndote organizar y manipular datos de manera eficiente. A medida que continúes tu camino con Python, verás que estas estructuras son invaluables para resolver una amplia gama de problemas de programación. Recuerda practicar su uso en diversos escenarios para consolidar tu comprensión y volverte más competente en la programación con Python.