Laboratorio de Pilas y Colas en Python

Conceptos que necesitas

Antes de programar, entendamos cómo se guardan los datos y por qué el orden cambia todo.

Paso 1 · ¿Qué es una variable?

Una variable es un nombre que apunta a un dato guardado en la memoria. Piensa en una caja con etiqueta: la etiqueta es el nombre y lo que hay adentro es el valor. En Python se crea con el signo =.

nombre = "Laura"      # texto (str)
edad = 19             # número entero (int)
promedio = 4.3        # número decimal (float)
activo = True         # verdadero o falso (bool)
materias = ["SQL", "Python", "Redes"]   # lista (list)

La variable materias es especial: guarda varios valores en orden. Esa idea de "varios datos en orden" es la base de las pilas y las colas.

nombre"Laura"

edad19

promedio4.3

activoTrue

materias

0"SQL"1"Python"2"Redes"

Paso 2 · Las listas y sus posiciones

Cada elemento de una lista tiene una posición (índice) que empieza en 0. Python también permite contar desde el final con números negativos: -1 es el último.

materias = ["SQL", "Python", "Redes"]
print(materias[0])    # SQL     -> el primero
print(materias[-1])   # Redes   -> el último
print(len(materias))  # 3       -> cuántos hay
materias.append("Web")        # agrega al final
print(materias)       # ['SQL', 'Python', 'Redes', 'Web']

Idea clave

Una pila y una cola son listas con reglas: no puedes sacar o meter datos en cualquier posición, solo por los extremos permitidos. Esas reglas son las que las hacen útiles.

Paso 3 · ¿Qué es una estructura de datos?

Es una forma de organizar los datos para usarlos de manera eficiente. La misma información se puede guardar de muchas formas; elegir la estructura correcta hace que el programa sea más claro y más rápido. Las pilas y las colas son dos de las estructuras lineales más usadas en software: están detrás del botón Atrás del navegador, del Ctrl+Z, de la cola de impresión y de los turnos de un banco.

Paso 4

La PILA (stack)

LIFO · Last In, First Out · el último en entrar es el primero en salir.

Imagina una torre de platos: pones uno encima del otro y siempre tomas el de arriba. Nunca sacas el plato de abajo sin quitar los demás.

Operación	Qué hace
apilar (push)	pone un dato en el tope
desapilar (pop)	saca el dato del tope
ver tope (peek)	mira el tope sin sacarlo
está vacía	¿no tiene datos?
tamaño	cuántos datos tiene

Dónde se usa: deshacer (Ctrl+Z), botón Atrás, llamadas a funciones (la "pila de llamadas"), revisar paréntesis en un compilador.

Paso 5

La COLA (queue)

FIFO · First In, First Out · el primero en entrar es el primero en salir.

Es la fila del banco: quien llega se ubica al final y se atiende a quien está al frente. Nadie se cuela.

Operación	Qué hace
encolar (enqueue)	agrega un dato al final
desencolar (dequeue)	saca el dato del frente
ver frente (front)	mira el frente sin sacarlo
está vacía	¿no tiene datos?
tamaño	cuántos datos tiene

Dónde se usa: cola de impresión, turnos y atención al cliente, mensajes entre programas, descargas en espera.

Paso 6 · Comparación rápida

	Pila	Cola
Regla	LIFO	FIFO
¿Por dónde entra?	por el tope	por el final
¿Por dónde sale?	por el tope (el mismo extremo)	por el frente (el extremo contrario)
En Python	`lista.append(x)` / `lista.pop()`	`deque.append(x)` / `deque.popleft()`
Ejemplo cotidiano	torre de platos	fila del banco

Paso 7 · Comprueba que entendiste

Pilas y colas en Python

Python no trae un tipo "Pila" ni "Cola" con ese nombre: las construimos con herramientas que ya existen.

La pila con una lista

pila = []              # pila vacía

pila.append("A")       # apilar
pila.append("B")
pila.append("C")       # pila = ['A', 'B', 'C']

