Resumen de Estructuras de Datos en Python

📋 Lista de Estructuras de Datos

1. Listas [] - Mutable y Ordenada

python

mi_lista = [1, 2, 3, "hola", True]

Características:

• ✅ Ordenada

• ✅ Mutable (puede cambiar)

• ✅ Permite duplicados

• ✅ Indexada (acceso por posición)

Operaciones principales:

python

# Modificación
mi_lista.append(4)           # Añadir al final
mi_lista.insert(1, "nuevo")  # Insertar en posición
mi_lista.remove(2)           # Eliminar elemento
mi_lista.pop()               # Eliminar último

# Búsqueda
mi_lista.index("hola")       # Encontrar posición
mi_lista.count(1)            # Contar ocurrencias

# Orden
mi_lista.sort()              # Ordenar
mi_lista.reverse()           # Invertir

Uso ideal: Colecciones que necesitan modificación frecuente.

---

2. Tuplas () - Inmutable y Ordenada

python

mi_tupla = (1, 2, 3, "hola")
tupla_un_elemento = (1,)     # ¡Importante la coma!

Características:

• ✅ Ordenada

• ❌ Inmutable (NO puede cambiar)

• ✅ Permite duplicados

• ✅ Indexada

Métodos disponibles:

python

mi_tupla.count(2)    # Contar elementos
mi_tupla.index("hola")  # Encontrar posición

Uso ideal: Datos constantes, retorno múltiple de funciones, claves en diccionarios.

---

3. Diccionarios {} - Mutable y No Ordenada (Python < 3.7)

python

mi_dict = {"nombre": "Ana", "edad": 25, "ciudad": "Madrid"}

Características:

• ✅ Pares clave-valor

• ✅ Mutable

• ❌ No ordenada (hasta Python 3.6)

• ✅ Claves únicas

• ❌ No indexada por posición

Operaciones principales:

python

# Acceso
mi_dict["nombre"]                # Ana
mi_dict.get("edad", 0)           # 25 (0 si no existe)

# Modificación
mi_dict["edad"] = 26             # Actualizar
mi_dict["profesion"] = "Ingeniera"  # Añadir nuevo
mi_dict.update({"ciudad": "Barcelona", "pais": "España"})

# Eliminación
del mi_dict["ciudad"]
valor = mi_dict.pop("edad")

# Información
mi_dict.keys()                   # Claves
mi_dict.values()                 # Valores
mi_dict.items()                  # Pares (clave, valor)

Uso ideal: Datos estructurados, configuraciones, JSON-like.

---

4. Sets {} - Mutable y No Ordenada

python

mi_set = {1, 2, 3, 4, 5}
mi_set_vacio = set()  # ¡No usar {} que crea dict!

Características:

• ❌ No ordenada

• ✅ Mutable

• ❌ No permite duplicados

• ❌ No indexada

Operaciones principales:

python

# Modificación
mi_set.add(6)                    # Añadir elemento
mi_set.remove(3)                 # Eliminar (error si no existe)
mi_set.discard(10)               # Eliminar (sin error)
mi_set.pop()                     # Eliminar aleatorio

# Operaciones de conjunto
set1 = {1, 2, 3}
set2 = {3, 4, 5}

set1.union(set2)                 # {1, 2, 3, 4, 5}
set1.intersection(set2)          # {3}
set1.difference(set2)            # {1, 2}
set1.symmetric_difference(set2)  # {1, 2, 4, 5}

Uso ideal: Eliminar duplicados, operaciones matemáticas de conjuntos.

---

5. Frozenset - Set Inmutable

python

mi_frozenset = frozenset([1, 2, 3, 4])

Características:

• ❌ No ordenada

• ❌ Inmutable

• ❌ No permite duplicados

Uso ideal: Sets que deben ser inmutables, claves en diccionarios.

---

6. NamedTuple - Tupla con Nombres

python

from collections import namedtuple

Persona = namedtuple('Persona', ['nombre', 'edad'])
persona = Persona("Carlos", 30)

Características:

• ✅ Ordenada

• ❌ Inmutable

• ✅ Acceso por nombre e índice

Uso ideal: Estructuras similares a clases pero más ligeras.

---

7. Deque - Lista de Doble Extremo

