Las estructuras de datos son esenciales en la programación para organizar, almacenar y manipular eficientemente la información. En este artículo, exploraremos tres estructuras fundamentales en Python: las listas, las pilas y las colas. Cada una tiene características específicas que las hacen útiles para diferentes tipos de problemas.

### Listas en Python
Las listas son colecciones ordenadas y mutables que permiten almacenar elementos de cualquier tipo. Se definen con corchetes y pueden modificarse añadiendo, eliminando o cambiando elementos.

Ejemplo:
“`python
mi_lista = [10, 20, 30, 40]
mi_lista.append(50) # Añade un elemento al final
print(mi_lista) # Salida: [10, 20, 30, 40, 50]
“`

Las listas permiten acceso por índices, iteración y tienen numerosas funciones útiles como `sort()`, `reverse()`, entre otras.

### Pilas (Stacks)
Una pila es una estructura LIFO (Last In First Out), donde el último elemento que se inserta es el primero en salir. Es muy usada en programas que requieren deshacer acciones, evaluaciones de expresiones, o llamadas recursivas.

Implementación básica de una pila en Python:
“`python
class Pila:
def __init__(self):
self.items = []
def esta_vacia(self):
return len(self.items) == 0
def push(self, item):
self.items.append(item)
def pop(self):
if not self.esta_vacia():
return self.items.pop()
return None

pila = Pila()
pila.push(1)
pila.push(2)
print(pila.pop()) # Salida: 2
“`

### Colas (Queues)
Las colas siguen el principio FIFO (First In First Out), donde el primer elemento que entra es el primero en salir. Son útiles en sistemas de impresión, gestión de tareas o cualquier flujo de proceso ordenado.

La implementación eficiente en Python usa `collections.deque`:
“`python
from collections import deque

class Cola:
def __init__(self):
self.items = deque()
def esta_vacia(self):
return len(self.items) == 0
def enqueue(self, item):
self.items.append(item)
def dequeue(self):
if not self.esta_vacia():
return self.items.popleft()
return None

cola = Cola()
cola.enqueue(‘primero’)
cola.enqueue(‘segundo’)
print(cola.dequeue()) # Salida: primero
“`

### Conclusión
Entender y dominar estas estructuras te ayudará a escribir código más limpio y eficiente. Python facilita su uso con sintaxis sencilla y herramientas integradas, siendo ideal para quienes quieren profundizar en conceptos clave de la programación.

Code Example:

# Ejemplo completo mostrando lista, pila y cola en Python

# Listas
def ejemplo_lista():
lista = [1, 2, 3]
lista.append(4)
return lista

# Pila
class Pila:
def __init__(self):
self.items = []
def esta_vacia(self):
return len(self.items) == 0
def push(self, item):
self.items.append(item)
def pop(self):
if not self.esta_vacia():
return self.items.pop()
return None

# Cola
from collections import deque

class Cola:
def __init__(self):
self.items = deque()
def esta_vacia(self):
return len(self.items) == 0
def enqueue(self, item):
self.items.append(item)
def dequeue(self):
if not self.esta_vacia():
return self.items.popleft()
return None

# Uso
if __name__ == '__main__':
print('Lista:', ejemplo_lista())

pila = Pila()
pila.push('elemento A')
pila.push('elemento B')
print('Pop pila:', pila.pop()) # elemento B

cola = Cola()
cola.enqueue('tarea 1')
cola.enqueue('tarea 2')
print('Dequeue cola:', cola.dequeue()) # tarea 1