print(pila[-1])        # ver tope      -> C
print(pila.pop())      # desapilar     -> C
print(len(pila))       # tamaño        -> 2
print(not pila)        # ¿está vacía?  -> False

La cola con deque

from collections import deque

cola = deque()         # cola vacía

cola.append("A")       # encolar
cola.append("B")
cola.append("C")       # cola = deque(['A', 'B', 'C'])

print(cola[0])         # ver frente    -> A
print(cola.popleft())  # desencolar    -> A
print(len(cola))       # tamaño        -> 2
print(not cola)        # ¿está vacía?  -> False

¿Por qué deque y no una lista para la cola?

Se podría usar lista.pop(0) para sacar el primero, pero cada vez que lo haces Python tiene que correr todos los demás elementos una posición. Con 10 datos no se nota; con un millón, sí. deque.popleft() saca el frente sin mover nada, por eso es la forma recomendada.

Errores típicos

pop() en una pila o popleft() en una cola vacía produce IndexError. Revisa antes con if pila:.
Confundir pop() (saca el último) con pop(0) (saca el primero).
Olvidar from collections import deque al inicio del archivo.
No nombres tu archivo collections.py ni queue.py: Python importaría tu archivo en lugar del módulo real.

Chuleta de operaciones

Operación	Pila (lista)	Cola (deque)
Crear vacía	`pila = []`	`cola = deque()`
Crear con datos	`pila = [1, 2, 3]`	`cola = deque([1, 2, 3])`
Agregar	`pila.append(x)`	`cola.append(x)`
Sacar	`pila.pop()`	`cola.popleft()`
Consultar sin sacar	`pila[-1]`	`cola[0]`
Tamaño	`len(pila)`	`len(cola)`
¿Vacía?	`not pila`	`not cola`
Recorrer sacando	`while pila: pila.pop()`	`while cola: cola.popleft()`

Simulador de pilas y colas

Cada botón que pulses genera la línea de Python equivalente. Observa qué entra, qué sale y en qué orden.

Valor sugerir siguiente letra

pilalista · LIFO

pila vacía

len(pila) = 0

coladeque · FIFO

cola vacía

len(cola) = 0

simulacion.py

# El código aparece aquí a medida que operas
from collections import deque
pila = []
cola = deque()

Salida / variables

>>> listo para simular

Reto rápido · ¿qué queda al final?

Se generan operaciones al azar. Ejecútalas en tu cabeza y elige el resultado. Luego compruébalo en el simulador.

Aciertos: 0 de 0

13 ejercicios: de sencillo a reto

Cada ejercicio trae el código base, la salida que debe aparecer y una tarea que tú agregas. Primero lo pruebas tal cual, luego haces la tarea en VS Code.

Regla de autoría

En todos los archivos cambia la primera línea por tu nombre real: print("Estudiante: Tu Nombre Completo"). Ese nombre debe verse en la terminal de tu pantallazo; sin él, la evidencia no cuenta.

ej01_primera_pila.py descargar .py

# Ejercicio 1 - Mi primera pila
# Una lista de Python funciona como pila: se agrega y se saca por el final (el tope).
print("Estudiante: ESCRIBE AQUÍ TU NOMBRE")

pila = []                      # pila vacía
pila.append("Libro de Python") # apilar (push)
pila.append("Libro de SQL")
pila.append("Libro de Redes")

print("Pila:", pila)
print("Tope:", pila[-1])       # el último elemento es el tope
print("Tamaño:", len(pila))

Salida esperada (código base)

Estudiante: ESCRIBE AQUÍ TU NOMBRE
Pila: ['Libro de Python', 'Libro de SQL', 'Libro de Redes']
Tope: Libro de Redes
Tamaño: 3

Tu tarea

Apila dos libros más (de tu carrera) y vuelve a imprimir la pila, el tope y el tamaño.

Ver pista

append() pone el elemento en el tope; pila[-1] lo consulta sin sacarlo.

Lo hice en VS Code

ej02_desapilar.py descargar .py