python

from collections import deque

mi_deque = deque([1, 2, 3])

Características:

• ✅ Optimizada para operaciones en ambos extremos

• ✅ Más eficiente que listas para colas

Operaciones:

python

mi_deque.appendleft(0)    # Añadir al inicio
mi_deque.popleft()        # Eliminar del inicio

Uso ideal: Colas, stacks, operaciones FIFO/LIFO.

---

📊 Tabla Comparativa

Estructura	Mutabilidad	Orden	Indexación	Duplicados	Uso Principal
Lista	✅ Mutable	✅ Ordenada	✅ Por índice	✅ Permitidos	Colecciones modificables
Tupla	❌ Inmutable	✅ Ordenada	✅ Por índice	✅ Permitidos	Datos constantes
Diccionario	✅ Mutable	✅ Ordenada*	✅ Por clave	❌ Claves únicas	Datos estructurados
Set	✅ Mutable	❌ No ordenada	❌ No indexada	❌ No permitidos	Elementos únicos
Frozenset	❌ Inmutable	❌ No ordenada	❌ No indexada	❌ No permitidos	Sets inmutables
NamedTuple	❌ Inmutable	✅ Ordenada	✅ Por nombre/índice	✅ Permitidos	Estructuras ligeras

*Los diccionarios mantienen orden de inserción desde Python 3.7

---

🎯 Guía Rápida de Elección

¿Cuál estructura usar?

• ¿Necesitas modificar datos frecuentemente? → Lista

• ¿Datos constantes o claves de diccionario? → Tupla

• ¿Datos estructurados con claves descriptivas? → Diccionario

• ¿Eliminar duplicados u operaciones de conjunto? → Set

• ¿Colección ordenada con nombres de campos? → NamedTuple

• ¿Operaciones eficientes en ambos extremos? → Deque

---

🔄 Conversiones entre Estructuras

python

# Lista a otras estructuras
mi_lista = [1, 2, 2, 3, 4]

lista = list(mi_lista)                    # Mantener como lista
tupla = tuple(mi_lista)                   # A tupla
conjunto = set(mi_lista)                  # A set (elimina duplicados)
diccionario = dict(enumerate(mi_lista))   # A dict con índices como claves

# Diccionario a otras
mi_dict = {"a": 1, "b": 2}

claves = list(mi_dict.keys())             # Lista de claves
valores = list(mi_dict.values())          # Lista de valores
pares = list(mi_dict.items())             # Lista de tuplas (clave, valor)

---

💡 Consejos de Uso

1. Listas: Usa comprensiones de lista para transformaciones

2. Diccionarios: Usa .get() para evitar KeyError

3. Sets: Perfectos para verificar pertenencia (más rápido que listas)

4. Tuplas: Más eficientes en memoria que listas

5. NamedTuple: Mejor legibilidad que tuplas normales

En Python NO hay una sintaxis específica para pilas y colas. Usamos estructuras existentes y las limitamos para que se comporten como pilas o colas.

python

# ¡ESTA ES LA CLAVE!
pila = []           # Se VE como lista, pero se USA como pila
cola = deque([])    # Se VE como deque, pero se USA como cola

🎯 La Diferencia NO está en la SINTAXIS, sino en el USO

Pila = Lista con restricciones

python

# DEFINICIÓN: Una pila es una lista que SOLO usas de esta forma:

pila = []  # Se ve como lista, pero...

# SÓLO estas operaciones la hacen pila:
pila.append(1)    # ✅ Apilar - añadir al FINAL
pila.append(2)
pila.append(3)

ultimo = pila.pop()  # ✅ Desapilar - sacar del FINAL
# pila.pop(0)        # ❌ Esto NO es pila
# pila.insert(0, x)  # ❌ Esto NO es pila

print(ultimo)  # 3 (LIFO: último en entrar, primero en salir)

Cola = Deque con restricciones

python

from collections import deque

# DEFINICIÓN: Una cola es un deque que SOLO usas de esta forma:

cola = deque()  # Se ve como deque, pero...

# SÓLO estas operaciones la hacen cola:
cola.append(1)       # ✅ Encolar - añadir al FINAL
cola.append(2)
cola.append(3)

