Python – Capítulo 23: El que ríe el último ríe mejor

El título que he elegido para este artículo contiene un acertijo. ¿De qué crees que hablaremos hoy?

Es complicado, así que te daré otra pista: «los últimos serán los primeros».

En el capítulo de hoy mostraremos cómo organizar una estructura LIFO (una pila o stack) en Python y para ello nos valdremos, una vez más, de nuestras potentes y versátiles listas. ¡Qué sería de nosotros sin ellas!

Aclaremos previamente, por si no lo conoces, qué entendemos por una pila.

Una pila, o stack en inglés, es el término que se emplea en programación para designar una estructura de datos ordenada en la que almacenamos información y la recuperamos del modo que lo último que entre sea lo primero que sale.

De ahí vienen las siglas LIFO: Last In, First Out; el último en entrar, el primero en salir.

Piensa en una montón de papeles que vas apilando uno encima de otro. Cuando los quieres recuperar, accedes en primer lugar al que está arriba de la pila. Una vez lo retiras tienes acceso al siguiente, y así sucesivamente.

El concepto opuesto es el de cola, que es una estructura FIFO: First In, First Out; el primero que entra, el primero que sale. Piensa en la típica cola ante la taquilla de un concierto. El primero que llegó es el que primero tiene derecho a comprar la entrada. El que llegó el último tendrá que esperar a que hayan salido todos los que están delante de él antes de que le toque su turno.

Si quizás has hecho tus pinitos en el mundo de la programación en lenguaje ensamblador, el concepto de pila, o stack, te resultará ya familiar, al igual que las dos instrucciones que se empleaban para introducir y recuperar datos: push y pop, respectivamente. En Python se emplean casi las mismas.

Vamos a ilustrar el concepto pensando en un ascensor como si de una estructura LIFO se tratase: entras en el ascensor y te sitúas atrás para dejar sitio a los demás; cuando llega la hora de salir, el último en entrar es el primero en abandonar el ascensor y tú, que entraste el primero, eres ahora el último en salir.

Al principio el ascensor está vacío. Vamos a crear una lista sin elementos:

>>> ascensor = []
>>> ascensor
[]

Ese par de corchetes tiene hasta forma de ascensor, ¿a que sí?

El método para agregar elementos a una lista, justo después del último, ya lo conoces del capítulo 19. Vamos a emplearlo para hacer que Luis suba en el ascensor:

>>> ascensor.append('Luis')
>>> ascensor
['Luis']

El siguiente en entrar será Pedro:

>>> ascensor.append('Pedro')
>>> ascensor
['Luis', 'Pedro']

Le siguen Marta y Juan:

>>> ascensor.append('Marta')
>>> ascensor.append('Juan')
>>> ascensor
['Luis', 'Pedro', 'Marta', 'Juan']

El ascensor llega a la planta baja y es hora de abandonarlo.

Para extraer el último elemento de una lista, Python dispone del método pop().

>>> ascensor.pop()
'Juan'
>>> ascensor
['Luis', 'Pedro', 'Marta']

Fíjate bien en que pop() hace dos cosas: por un lado, recupera el último elemento, el cual podrías, por ejemplo, presentarlo o asignarlo a una variable; por otro, elimina ese elemento de la lista.

Si vuelvo a hacer un pop(), ¿quién crees que saldrá ahora?

>>> ascensor.pop()
'Marta'

Le sigue Pedro y, a continuación, Luis, que estaba apretujado al fondo:

>>> ascensor.pop()
'Pedro'
>>> ascensor
['Luis']
>>> ascensor.pop()
'Luis'

Si no nos hemos equivocado en las cuentas, el ascensor está ya completamente vacío. En efecto:

>>> ascensor
[]

Con dos sencillos métodos, append() y pop(), hemos diseñado una estructura LIFO en todas las de la ley.

El método pop() podemos utilizarlo aunque nuestra lista no sea LIFO. Veámoslo:

Demos marcha atrás en el tiempo hasta el momento en el que el ascensor estaba completamente lleno:

>>> ascensor=['Luis', 'Pedro', 'Marta', 'Juan']
>>> ascensor
['Luis', 'Pedro', 'Marta', 'Juan']

Se abren las puertas y le toca salir a Juan, que ha sido el último en entrar. Sin dudarlo, considera que sería poco caballeroso por su parte salir el primero y, cortésmente, le cede el paso a Marta.

Cuando al método pop() le facilitamos un índice, extraerá el elemento correspondiente, en lugar del último de la lista.

El índice de Marta en la lista es 2. Por lo tanto:

>>> ascensor.pop(2)
'Marta'
>>> ascensor
['Luis', 'Pedro', 'Juan']

¡Cuánta caballerosidad! No sólo el lenguaje Python es elegante y cortés en sí mismo, ¡incluso los mismos elementos que ilustran como ejemplo sus estructuras de datos!

Javier Montero


Python – Capítulo 23: El que ríe el último ríe mejor


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta

5 opiniones en “Python – Capítulo 23: El que ríe el último ríe mejor”

  1. Me encanta leer tus artículos, da la casualidad de que quiero aprender Python y SQL pero aunque no fuera así también da gusto leerte.

  2. Muy bien explicado, eres uno grande tio, explicas tan bien y tan claro que deberias dedicar a eso de enseñar, a ver si te animas algun video aula. Gracias un saludo

Deja un comentario

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.plugin cookies

ACEPTAR
Aviso de cookies