# Ejercicio 2 - Desapilar: el último en entrar es el primero en salir (LIFO)
print("Estudiante: ESCRIBE AQUÍ TU NOMBRE")

pila = [10, 20, 30, 40]
print("Pila inicial:", pila)

sacado = pila.pop()            # desapilar (pop) devuelve el elemento del tope
print("Saqué:", sacado)
sacado = pila.pop()
print("Saqué:", sacado)

print("Pila final:", pila)

Salida esperada (código base)

Estudiante: ESCRIBE AQUÍ TU NOMBRE
Pila inicial: [10, 20, 30, 40]
Saqué: 40
Saqué: 30
Pila final: [10, 20]

Tu tarea

Apila tus tres materias favoritas y desapílalas todas mostrando cada una al salir.

Ver pista

pop() sin parámetros siempre retira el último elemento de la lista.

Lo hice en VS Code

ej03_pila_vacia.py descargar .py

# Ejercicio 3 - Revisar antes de sacar: la pila vacía
print("Estudiante: ESCRIBE AQUÍ TU NOMBRE")

pila = ["A"]

def desapilar_seguro(p):
    if len(p) == 0:            # también sirve: if not p:
        return "La pila está vacía"
    return p.pop()

print(desapilar_seguro(pila))
print(desapilar_seguro(pila))  # ya no queda nada

# TU TAREA: crea la función ver_tope(p) que devuelva el tope SIN sacarlo
# (o el mensaje "La pila está vacía") y pruébala.

Salida esperada (código base)

Estudiante: ESCRIBE AQUÍ TU NOMBRE
A
La pila está vacía

Tu tarea

Crea la función ver_tope(p) que devuelva el tope sin sacarlo y pruébala con una pila llena y una vacía.

Ver pista

Una lista vacía se evalúa como False: if not p: ...

Lo hice en VS Code

ej04_primera_cola.py descargar .py

# Ejercicio 4 - Mi primera cola con deque
# deque (de collections) saca por el frente de forma rápida con popleft().
from collections import deque
print("Estudiante: ESCRIBE AQUÍ TU NOMBRE")

cola = deque()
cola.append("Ana")             # encolar (enqueue) por el final
cola.append("Luis")
cola.append("Sofía")
print("Cola:", list(cola))

atendido = cola.popleft()      # desencolar (dequeue) por el frente
print("Atendido:", atendido)
print("Siguiente:", cola[0])   # el frente es la posición 0
print("Cola:", list(cola))

Salida esperada (código base)

Estudiante: ESCRIBE AQUÍ TU NOMBRE
Cola: ['Ana', 'Luis', 'Sofía']
Atendido: Ana
Siguiente: Luis
Cola: ['Luis', 'Sofía']

Tu tarea

Encola a cinco compañeros de clase, atiende a dos y muestra quién sigue.

Ver pista

append() entra por el final; popleft() sale por el frente; cola[0] es el frente.

Lo hice en VS Code

ej05_atender_hasta_vaciar.py descargar .py

# Ejercicio 5 - Atender la cola hasta vaciarla (FIFO)
from collections import deque
print("Estudiante: ESCRIBE AQUÍ TU NOMBRE")

cola = deque(["Turno 1", "Turno 2", "Turno 3", "Turno 4"])

while cola:                    # mientras la cola NO esté vacía
    turno = cola.popleft()
    print("Atendiendo:", turno, "| quedan", len(cola))

print("No hay más turnos")

Salida esperada (código base)

Estudiante: ESCRIBE AQUÍ TU NOMBRE
Atendiendo: Turno 1 | quedan 3
Atendiendo: Turno 2 | quedan 2
Atendiendo: Turno 3 | quedan 1
Atendiendo: Turno 4 | quedan 0
No hay más turnos

Tu tarea

Simula la fila de la cafetería con 6 pedidos e imprime el pedido y cuántos quedan.

Ver pista

while cola: se repite mientras la cola tenga elementos.

Lo hice en VS Code

ej06_invertir_palabra.py descargar .py

# Ejercicio 6 - Invertir una palabra con una pila
print("Estudiante: ESCRIBE AQUÍ TU NOMBRE")

