Scribd
Cargar
209 vistas

Clase 17 - Python

Este documento presenta información sobre pilas en Python. Explica cómo crear una clase Pila que use una lista para representar una pila, con métodos como apilar(), desapilar() y es_vacía(). Muestra código para una clase Pila básica con estas operaciones, y ejemplos de cómo crear instancias de Pila y usar sus métodos.

Cargado por

Miguel Angulo Loria
Derechos de autor
© © All Rights Reserved
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd
209 vistas

Clase 17 - Python

Este documento presenta información sobre pilas en Python. Explica cómo crear una clase Pila que use una lista para representar una pila, con métodos como apilar(), desapilar() y es_vacía(). Muestra código para una clase Pila básica con estas operaciones, y ejemplos de cómo crear instancias de Pila y usar sus métodos.

Cargado por

Miguel Angulo Loria
Derechos de autor
© © All Rights Reserved
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 15

JUNIOR DEVELOPER

Módulo - PYTHON

Ing. Yusselin Murcia Clase 17


Tarea
◦ Realizar la programación de la siguiente estructura.

Crea al menos un objeto de cada subclase y añádelos a una


lista llamada vehiculos.
Realiza una función llamada catalogar() que reciba la lista de
vehiculos y los recorra mostrando el nombre de su clase y sus
atributos.
Modifica la función catalogar() para que reciba un argumento
optativo ruedas, haciendo que muestre únicamente los que
su número de ruedas concuerde con el valor del argumento.
También debe mostrar un mensaje "Se han encontrado {}
vehículos con {} ruedas:" únicamente si se envía el argumento
ruedas. Ponla a prueba con 0, 2 y 4 ruedas como valor.
ESTRUCTURAS DE DATOS COMPLEJAS
Más sobre las listas
El tipo de datos ``lista'' tiene algunos métodos más. Éstos son todos los métodos de los objetos lista:
◦ append(x): Añade un elemento al final de una lista; es equivalente a a[len(a):] = [x].
◦ extend(L): Extiende la lista concatenándole todos los elementos de la lista indicada; es equivalente a a[len(a):]
= L.
◦ insert(i, x): Inserta un elemento en un posición dada. El primer argumento es el índice del elemento antes del
que se inserta, por lo que a.insert(0, x) inserta al principio de la lista y a.insert(len(a), x) equivale a a.append(x).
◦ remove(x): Elimina el primer elemento de la lista cuyo valor es x. Provoca un error si no existe tal elemento.
◦ pop([i]):Elimina el elemento de la posición dada de la lista y lo devuelve. Si no se especifica un
índice, a.pop() devuelve el último elemento de la lista y también lo elimina. Los corchetes que rodean la i en
la signatura del método indican que el parámetro es opcional, no que haya que teclear los corchetes en
dicha posición.
Más sobre las listas

◦ index(x): Devuelve el índice del primer elemento de la lista cuyo valor


sea x. Provoca un error si no existe tal elemento.

◦ count(x): Devuelve el número de veces que aparece x en la lista.


◦ sort(): Ordena ascendentemente los elementos de la propia lista (la
lista queda cambiada).
◦ reverse(): Invierte la propia lista (la lista queda cambiada).
Estructura de Datos: Pilas en Python

Una pila como estructura de datos, funciona exactamente cómo sucede


en el mundo real en un conjunto de objetos superpuestos verticalmente.
Ejemplo: eres estudiante, y estás buscando un objeto en tu mochila. Por
más que mueves las cosas no logras encontrar lo que buscas, así que
comienzas a sacar tus libros y los apilas, uno sobre otro. Con esto lograste
ubicar el objeto que buscabas, paso siguiente, pones los libros de regreso
en tu mochila, comenzando por el libro que se encuentra en el tope de la
pila, y así hasta llegar al último. (Asumiendo que todos somos ordenados)
Estructura de Datos: Pilas en Python

Si analizamos un poco el ejemplo, podemos notar ciertas cosas, al agregar un


nuevo elemento (un libro) a la pila, pasará a colocarse en el tope, ya que siempre
en una pila, el último elemento en ingresar a la pila, será el tope de la misma.
Mientras que para eliminar un elemento (guardar un libro) comenzaremos por el
último en haber sido introducido a la pila (que se encuentra en el tope).
Esto es debido a que las pilas, son una estructura de datos del tipo LIFO («Last In,
First Out»), lo que nos dice que el último elemento en ingresar a la pila, será el
primero en salir de ella.
Operaciones de Pilas

