Colas en Python: entendiendo FIFO y LIFO con ejemplos prácticos

Colas en Python: entendiendo FIFO y LIFO con ejemplos prácticos

¿Qué es una cola en Python?

Una cola es una estructura de datos que almacena elementos en orden lineal. Los elementos se añaden al final y se eliminan desde el frente, siguiendo el principio First-In, First-Out (FIFO - Primero en entrar, primero en salir). La cola expone dos extremos lógicos: frente y final —encolar en el final, desencolar desde el frente.

En este tutorial aprenderás:

• Cómo funciona el módulo queue de Python.
• Tipos de colas disponibles en Python.
• Cómo importar el módulo.
• Métodos clave en objetos Queue y LifoQueue.
• Ejemplos prácticos para colas FIFO y LIFO.
• Operaciones por lotes, ordenación e inversión de colas.

Cómo funciona el módulo Queue

El comportamiento es análogo a una fila física: la primera persona en la fila es la primera en ser atendida. En la estructura de datos cola, el elemento que se encola primero será el primero en desencolarse.

El punto final (rear) es donde se insertan nuevos elementos (p. ej., valor 7). El punto frente (front) es donde salen los elementos de la cola; eliminar el primer elemento produce el valor 1.

Como la cola es lineal, no puedes eliminar un elemento arbitrario en el medio; debes desencolar todos los elementos precedentes primero.

Tipos de colas en Python

El módulo queue de Python ofrece dos clases principales de cola:

• Cola FIFO – usa Queue(). El elemento más antiguo siempre es el primero en ser removido.
• Cola LIFO – usa LifoQueue(). El elemento añadido más recientemente se devuelve primero.

Primeros pasos: Importando el módulo

Python incluye el módulo queue por defecto; no se requiere instalación externa.

import queue

Instanciar una cola FIFO:

q1 = queue.Queue()

Instanciar una cola LIFO:

q1 = queue.LifoQueue()

Métodos clave

Tanto Queue como LifoQueue exponen la misma API principal:

• put(item) – encola un elemento.
• get() – desencola y devuelve el siguiente elemento.
• empty() – devuelve True si la cola no tiene elementos.
• full() – devuelve True si la cola ha alcanzado su tamaño máximo.
• qsize() – devuelve el número actual de elementos.

Ejemplo de cola FIFO

Encolar un solo elemento

import queue
q1 = queue.Queue()
q1.put(10)  # añade 10 a la cola

Encolar múltiples elementos con límite de tamaño

q1 = queue.Queue(maxsize=5)  # máximo 5 elementos
for i in range(1, 6):
    q1.put(i)
print(q1.full())  # → True

Salida:

True

Desencolar un elemento

elemento = q1.get()
print('Elemento desencolado:', elemento)

Salida:

Elemento desencolado: 10

Ejemplo de cola LIFO

Encolar un solo elemento

q1 = queue.LifoQueue()
q1.put(10)

Desencolar un elemento

elemento = q1.get()
print('Desencolado de LIFO:', elemento)

Salida:

Desencolado de LIFO: 10

Operaciones por lotes

FIFO – Encolar 20 números

q1 = queue.Queue()
for i in range(20):
    q1.put(i)

FIFO – Desencolar todo

while not q1.empty():
    print('Valor:', q1.get())

Salida:

Valor: 0
Valor: 1
...
Valor: 19

LIFO – Encolar 20 números

q1 = queue.LifoQueue()
for i in range(20):
    q1.put(i)

LIFO – Desencolar todo

while not q1.empty():
    print('Valor:', q1.get())

Salida:

Valor: 19
Valor: 18
...
Valor: 0

Ordenación de una cola (Burbuja)

q1 = queue.Queue()
for item in [11, 5, 4, 21, 3, 10]:
    q1.put(item)

n = q1.qsize()
for i in range(n):
    x = q1.get()
    for j in range(n-1):
        y = q1.get()
        if x > y:
            q1.put(y)
        else:
            q1.put(x)
        x = y
    q1.put(x)

while not q1.empty():
    print(q1.queue[0], end=' ')
    q1.get()

Salida:

3 4 5 10 11 21

Inversión de una cola usando recursión

def invertir_cola(origen, destino):
    item = origen.get()
    if not origen.empty():
        invertir_cola(origen, destino)
    destino.put(item)
    return destino

q1 = queue.Queue()
for item in [11, 5, 4, 21, 3, 10]:
    q1.put(item)

q2 = queue.Queue()
invertir_cola(q1, q2)

while not q2.empty():
    print(q2.queue[0], end=' ')
    q2.get()

Salida:

10 3 21 4 5 11

Resumen rápido

• queue.Queue de Python implementa FIFO; queue.LifoQueue implementa LIFO.
• Usa put() para encolar y get() para desencolar.
• Ambas clases exponen empty(), full() y qsize() para inspección de estado.
• Puedes establecer un tamaño máximo en una cola FIFO; intentar put() más allá de eso bloqueará hasta que se libere espacio.
• La ordenación e inversión son posibles con algoritmos estándar, aunque deque de collections a menudo ofrece más flexibilidad.