palabra = "UNIMINUTO"
pila = []

for letra in palabra:          # apilo cada letra
    pila.append(letra)

invertida = ""
while pila:                    # desapilo: salen al revés
    invertida += pila.pop()

print("Original :", palabra)
print("Invertida:", invertida)

# TU TAREA: pide la palabra con input() y di si es palíndromo
# (se lee igual al derecho y al revés, por ejemplo "radar").

Salida esperada (código base)

Estudiante: ESCRIBE AQUÍ TU NOMBRE
Original : UNIMINUTO
Invertida: OTUNIMINU

Tu tarea

Pide la palabra con input() y di si es palíndromo (por ejemplo "radar" o "reconocer").

Ver pista

Compara la palabra original con la invertida: si son iguales, es palíndromo.

Lo hice en VS Code

ej07_banco_turnos.py descargar .py

# Ejercicio 7 - Turnos de un banco (cola de tuplas)
from collections import deque
print("Estudiante: ESCRIBE AQUÍ TU NOMBRE")

cola = deque()

def llegar(nombre, tramite):
    cola.append((nombre, tramite))
    print(f"Llega {nombre} para {tramite}. En espera: {len(cola)}")

def atender():
    if not cola:
        print("Nadie en la fila")
        return
    nombre, tramite = cola.popleft()
    print(f"Atendiendo a {nombre} ({tramite}). En espera: {len(cola)}")

llegar("Carlos", "consignación")
llegar("María", "retiro")
atender()
llegar("Pedro", "pago de servicios")
atender()
atender()
atender()

# TU TAREA: agrega la función ver_siguiente() que muestre quién sigue sin atenderlo.

Salida esperada (código base)

Estudiante: ESCRIBE AQUÍ TU NOMBRE
Llega Carlos para consignación. En espera: 1
Llega María para retiro. En espera: 2
Atendiendo a Carlos (consignación). En espera: 1
Llega Pedro para pago de servicios. En espera: 2
Atendiendo a María (retiro). En espera: 1
Atendiendo a Pedro (pago de servicios). En espera: 0
Nadie en la fila

Tu tarea

Agrega la función ver_siguiente() que muestre quién sigue sin atenderlo.

Ver pista

nombre, tramite = cola[0] lee el frente sin sacarlo.

Lo hice en VS Code

ej08_navegador_atras.py descargar .py

# Ejercicio 8 - El botón "Atrás" del navegador (pila de historial)
print("Estudiante: ESCRIBE AQUÍ TU NOMBRE")

historial = []
actual = "inicio.html"

def visitar(pagina):
    global actual
    historial.append(actual)   # guardo la página donde estaba
    actual = pagina
    print("Visitando:", actual)

def atras():
    global actual
    if historial:
        actual = historial.pop()
        print("Atrás ->", actual)
    else:
        print("No hay páginas anteriores")

visitar("cursos.html")
visitar("estructura-datos.html")
visitar("pilas.html")
atras()
atras()
print("Historial:", historial)

# TU TAREA: agrega el botón "Adelante" usando una SEGUNDA pila.

Salida esperada (código base)

Estudiante: ESCRIBE AQUÍ TU NOMBRE
Visitando: cursos.html
Visitando: estructura-datos.html
Visitando: pilas.html
Atrás -> estructura-datos.html
Atrás -> cursos.html
Historial: ['inicio.html']

Tu tarea

Agrega el botón "Adelante" usando una segunda pila.

Ver pista

Al ir atrás, apila la página actual en la pila "adelante" antes de cambiarla.

Lo hice en VS Code

ej09_deshacer.py descargar .py

# Ejercicio 9 - Deshacer (Ctrl+Z) en un editor de texto
print("Estudiante: ESCRIBE AQUÍ TU NOMBRE")

texto = ""
deshacer = []

def escribir(palabra):
    global texto
    deshacer.append(texto)     # guardo cómo estaba ANTES del cambio
    texto += palabra
    print(f'Texto: "{texto}"')