primero = cola.popleft()  # ✅ Desencolar - sacar del PRINCIPIO
# cola.pop()              # ❌ Esto NO es cola
# cola.appendleft(x)      # ❌ Esto NO es cola estándar

print(primero)  # 1 (FIFO: primero en entrar, primero en salir)

🧠 La CLAVE: Te toca a TI definir el comportamiento

Ejemplo: La MISMA lista puede ser pila O cola

python

mi_lista = [1, 2, 3]

# Si la uso ASÍ es una PILA:
mi_lista.append(4)    # Apilar
ultimo = mi_lista.pop()  # Desapilar
print("Es una pila:", ultimo)  # 4

# Si la uso ASÍ es una COLA (ineficiente):
mi_lista.append(5)    # Encolar
primero = mi_lista.pop(0)  # Desencolar
print("Es una cola:", primero)  # 1

📋 Resumen Visual: Cómo SABER qué es cada cosa

PILA = Lista + Disciplina LIFO

python

pila = []                    # Se crea como lista
pila.append("documento1")    # Apilar
pila.append("documento2")    
pila.append("documento3")

# COMPORTAMIENTO PILA:
ultimo = pila.pop()          # Saco "documento3" (el ÚLTIMO que entró)
print(ultimo)                # documento3 ← LIFO

 PILAS con Listas (Sencillo)

python

# Una PILA es simplemente una lista que usas de una forma ESPECIAL

pila = []  # Lista normal

# Para usarla como PILA, solo usas 2 operaciones:
pila.append(10)  # 1. Meter elementos al FINAL
pila.append(20)
pila.append(30)

print(pila)  # [10, 20, 30]

# Y solo sacas del FINAL
ultimo = pila.pop()  # 2. Sacar el ÚLTIMO elemento
print(ultimo)  # 30
print(pila)    # [10, 20]

Regla de la pila: "El último que entra es el primero que sale"

📚 COLAS con Listas (Sencillo)

python

# Una COLA es simplemente una lista que usas de otra forma ESPECIAL

cola = []  # Lista normal

# Para usarla como COLA:
cola.append("Ana")    # 1. Meter elementos al FINAL
cola.append("Carlos")
cola.append("María")

print(cola)  # ['Ana', 'Carlos', 'María']

# Pero sacas del PRINCIPIO
primero = cola.pop(0)  # 2. Sacar el PRIMER elemento
print(primero)  # Ana
print(cola)     # ['Carlos', 'María']

Regla de la cola: "El primero que entra es el primero que sale"

🎯 La DIFERENCIA Fundamental

python

# MISMA lista, COMPORTAMIENTO diferente

lista = []

# Si la uso ASÍ es PILA:
lista.append("A")
lista.append("B")
lista.append("C")
elemento = lista.pop()    # Saco "C" (el ÚLTIMO)
print("Pila:", elemento)  # C

# Si la uso ASÍ es COLA:
lista.append("X")
lista.append("Y") 
lista.append("Z")
elemento = lista.pop(0)   # Saco "X" (el PRIMERO)  
print("Cola:", elemento)  # X

📊 Resumen Super Sencillo

Concepto	Cómo meter	Cómo sacar	Ejemplo de la vida real
PILA	append()	pop()	Pila de platos
COLA	append()	pop(0)	Fila del banco

🧠 Ejemplos Prácticos SIN deque

Ejemplo 1: Navegador Web (PILA)

python

# PILA de páginas visitadas
historial = []

def visitar_pagina(pagina):
    historial.append(pagina)
    print(f"Visitando: {pagina}")

def retroceder():
    if len(historial) > 1:
        historial.pop()  # Saco la página actual
        pagina_anterior = historial[-1]  # Veo la anterior
        print(f"Volviendo a: {pagina_anterior}")
        return pagina_anterior
    return None

# Uso
visitar_pagina("google.com")     # Visitando: google.com
visitar_pagina("youtube.com")    # Visitando: youtube.com  
visitar_pagina("facebook.com")   # Visitando: facebook.com

retroceder()  # Volviendo a: youtube.com

Ejemplo 2: Fila de Impresión (COLA)

python

# COLA de documentos a imprimir
fila_impresion = []

def agregar_documento(documento):
    fila_impresion.append(documento)
    print(f"Agregado: {documento}")