Las operaciones distintivas de una pila son: pop(), para sacar (remover) el
elemento en el tope de la pila y push() para empujar (añadir) un elemento en el
tope.
Cada vez que se realiza una operación push() la pila aumenta de tamaño y el tope
se modifica siendo ahora el elemento añadido. En el caso de la
operación pop() disminuye el tamaño de la pila, y el tope ahora será el elemento
debajo del elemento a ser removido, generalmente esta operación devuelve el
elemento removido.
Otra operación que generalmente se implementa en una pila, es peek(), que
devuelve el elemento que se encuentra como tope de la pila, sin removerlo.
Creando una pila con Python
class Stack: def get_peek(self):
elements = [] return self.elements[-1]

def __init__(self): peek = property(fget=get_peek)


self.elements = [] size = property(fget=get_size)

def get_size(self):
return len(self.elements) s = Stack()
s.push("a")
def push(self, x): s.push("b")
self.elements.append(x) s.push("c")
s.push("d")
def pop(self): s.push("e")
return self.elements.pop() s.push("f")
s.push("h")

El código es algo simple, definimos una clase, la cual será nuestra Pila, que contiene un atributo elements, el
cual será una lista vacía. Con __init__() establecemos la lista como vacía al crear una nueva instancia. Contiene
un método get_size(), que retorna el tamaño de la pila, push() para añadir un elemento al tope de la pila, pop()
para remover el elemento en el tope y devolverlo y get_peek(), que nos devuelve el elemento en el tope sin
removerlo, en este caso utilizamos la expresión elements[-1], que es la forma de obtener el último elemento de
una lista (recuerdan que en Python, una pila no es más que una lista).
Creando una pila con Python
Paso seguido creamos una instancia y añadimos algunos valores a nuestra pila, quedando de esta forma:

Como se observa, h es el elemento que se encuentra en el


tope de la pila. Si ejecutamos las operaciones
mencionadas anteriormente. get_size() devuelve el valor
de 8, con get_peek() obténdremos «h», y con pop()
también obtendremos «h», la diferencia es que ahora
nuestra pila se encuentra de la siguiente forma.
Creando una pila con Python

Si observas, ahora el tope de la pila es «g», y el tamaño actual es de 7.


Este ejemplo podría mejorarse un poco. Se podría añadir una validación para evitar
que se intente hacer pop() si la lista se encuentra vacía, te invito a realizarlo a modo
de práctica y lo expongas en los comentarios.
La pila es probablemente una de las estructuras de datos más utilizadas en el
ámbito de la programación, y de la informática en general me atrevería a decir.
Son utilizadas en ocasiones de manera inconsciente, cuando definimos algoritmos
recursivos, dado que los lenguajes de programación implementan este mecanismo
mediante una pila que almacena los llamados recursivos.
Pilas representadas por listas

◦ Definiremos una clase Pila con un atributo, items, de tipo lista, que contendrá los
ele-mentos de la pila. El tope de la pila se encontrará en la última posición de la
lista, y cada vez que se apile un nuevo elemento, se lo agregará al final.
◦ El método __init__ no recibirá parámetros adicionales, ya que deberá crear una
pila vacía (que representaremos por una lista vacía):

class Pila:
""" Representa una pila con operaciones de apilar, desapilar y verificar si
está vacía. """
def __init__(self): """ Crea una pila vacía. """
# La pila vacía se representa con una lista vacía
self.items=[]
Pilas representadas por listas
◦ El método apilar se implementará agregando el nuevo elemento al final de la lista:

def apilar(self, x):


""" Agrega el elemento x a la pila. """
# Apilar es agregar al final de la lista.
self.items.append(x)

◦ Para implementar desapilar, se usará el método pop de lista que hace exactamente lo requerido: elimina el último elemento de la
lista y devuelve el valor del elemento eliminado. Si la lista está vacía levanta una excepción, haremos lo mismo, pero
cambiaremos el tipo de excepción, para no revelar la implementación.

def desapilar(self): """ Devuelve el elemento tope y lo elimina


de la pila. Si la pila está vacía levanta una excepción. ""”
try:
return self.items.pop()
except IndexError:
raise ValueError("La pila está vacía")
Pilas representadas por listas
◦ Finalmente, el método para indicar si se trata de una pila vacía.

def es_vacia(self):
""" Devuelve True si la lista está vacía, False si no. ""”
return self.items == []

◦ Construimos algunas pilas y operamos con ellas:


MUCHAS GRACIAS

También podría gustarte