def ctrl_z():
    global texto
    if deshacer:
        texto = deshacer.pop()
    print(f'Deshacer -> "{texto}"')

escribir("Hola ")
escribir("mundo ")
escribir("Python")
ctrl_z()
ctrl_z()

# TU TAREA: agrega ctrl_y() (Rehacer) con otra pila.

Salida esperada (código base)

Estudiante: ESCRIBE AQUÍ TU NOMBRE
Texto: "Hola "
Texto: "Hola mundo "
Texto: "Hola mundo Python"
Deshacer -> "Hola mundo "
Deshacer -> "Hola "

Tu tarea

Agrega ctrl_y() (Rehacer) con otra pila.

Ver pista

Al deshacer, guarda el texto actual en la pila de rehacer.

Lo hice en VS Code

ej10_parentesis.py descargar .py

# Ejercicio 10 - ¿Los paréntesis están balanceados?
print("Estudiante: ESCRIBE AQUÍ TU NOMBRE")

def balanceado(expresion):
    pares = {")": "(", "]": "[", "}": "{"}
    pila = []
    for c in expresion:
        if c in "([{":
            pila.append(c)                 # abre: apilo
        elif c in ")]}":
            if not pila or pila.pop() != pares[c]:
                return False               # cierra sin pareja correcta
    return len(pila) == 0                  # no deben sobrar aperturas

pruebas = ["(a+b)*[c-d]", "{[()]}", "(]", "((2+3)", "print(lista[0])"]
for p in pruebas:
    resultado = "Balanceado" if balanceado(p) else "NO balanceado"
    print(f"{p:16} -> {resultado}")

# TU TAREA: agrega 3 expresiones tuyas a la lista de pruebas.

Salida esperada (código base)