def imprimir_siguiente():
    if fila_impresion:
        documento = fila_impresion.pop(0)  # Saco el PRIMERO
        print(f"Imprimiendo: {documento}")
        return documento
    print("No hay documentos en la fila")
    return None

# Uso
agregar_documento("Tarea matemáticas")  # Agregado: Tarea matemáticas
agregar_documento("Contrato trabajo")   # Agregado: Contrato trabajo
agregar_documento("Receta médica")      # Agregado: Receta médica

imprimir_siguiente()  # Imprimiendo: Tarea matemáticas
imprimir_siguiente()  # Imprimiendo: Contrato trabajo

💡 Truco para Recordar

PILA = pop() SIN número

python

pila = []
pila.append(1)
pila.append(2)
pila.append(3)

print(pila.pop())   # 3 ← ÚLTIMO que entró
print(pila.pop())   # 2
print(pila.pop())   # 1 ← PRIMERO que entró

COLA = pop(0) CON cero

python

cola = []
cola.append(1)
cola.append(2) 
cola.append(3)

print(cola.pop(0))  # 1 ← PRIMERO que entró
print(cola.pop(0))  # 2
print(cola.pop(0))  # 3 ← ÚLTIMO que entró

🚨 Nota sobre Eficiencia

python

# Para PROGRAMAS PEQUEÑOS está BIEN usar listas
cola = []
cola.append(1)
cola.append(2)
elemento = cola.pop(0)  # ✅ OK para pocos elementos

# Para programas GRANDES con MUCHOS datos:
from collections import deque  # Esto sería más eficiente
cola_grande = deque()
cola_grande.append(1)
cola_grande.append(2) 
elemento = cola_grande.popleft()  # Más rápido para muchos elementos

✅ Conclusión para Principiantes

1. PILA = Lista + pop() (sin número)

2. COLA = Lista + pop(0) (con cero)

3. La diferencia está en cómo sacas los elementos

4. Para empezar, olvídate de deque

COLA = Deque + Disciplina FIFO

python

from collections import deque

cola = deque()               # Se crea como deque
cola.append("persona1")      # Encolar
cola.append("persona2")
cola.append("persona3")

# COMPORTAMIENTO COLA:
primero = cola.popleft()     # Saco "persona1" (el PRIMERO que entró)
print(primero)               # persona1 ← FIFO

🚨 ¿Por qué esta confusión?

Python es un lenguaje de tipado dinámico que prefiere:

• No crear syntax nueva para cada concepto

• Reutilizar estructuras existentes

• Confiarnos la disciplina de uso

💡 Truco Práctico: Nomenclatura

Para evitar confusiones, usa nombres descriptivos:

python

# ✅ CLARO - Sabes inmediatamente qué es
pila_documentos = []
cola_clientes = deque()

# ❌ CONFUSO - ¿Es lista normal o pila?
lista1 = []
lista2 = deque()

🎯 Reglas Mnemotécnicas

Para PILAS:

"Saco siempre el ÚLTIMO que metí"
Como una pila de platos - sacas el de arriba

Para COLAS:

"Atiendo siempre al PRIMERO que llegó"
Como la fila del banco - atiendes al primero en llegar

🔄 Ejemplo Real: Editor de Texto

python

# PILA para undo/redo
historial_undo = []  # ¡Se VE como lista!
historial_redo = []  # ¡Se VE como lista!

# Operaciones como PILA:
def hacer_cambio(accion):
    historial_undo.append(accion)  # APILAR
    historial_redo.clear()

def deshacer():
    if historial_undo:
        accion = historial_undo.pop()  # DESAPILAR (LIFO)
        historial_redo.append(accion)
        return accion
    return None

def rehacer():
    if historial_redo:
        accion = historial_redo.pop()  # DESAPILAR (LIFO)
        historial_undo.append(accion)
        return accion
    return None

✅ Conclusión Final

• Pila = Lista que solo usas con append() y pop()

• Cola = Deque que solo usas con append() y popleft()

• La diferencia NO está en cómo se crean, sino en cómo los usas

¡Tú decides si esa estructura se comporta como pila, cola o lista normal!

¿Ahora tiene más sentido? ¡Es normal confundirse al principio!