def ejercicio_11():
obj_Cola = Cola()
Mat_PJ_de_SW = [
['Chewbacca', 'Anoat'],
['Obi-Wan Kenobi', 'Tatooine'],
['Yoda','Endor'],
['BB8', 'Alderaan'],
['Padme Amidala','Atollon'],
['Luke Skywalker', 'Tatooine'],
['Han Solo','Corellia'],
['Jar Jar Binks', 'Anoat']
]
for datos_PJ in Mat_PJ_de_SW:
obj_Cola.arribo(datos_PJ)
print('\nMOSTRAR PERSONAJE CON SU PLANETA DE ORIGEN\n')
mostrar_Pj_De_Star_Wars_Con_Su_Planeta(get_Pj_De_Los_Planetas_Alderaan_Endor_Tatooine(obj_Cola))
print('\nPLANETA DE LUKE Y HAN\n')
mostrar_Planeta_Natal_De_Luke_Y_Han_Solo(get_Planeta_Natal_De_Luke_Y_Han_Solo(obj_Cola))
print('\nINSERTAR PERSONAJE ANTES QUE YODA\n')
insertar_Personaje_Antes_Que_Yoda(obj_Cola)
imprimir_Cola(obj_Cola)
print('\nELIMINAR PERSONAJE DESPUES DE JAR JAR BINKS\n')
eliminar_Personaje_Despues_De_Jar_Jar_Binks(obj_Cola)
imprimir_Cola(obj_Cola)
def parser(cadena, user):
try:
full_file = os.path.abspath(os.path.join(cadena))
dom = ElementTree.parse(full_file)
if user.mat == None:
ejex = dom.find('matriz/x').text
ejey = dom.find('matriz/y').text
matriz = Matriz()
matriz.crear(ejey, ejex)
user.mat = matriz
trans = Matriz()
trans.crear(ejex, ejey)
user.trans = trans
cola = Cola()
operacion = dom.findall('operaciones/operacion')
if user.cola == None:
for op in operacion:
cola.queque(op.text)
user.cola = cola
else:
for op in operacion:
user.cola.queque(op.text)
print "----------cargado exitosamente----------"
except IOError:
print "este archivo no existe en esta carpeta"
return user
def guardar_estados_clave(estados,angulo):
"""Devuelve una cola con los estados clave (de inflexión) que definen dibujo"""
pluma = Pluma()
tortuga = Tortuga(pluma)
estados_clave = Cola()
pila_tortugas = Pila()
encolar_estado_clave(tortuga, estados_clave) #guarda la posición [0,0] con orientación 0 y pluma = True como "inicio"
for _ in range(len(estados.items)):
accion = estados.desencolar()
if not str(accion).isdigit():
if type(accion) == bool:
tortuga.pluma.cambiar_estado()
elif accion == '+':
tortuga.derecha(angulo)
elif accion == '-':
tortuga.izquierda(angulo)
elif accion == '|':
tortuga.orientacion += radians(180)
elif accion == '[':
tortuga = apilar_tortuga(tortuga, pila_tortugas)
elif accion == ']':
encolar_estado_clave(tortuga, estados_clave)
estados_clave.encolar(CAMBIO_DE_TORTUGA)
tortuga = desapilar_tortuga(tortuga, pila_tortugas)
encolar_estado_clave(tortuga, estados_clave)
else:
tortuga.adelante(accion)
encolar_estado_clave(tortuga, estados_clave)
return estados_clave
class TorreDeControl:
def __init__(self):
self.arribos = Cola()
self.partidas = Cola()
def nuevo_arribo(self,avion):
self.arribos.encolar(avion)
def nueva_partida(self,avion):
self.partidas.encolar(avion)
def ver_estado(self):
print(f'Vuelos esperando para aterrizar: {str(self.arribos)}\nVuelos esperando para despegar: {str(self.partidas)}')
def asignar_pista(self):
try:
print(f'El vuelo {self.arribos.desencolar()} aterrizó con éxito')
except ValueError:
try:
print(f'El vuelo {self.partidas.desencolar()} despegó con éxito')
except ValueError:
print('No hay vuelos en espera')
def main():
a = Cola()
for i in range(0, 10):
a.encolar((int)(1 + random() * 20))
a.imprimir()
a.desencolar()
a.imprimir()
def main():
cupos = randrange(1, 10)
parqueaderos = Cola()
horarios = [
Horario(1, 6, 13),
Horario(2, 6, 15),
Horario(3, 8, 12),
Horario(4, 9, 16)
]
motos = [
Moto("EPF123", "verde", 3),
Moto("EXF123", "azul", 3),
Moto("EPQ123", "negra", 3),
Moto("QEF123", "blanca", 3),
Moto("LHJ123", "rosada", 3),
Moto("POI123", "gris", 3)
]
estudiantes = [
Estudiante(20112020005, "Felipe Duitama", 1, 1),
Estudiante(20112020005, "Felipe Duitama", 2, 2),
Estudiante(20112020005, "Felipe Duitama", 3, 3),
Estudiante(20112020005, "Felipe Duitama", 4, 4),
Estudiante(20112020005, "Felipe Duitama", 1, 5),
]
if len(parqueaderos.items) < cupos:
estudiante = choice(estudiantes)
parqueaderos.encolar(estudiante)
estudiantes.remove(estudiante)
print(parqueaderos.items)
def inicializacion(self, duracion_simulacion):
super(Simulacion2mec, self).inicializacion(duracion_simulacion)
self.estado_mecanico = [Simulacion.DESOCUPADO, Simulacion.DESOCUPADO]
self.cola_mecanico = [Cola('mecanico'), Cola('mecanico')]
# Lista de eventos
self.lista_de_eventos = {
'arribo_pala': [
Evento('arribo_pala'),
Evento('arribo_pala'),
Evento('arribo_pala')
],
'partida_pala': [
Evento('partida_pala'),
Evento('partida_pala'),
Evento('partida_pala')
],
'arribo_aplastador':
Evento('arribo_aplastador'),
'partida_aplastador':
Evento('partida_aplastador'),
'fin_de_reparacion':
[Evento('fin_de_reparacion'),
Evento('fin_de_reparacion')]
}
def ejercicio_22():
obj_Cola = Cola()
array_Personajes_MCU = [
['Tony Stark', 'Iron Man', 'M'],
['Thor Odinson', 'Thor', 'M'],
['Carol Danvers','Capitana Marvel','F'],
['Steve Rogers', 'Capitan America', 'M'],
['Scott Lang', 'Hombre Hormiga', 'F'],
['Stephen Strange', 'Doctor Strange', 'M'],
]
for i in range(0, len(array_Personajes_MCU)):
obj_Cola.arribo(array_Personajes_MCU[i])
print('NOMBRE DE CAPITANA MARVEL')
print(get_Mensaje_Si_Existe_Personaje_O_Super_Heroe(get_Nombre_Personaje(obj_Cola, 'Capitana Marvel'), 'Capitana Marvel'))
print('\nSUPER HEROINAS')
print(get_Personajes_Concatenados_De_Un_Vector(get_Super_Heroinas(obj_Cola)))
print('PERSONAJES MASCULINOS')
print(get_Personajes_Concatenados_De_Un_Vector(get_Personajes_Masculinos(obj_Cola)))
print('NOMBRE DE SUPER HEROE DE SCOTT LANG')
print(get_Mensaje_Si_Existe_Personaje_O_Super_Heroe(get_Nombre_Del_Super_Heroe(obj_Cola, 'Scott Lang'), 'Scott Lang'))
print('\nPERSONAJES Y SUPER HEROES CON INICIAL S')
print(get_Personajes_Concatenados_De_Una_Matriz(get_Nombres_Con_S(obj_Cola)))
print('NOMBRE DE SUPER HEROE DE CAROL DANVERS')
print(get_Mensaje_Si_Existe_Personaje_O_Super_Heroe(get_Nombre_Del_Super_Heroe(obj_Cola, 'Carol Danvers'), 'Carol Danvers'))
def inicializacion(self, duracion_simulacion):
super(SimulacionUnaCola, self).inicializacion(duracion_simulacion)
self.cola_pala = Cola('pala')
for i in range(3):
self.cola_pala.agregar(Camion(50))
for k in range(2):
self.cola_pala.agregar(Camion(20))
# Lista de eventos
self.lista_de_eventos = {
'arribo_pala':
Evento('arribo_pala'),
'partida_pala': [
Evento('partida_pala'),
Evento('partida_pala'),
Evento('partida_pala')
],
'arribo_aplastador':
Evento('arribo_aplastador'),
'partida_aplastador':
Evento('partida_aplastador'),
'fin_de_reparacion':
Evento('fin_de_reparacion')
}
def ejercicio_6():
obj_Cola = Cola()
for i in range(0, 15):
obj_Cola.arribo(randint(1, 10))
numero = int(input('ingrese un numero: '))
print('Cantidad de ocurrencias: ', contar_Ocurrencias(obj_Cola, numero))
def barrido_por_nivel_huff(self):
pendientes = Cola()
pendientes.arribo(self)
while(not pendientes.cola_vacia()):
nodo = pendientes.atencion()
print(nodo.info, nodo.frecuencia)
if(nodo.izq is not None):
pendientes.arribo(nodo.izq)
if(nodo.der is not None):
pendientes.arribo(nodo.der)
def barrido_por_nivel_huff(self):
"""Realiza el barrido por nivel del arbol con codigos de Huffman."""
pendientes = Cola()
pendientes.arribo(self)
while (not pendientes.cola_vacia()):
nodo = pendientes.atencion()
print(nodo.info, nodo.datos)
if (nodo.izq is not None):
pendientes.arribo(nodo.izq)
if (nodo.der is not None):
pendientes.arribo(nodo.der)
def barrido_por_nivel(self):
"""Realiza el barrido por nivel del arbol."""
pendientes = Cola()
pendientes.arribo(self)
while (not pendientes.cola_vacia()):
nodo = pendientes.atencion()
print(nodo.info)
if (nodo.izq is not None):
pendientes.arribo(nodo.izq)
if (nodo.der is not None):
pendientes.arribo(nodo.der)
def encolar_personas_enlistas_colectivos(lista_eventos):
personas = Cola()
colectivos = []
for evento in lista_eventos:
if evento[1] == 'p':
personas.encolar(evento)
else:
colectivos.append(evento)
return personas, colectivos
def orden_topologico(grafo):
res = []
orden = {}
visitados = set()
for v in grafo.obt_vertices():
orden[v] = 0
for v in grafo.obt_vertices():
for w in grafo.obtener_vecinos(v):
orden[w] += 1
cola = Cola()
for v, grado in orden.items():
if grado == 0:
cola.encolar(v)
while (not cola.esta_vacia()):
v = cola.desencolar()
if v in visitados:
continue
res.append(v)
visitados.add(v)
for w in grafo.obtener_vecinos(v):
orden[w] -= 1
for v, grado in orden.items():
if grado == 0:
cola.encolar(v)
return res
def es_Palindromo(palabra):
obj_Cola = Cola()
obj_Pila = Pila()
letra = None
for i in range(0, len(palabra)):
letra = palabra[i].lower()
obj_Cola.arribo(letra)
obj_Pila.apilar(letra)
mitad = len(palabra)//2
for i in range(0, mitad):
if(obj_Pila.desapilar() != obj_Cola.atencion()):
return False
return True
def invertir_Cola(contenedor):
obj_Cola = Cola()
obj_Pila = Pila()
for i in range(0, len(contenedor)):
obj_Cola.arribo(contenedor[i])
while(not obj_Cola.cola_vacia()):
obj_Pila.apilar(obj_Cola.atencion())
while(not obj_Pila.pila_vacia()):
obj_Cola.arribo(obj_Pila.desapilar())
for i in range(0, obj_Cola.tamanio()):
contenedor[i] = obj_Cola.atencion()
return contenedor
def inicializacion(self, duracion_simulacion):
self.duracion_simulacion = duracion_simulacion
# Contadores Estadisticos
self.tiempo_ocioso = 0
self.total_material_transportado = 0
self.total_descomposturas = 0
self.acrt = 0
# Variables de estado
self.reloj_simulacion = 0
self.estado_pala = [
Simulacion.DESOCUPADO, Simulacion.DESOCUPADO, Simulacion.DESOCUPADO
]
self.estado_aplastador = Simulacion.DESOCUPADO
self.estado_mecanico = Simulacion.DESOCUPADO
self.ult_ubicacion_mecanico = 'pala'
self.ultima_medicion_descomposturas = 0
self.dcrt = 0
self.colas_pala = []
for i in range(3):
cola_pala = Cola('pala')
cola_pala.agregar(Camion(50, i))
cola_pala.agregar(Camion(20, i))
cola_pala.agregar(Camion(20, i))
self.colas_pala.append(cola_pala)
self.cola_aplastador = Cola('aplastador')
self.cola_mecanico = Cola('mecanico')
# Lista de eventos
self.lista_de_eventos = {
'arribo_pala': [
Evento('arribo_pala'),
Evento('arribo_pala'),
Evento('arribo_pala')
],
'partida_pala': [
Evento('partida_pala'),
Evento('partida_pala'),
Evento('partida_pala')
],
'arribo_aplastador':
Evento('arribo_aplastador'),
'partida_aplastador':
Evento('partida_aplastador'),
'fin_de_reparacion':
Evento('fin_de_reparacion')
}
def test(self):
cola = Cola() #Define medico y cola
cola.enqueue("Pedro")# Ingresa un paciente en la cola de Pablo
cola.enqueue("Marco")# Ingresa un paciente en la cola de Pablo
self.agregarMedico("Pablo", cola) #Ingresa a pablo y su cola de pacientes
mCola = self.dict["Pablo"] #Saca cola de pacienes de pablo
print(mCola.dequeue())#saca el siguiente paciente en la cola
print(mCola.dequeue())#saca el siguiente paciente en la cola
cola1 = Cola() #//
cola1.enqueue("P")
cola1.enqueue("M")
self.agregarCola("Jose", cola1)
mCola = self.dict["Jose"] # //
print(mCola.dequeue())
print(mCola.dequeue())
def topologico_grados(grafo):
g_ent = grados_entrada(grafo)
q = Cola()
for v in grafo:
if g_ent[v] == 0:
q.encolar(v)
resultado = []
while not q.esta_vacia():
v = q.desencolar()
resultado.append(v)
for w in grafo.adyacentes(v):
g_ent[w] -= 1
if g_ent[w] == 0:
q.encolar(w)
return resultado
def distancias_ady(grafo, origen, visitados, orden, dicc_dist):
q = Cola()
q.encolar(origen)
visitados[origen] = True
while not q.esta_vacia():
v = q.desencolar()
ady = list(grafo.adyacentes(v))
for w in ady:
if w not in visitados:
visitados[w] = True
orden[w] = orden[v] + 1
if not orden[w] in dicc_dist:
dicc_dist[orden[w]] = 1
else:
dicc_dist[orden[w]] += 1
q.encolar(w)
class Impresora:
def __init__(self, nombre, capacidad_tinta):
self.nombre = nombre
self.capacidad_max = capacidad_tinta
self.capacidad = self.capacidad_max
self.cola_de_impresion = Cola()
def encolar(self,archivo):
self.cola_de_impresion.encolar(archivo)
def imprimir(self):
if not self.capacidad:
print('No tengo tinta :(')
return
print(f'{self.cola_de_impresion.desencolar()} impreso.')
self.capacidad -= 1
def cargar_tinta(self):
self.capacidad = self.capacidad_max
def camino_minimo(grafo, origen):
visitados = set()
distancia = {}
padre = {}
padre[origen] = None
distancia[origen] = 0
q = Cola()
q.encolar(origen)
visitados.add(origen)
while not q.esta_vacia():
v = q.desencolar()
for w in grafo.adyacentes(v):
if not w in visitados:
padre[w] = v
distancia[w] = distancia[v] + 1
visitados.add(w)
q.encolar(w)
return distancia, padre
def bfs(grafo, inicio):
if not grafo.vertice_esta(inicio):
return None
cola = Cola()
visitados = set()
padres = {}
padres[inicio] = None
visitados.add(inicio)
cola.encolar(inicio)
while (not cola.esta_vacia()):
vertice = cola.desencolar()
for v in grafo.obtener_vecinos(vertice):
if v in visitados:
continue
visitados.add(v)
padres[v] = vertice
cola.encolar(v)
return padres
def bfs(grafo, origen):
visitados = set()
padres = {}
orden = {}
padres[origen] = None
orden[origen] = 0
visitados.add(origen)
q = Cola() # usar deque de collections, NO QUEUE!!
q.encolar(origen)
while not q.esta_vacia():
v = q.desencolar()
for w in grafo.adyacentes(v): # E1 + E2 + E3 + ... + Ev = k E
if w not in visitados:
padres[w] = v
orden[w] = orden[v] + 1
visitados.add(w)
q.encolar(w)
# O(V + E)
return padres, orden
def divulgar(grafo, args):
origen = args[0]
n = int(args[1])
resultado = []
visitados = set()
orden = {}
orden[origen] = 0
q = Cola()
q.encolar(origen)
visitados.add(origen)
while not q.esta_vacia():
v = q.desencolar()
for w in grafo.adyacentes(v):
if not w in visitados:
orden[w] = orden[v] + 1
if orden[w] > n:
print(*resultado, sep=", ")
return
resultado.append(w)
visitados.add(w)
q.encolar(w)
def orden_topologico(grafo):
"""Solo funciona para grafo dirigido"""
resultado = []
cola = Cola()
orden = {}
for v in grafo.obtener_todos_vertices():
orden[v] = 0
for v in grafo.obtener_todos_vertices():
for w in grafo.adyacentes_vertice(v):
orden[w] += 1
for v in grafo.obtener_todos_vertices():
if (orden[v] == 0):
cola.encolar(v)
while not cola.esta_vacia():
v = cola.desencolar()
resultado.append(v)
for w in grafo.adyacentes_vertice(v):
orden[w] -= 1
if orden[w] == 0:
cola.encolar(w)
return resultado
def barrido_amplitud(self, ver_origen):
cola = Cola()
while (ver_origen < self.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
if (not vertice['visitado']):
vertice['visitado'] = True
cola.arribo(vertice)
while (not cola.cola_vacia()):
nodo = cola.atencion()
print(nodo['info'])
aristas = 0
while (aristas < nodo['aristas'].tamanio()):
adyacente = nodo['aristas'].obtener_elemento(aristas)
pos_vertice = self.buscar_vertice(adyacente['destino'])
nuevo_vertice = self.inicio.obtener_elemento(
pos_vertice)
if (not nuevo_vertice['visitado']):
nuevo_vertice['visitado'] = True
cola.arribo(nuevo_vertice)
aristas += 1
ver_origen += 1
def bfs(self, visitar=visitar_nulo, extra=None, inicio=None):
'''Realiza un recorrido BFS dentro del grafo, aplicando la funcion pasada por parametro en cada vertice visitado.
Parametros:
- visitar: una funcion cuya firma sea del tipo:
visitar(v, padre, orden, extra) -> Boolean
Donde 'v' es el identificador del vertice actual,
'padre' el diccionario de padres actualizado hasta el momento,
'orden' el diccionario de ordenes del recorrido actualizado hasta el momento, y
'extra' un parametro extra que puede utilizar la funcion (cualquier elemento adicional que pueda servirle a la funcion a aplicar).
La funcion aplicar devuelve True si se quiere continuar iterando, False en caso contrario.
- extra: el parametro extra que se le pasara a la funcion 'visitar'
- inicio: identificador del vertice que se usa como inicio. Si se indica un vertice, el recorrido se comenzara en dicho vertice,
y solo se seguira hasta donde se pueda (no se seguira con los vertices que falten visitar)
Salida:
Tupla (padre, orden), donde :
- 'padre' es un diccionario que indica para un identificador, cual es el identificador del vertice padre en el recorrido BFS (None si es el inicio)
- 'orden' es un diccionario que indica para un identificador, cual es su orden en el recorrido BFS
'''
if not inicio in self.vertices:
raise KeyError
(visitados, padre, orden) = crear_diccionarios(self.nombre_vertices)
cola = Cola()
cola.encolar(inicio)
orden[inicio] = 0
while not cola.esta_vacia():
analizar = cola.desencolar()
if not visitar(analizar, padre, orden, extra):
return (padre, orden)
dist = orden[analizar]
if not visitados[analizar]:
visitados[analizar] = True
for adyacente in self.adyacentes(analizar):
if orden[adyacente] == -1:
orden[adyacente] = dist + 1
padre[adyacente] = analizar
cola.encolar(adyacente)
return (padre, orden)
def contar_personas(personas)):
if personas.esta_vacia():
return 0
i = 1
cola_aux = Cola()
while not personas.esta_vacia():
cola_aux.encolar(personas.desencolar())
i +=1
while not cola_aux.esta_vacia():
personas.encolar(cola_aux.desencolar())
return i
def bfs(self, visitar = visitar_nulo, extra = None, inicio=None):
'''Realiza un recorrido BFS dentro del grafo, aplicando la funcion pasada por parametro en cada vertice visitado.
Parametros:
- visitar: una funcion cuya firma sea del tipo:
visitar(v, padre, orden, extra) -> Boolean
Donde 'v' es el identificador del vertice actual,
'padre' el diccionario de padres actualizado hasta el momento,
'orden' el diccionario de ordenes del recorrido actualizado hasta el momento, y
'extra' un parametro extra que puede utilizar la funcion (cualquier elemento adicional que pueda servirle a la funcion a aplicar).
La funcion aplicar devuelve True si se quiere continuar iterando, False en caso contrario.
- extra: el parametro extra que se le pasara a la funcion 'visitar'
- inicio: identificador del vertice que se usa como inicio. Si se indica un vertice, el recorrido se comenzara en dicho vertice,
y solo se seguira hasta donde se pueda (no se seguira con los vertices que falten visitar)
Salida:
Tupla (padre, orden), donde :
- 'padre' es un diccionario que indica para un identificador, cual es el identificador del vertice padre en el recorrido BFS (None si es el inicio)
- 'orden' es un diccionario que indica para un identificador, cual es su orden en el recorrido BFS
'''
if not inicio in self.vertices:
raise KeyError
(visitados, padre, orden) = crear_diccionarios(self.nombre_vertices)
cola = Cola()
cola.encolar(inicio)
orden[inicio] = 0
while not cola.esta_vacia():
analizar = cola.desencolar()
if not visitar(analizar,padre,orden,extra):
return (padre,orden)
dist = orden[analizar]
if not visitados[analizar]:
visitados[analizar] = True
for adyacente in self.adyacentes(analizar):
if orden[adyacente] == -1:
orden[adyacente] = dist + 1
padre[adyacente] = analizar
cola.encolar(adyacente)
return (padre,orden)
def setUp(self):
self.cola = Cola()
self.d1 = 'dummy1'
self.d2 = 'dummy2'
self.d3 = 'dummy3'
self.d4 = 'dummy4'
class TestCola(unittest.TestCase):
def setUp(self):
self.cola = Cola()
self.d1 = 'dummy1'
self.d2 = 'dummy2'
self.d3 = 'dummy3'
self.d4 = 'dummy4'
def test_inicio(self):
self.assertIsInstance(self.cola._datos, ListaConPyLista)
def test_poner(self):
self.cola.poner(self.d1)
expected = str([self.d1])
self.assertEqual(expected, str(self.cola))
self.cola.poner(self.d2)
expected = str([self.d2, self.d1])
self.assertEqual(expected, str(self.cola))
self.cola.poner(self.d3)
expected = str([self.d3, self.d2, self.d1])
self.assertEqual(expected, str(self.cola))
self.cola.poner(self.d4)
expected = str([self.d4, self.d3, self.d2, self.d1])
self.assertEqual(expected, str(self.cola))
def test_sacar(self):
self.cola.poner(self.d1)
self.cola.poner(self.d2)
self.cola.poner(self.d3)
self.cola.poner(self.d4)
self.assertEqual(self.d1, self.cola.sacar())
self.assertEqual(self.d2, self.cola.sacar())
self.assertEqual(self.d3, self.cola.sacar())
self.assertEqual(self.d4, self.cola.sacar())
self.assertRaises(IndexError, self.cola.sacar)
def test_tope(self):
self.cola.poner(self.d1)
self.assertEqual(self.d1, self.cola.tope())
self.cola.poner(self.d2)
self.assertEqual(self.d1, self.cola.tope())
self.cola.poner(self.d3)
self.assertEqual(self.d1, self.cola.tope())
self.cola.poner(self.d4)
self.assertEqual(self.d1, self.cola.tope())
def test_EsVacia_si(self):
self.assertTrue(self.cola.esVacia())
self.cola.poner(self.d1)
elem = self.cola.sacar()
self.assertTrue(self.cola.esVacia())
def test_EsVacia_no(self):
self.cola.poner(self.d1)
self.assertFalse(self.cola.esVacia())
self.cola.poner(self.d2)
self.assertFalse(self.cola.esVacia())
elem = self.cola.sacar()
self.assertFalse(self.cola.esVacia())