Estudiante: ESCRIBE AQUÍ TU NOMBRE
(a+b)*[c-d]      -> Balanceado
{[()]}           -> Balanceado
(]               -> NO balanceado
((2+3)           -> NO balanceado
print(lista[0])  -> Balanceado

Tu tarea

Agrega tres expresiones tuyas a la lista de pruebas (al menos una mal balanceada).

Ver pista

Si llega un cierre y la pila está vacía o el tope no es su pareja, la expresión está mal.

Lo hice en VS Code

ej11_impresion_prioridad.py descargar .py

# Ejercicio 11 - Cola de impresión con prioridad (dos colas)
from collections import deque
print("Estudiante: ESCRIBE AQUÍ TU NOMBRE")

urgente = deque()
normal = deque()

def enviar(doc, es_urgente=False):
    if es_urgente:
        urgente.append(doc)
    else:
        normal.append(doc)

def imprimir():
    if urgente:                            # primero se vacía la cola urgente
        return "URGENTE " + urgente.popleft()
    if normal:
        return "normal  " + normal.popleft()
    return None

enviar("Taller.pdf")
enviar("Notas.xlsx")
enviar("Acta_rector.docx", es_urgente=True)
enviar("Foto.png")
enviar("Horario.pdf", es_urgente=True)

while True:
    trabajo = imprimir()
    if trabajo is None:
        break
    print("Imprimiendo", trabajo)
print("Impresora libre")

Salida esperada (código base)

Estudiante: ESCRIBE AQUÍ TU NOMBRE
Imprimiendo URGENTE Acta_rector.docx
Imprimiendo URGENTE Horario.pdf
Imprimiendo normal  Taller.pdf
Imprimiendo normal  Notas.xlsx
Imprimiendo normal  Foto.png
Impresora libre

Tu tarea

Agrega una tercera cola "baja" que solo se imprima cuando las otras dos estén vacías.

Ver pista

El orden de los if dentro de imprimir() define la prioridad.

Lo hice en VS Code

ej12_clases_pila_cola.py descargar .py

# Ejercicio 12 - Clases Pila y Cola (programación orientada a objetos)
from collections import deque
print("Estudiante: ESCRIBE AQUÍ TU NOMBRE")

class Pila:
    def __init__(self):
        self._datos = []
    def apilar(self, x):
        self._datos.append(x)
    def desapilar(self):
        if self.esta_vacia():
            raise IndexError("desapilar de una pila vacía")
        return self._datos.pop()
    def ver_tope(self):
        return None if self.esta_vacia() else self._datos[-1]
    def esta_vacia(self):
        return len(self._datos) == 0
    def __len__(self):
        return len(self._datos)
    def __str__(self):
        return f"Pila{self._datos} <- tope"

class Cola:
    def __init__(self):
        self._datos = deque()
    def encolar(self, x):
        self._datos.append(x)
    def desencolar(self):
        if self.esta_vacia():
            raise IndexError("desencolar de una cola vacía")
        return self._datos.popleft()
    def ver_frente(self):
        return None if self.esta_vacia() else self._datos[0]
    def esta_vacia(self):
        return len(self._datos) == 0
    def __len__(self):
        return len(self._datos)
    def __str__(self):
        return f"frente -> Cola{list(self._datos)}"

p = Pila()
c = Cola()
for n in [1, 2, 3]:
    p.apilar(n)
    c.encolar(n)

print(p)
print(c)
print("Desapilo:", p.desapilar(), "| Desencolo:", c.desencolar())
print("Tope:", p.ver_tope(), "| Frente:", c.ver_frente())
print("Tamaños:", len(p), len(c))

try:
    vacia = Pila()
    vacia.desapilar()
except IndexError as error:
    print("Error controlado:", error)

Salida esperada (código base)

Estudiante: ESCRIBE AQUÍ TU NOMBRE
Pila[1, 2, 3] <- tope
frente -> Cola[1, 2, 3]
Desapilo: 3 | Desencolo: 1
Tope: 2 | Frente: 2
Tamaños: 2 2
Error controlado: desapilar de una pila vacía

Tu tarea

Agrega a cada clase el método vaciar() y pruébalo; luego provoca y controla el error de la cola vacía.

Ver pista

raise IndexError("...") lanza el error; try/except lo captura.

Lo hice en VS Code

ej13_reto_supermercado.py descargar .py

# Ejercicio 13 - RETO: supermercado con dos cajas (colas) y canastas (pila)
from collections import deque
print("Estudiante: ESCRIBE AQUÍ TU NOMBRE")

canastas = ["C1", "C2", "C3", "C4"]        # pila: el tope es la última
cajas = {"Caja 1": deque(), "Caja 2": deque()}

def llega(cliente):
    if not canastas:
        print(f"{cliente} espera: no hay canastas")
        return
    canasta = canastas.pop()                # toma la canasta de encima
    caja = min(cajas, key=lambda k: len(cajas[k]))   # la fila más corta
    cajas[caja].append((cliente, canasta))
    print(f"{cliente} toma {canasta} y hace fila en {caja}")

def atiende(caja):
    if not cajas[caja]:
        print(f"{caja} sin clientes")
        return
    cliente, canasta = cajas[caja].popleft()
    canastas.append(canasta)                # la canasta vuelve a la pila
    print(f"{caja} atiende a {cliente} y devuelve {canasta}")

for nombre in ["Ana", "Beto", "Caro", "Dani", "Eli"]:
    llega(nombre)
atiende("Caja 1")
llega("Eli")
atiende("Caja 2")
atiende("Caja 2")
atiende("Caja 2")
print("Canastas disponibles:", canastas)
for caja, fila in cajas.items():
    print(caja, "->", [cliente for cliente, _ in fila])

# RETO: agrega una tercera caja y un cliente "con prioridad" que pase al frente.

Salida esperada (código base)

Estudiante: ESCRIBE AQUÍ TU NOMBRE
Ana toma C4 y hace fila en Caja 1
Beto toma C3 y hace fila en Caja 2
Caro toma C2 y hace fila en Caja 1
Dani toma C1 y hace fila en Caja 2
Eli espera: no hay canastas
Caja 1 atiende a Ana y devuelve C4
Eli toma C4 y hace fila en Caja 1
Caja 2 atiende a Beto y devuelve C3
Caja 2 atiende a Dani y devuelve C1
Caja 2 sin clientes
Canastas disponibles: ['C3', 'C1']
Caja 1 -> ['Caro', 'Eli']
Caja 2 -> []

Tu tarea

Agrega una tercera caja y un cliente con prioridad que pase al frente de su fila.

Ver pista

deque tiene appendleft() para meter a alguien por el frente.

Lo hice en VS Code

Hazlo en Visual Studio Code

El navegador sirve para probar; la evidencia se hace en tu computador, con VS Code y la terminal.

Instala Python 3
Descárgalo de python.org. En Windows marca la casilla Add python.exe to PATH antes de instalar. Comprueba en una terminal con python --version (o py --version).
Prepara VS Code
Abre VS Code, ve a Extensiones (Ctrl+Shift+X) e instala Python de Microsoft.
Crea tu carpeta de trabajo
Crea la carpeta PilasColas_TuApellido y ábrela con Archivo → Abrir carpeta.
Crea un archivo por ejercicio
Nombres sugeridos: ej01_primera_pila.py, ej02_desapilar.py… Escribe el código (escribirlo a mano se aprende mejor que copiarlo) y cambia la primera línea por tu nombre.
Ejecuta
Pulsa el botón de reproducir (arriba a la derecha) o abre la terminal (Ctrl+ñ o Ctrl+`) y escribe python ej01_primera_pila.py. Compara tu salida con la salida esperada.
Haz la tarea
Modifica el código según "Tu tarea" y ejecútalo otra vez.
Toma el pantallazo
En Windows usa Win + Shift + S. Debe verse: el código, la terminal con la salida y tu nombre impreso. Guárdalo como imagen (PNG o JPG).
Súbelo
En la pestaña 6 envía tus pantallazos indicando qué ejercicios incluyen.

¿Compilar o ejecutar?

En C o Java el código se compila primero a otro formato. Python es interpretado: al ejecutar python archivo.py, el intérprete revisa y corre el programa en el mismo paso. Si hay un error de sintaxis, te lo dice antes de ejecutar la primera línea.

Si algo falla

"python no se reconoce como un comando": reinstala marcando PATH o usa py archivo.py.
IndentationError: revisa los espacios; dentro de un def, if o while todo va con 4 espacios.
NameError: name 'deque' is not defined: falta from collections import deque.
IndexError: pop from empty list: intentaste sacar de una pila vacía.

ej04_primera_cola.py — PilasColas_Perez — Visual Studio Code

from collections import deque
print("Estudiante: Andrea Pérez Gómez")
cola = deque()
cola.append("Ana")
cola.append("Luis")
...

TERMINAL

PS C:\PilasColas_Perez> python ej04_primera_cola.py
Estudiante: Andrea Pérez Gómez
Cola: ['Ana', 'Luis', 'Sofía']
Atendido: Ana

Así debe verse un buen pantallazo: código, terminal y nombre del estudiante en la salida.

Pilas y Colas:
el orden importa

Conceptos que necesitas

Paso 1 · ¿Qué es una variable?

Paso 2 · Las listas y sus posiciones

Paso 3 · ¿Qué es una estructura de datos?

La PILA (stack)

La COLA (queue)

Paso 6 · Comparación rápida

Paso 7 · Comprueba que entendiste

Pilas y colas en Python

La pila con una lista

La cola con deque

Chuleta de operaciones

Simulador de pilas y colas

Reto rápido · ¿qué queda al final?

13 ejercicios: de sencillo a reto

Hazlo en Visual Studio Code

Entrega de evidencias

Pilas y Colas:el orden importa

Paso 1 · ¿Qué es una variable?

Paso 2 · Las listas y sus posiciones

Paso 3 · ¿Qué es una estructura de datos?

La PILA (stack)

La COLA (queue)

Paso 6 · Comparación rápida

Paso 7 · Comprueba que entendiste

La pila con una lista

La cola con deque

Chuleta de operaciones

Reto rápido · ¿qué queda al final?

Pilas y Colas:
el orden importa