def test_carga():
lst = []
lst = lt.newList()
file = "Data/GoodReads/books.csv"
sep = ','
dialect = csv.excel()
dialect.delimiter = sep
assert (lt.size(lst) == 0), "la lista no empieza en cero"
try:
with open(file, encoding='utf-8') as csvfile:
reader = csv.DictReader(csvfile, dialect=dialect)
for row in reader:
lst.append(row)
lt.addLast(lst, row)
except:
assert False, "Se presento un error al cargar el archivo"
assert len(lst) == lt.size(lst), "Son diferentes tamaños"
for i in range(len(lst)):
assert lt.getElement(
lst, i + 1) == lst[i], "Las listas no estan en el mismo orden"
def test_carga():
lista = []
lst = lt.newList('ARRAY_LIST', cmpfunction)
file = config.data_dir + 'MoviesCastingRaw-small.csv'
sep = ';'
dialect = csv.excel()
dialect.delimiter = sep
assert (lt.size(lst) == 0), "La lista no empieza en cero."
try:
with open(file, encoding='utf-8') as csvfile:
reader = csv.DictReader(csvfile, dialect=dialect)
for row in reader:
lista.append(row)
lt.addLast(lst, row)
except:
assert False, "Se presento un error al cargar el archivo."
assert len(lista) == lt.size(lst), "Son diferentes tamaños."
for i in range(len(lista)):
assert lt.getElement(
lst, i + 1) == lista[i], "Las listas no estan en el mismo orden."
def test_carga():
lista = []
lst = lt.newList()
file = "Data\theMoviesdb\MoviesCastingRaw-small.csv"
sep = ";"
dialect = csv.excel()
dialect.delimiter = sep
assert (lt.size(lst) == 0), "la lista no empieza en cero"
try:
with open(file, enconding='utf-8') as csvfile:
reader = csv.DictReader(csvfile, dialect=dialect)
for row in reader:
lista.append(row)
lt.addLast(lst, row)
except:
assert False, "Se presento un error al cargar el archivo"
assert len(lista) == lt.size(lst), "son diferentes tamaños"
for i in range(len(lista)):
assert lt.getElement(
lst, i + 1) == lista[i], "las listas no estan en el mismo orden"
def test_addFirst(self):
self.lst = slt.newList('ARRAY_LIST')
slt.addFirst(self.lst, self.book1)
self.assertEqual(slt.size(self.lst), 1)
slt.addFirst(self.lst, self.book2)
self.assertEqual(slt.size(self.lst), 2)
book = slt.firstElement(self.lst)
self.assertDictEqual(book, self.book2)
def test_addFirst(self):
self.lst = slt.newList('ARRAY_LIST')
self.assertEqual(slt.isEmpty(self.lst), True)
self.assertEqual(slt.size(self.lst), 0)
slt.addFirst(self.lst, self.movie1)
self.assertEqual(slt.size(self.lst), 1)
slt.addFirst(self.lst, self.movie2)
self.assertEqual(slt.size(self.lst), 2)
movie = slt.firstElement(self.lst)
self.assertDictEqual(movie, self.movie2)
def test_insertElement(self):
self.lst = slt.newList('ARRAY_LIST')
slt.insertElement(self.lst, self.book1, 1)
self.assertEqual(slt.size(self.lst), 1)
slt.insertElement(self.lst, self.book2, 1)
self.assertEqual(slt.size(self.lst), 2)
book = slt.getElement(self.lst, 1)
self.assertDictEqual(book, self.book2)
book = slt.getElement(self.lst, 2)
self.assertDictEqual(book, self.book1)
def test_addFirst (self):
self.lst = slt.newList()
self.assertEqual (slt.isEmpty(self.lst), True)
self.assertEqual (slt.size(self.lst), 0)
slt.addFirst (self.lst, self.book1)
self.assertEqual (slt.size(self.lst), 1)
slt.addFirst (self.lst, self.book2)
self.assertEqual (slt.size(self.lst), 2)
book = slt.firstElement(self.lst)
self.assertDictEqual (book, self.book2)
def test_getElement(self):
self.lst = slt.newList()
slt.addLast(self.lst, self.book1)
self.assertEqual(slt.size(self.lst), 1)
slt.addLast(self.lst, self.book2)
self.assertEqual(slt.size(self.lst), 2)
book = slt.getElement(self.lst, 1)
self.assertDictEqual(book, self.book1)
book = slt.getElement(self.lst, 2)
self.assertDictEqual(book, self.book2)
def test_listAddFirst(self):
"""
Lista con elementos en orden aleatorio
"""
self.lst = lt.newList()
lt.addFirst(self.lst, self.book1)
self.assertEqual(lt.size(self.lst), 1)
lt.addFirst(self.lst, self.book2)
self.assertEqual(lt.size(self.lst), 2)
book = lt.firstElement(self.lst)
self.assertDictEqual(book, self.book2)
def keySet(map):
"""
Retorna una lista con todas las llaves de la tabla de hash
"""
ltset = lt.newList()
for pos in range(lt.size(map['table'])):
bucket = lt.getElement(map['table'], pos + 1)
for element in range(lt.size(bucket)):
entry = lt.getElement(bucket, element + 1)
lt.addLast(ltset, entry['key'])
return ltset
def test_addFirstEmpty(self):
"""
Con la lista vacia
"""
self.lst = slt.newList('SINGLE_LINKED_LIST')
self.assertEqual(slt.isEmpty(self.lst), True)
self.assertEqual(slt.size(self.lst), 0)
slt.addFirst(self.lst, self.book1)
self.assertEqual(slt.size(self.lst), 1)
book = slt.firstElement(self.lst)
self.assertDictEqual(book, self.book1)
def valueSet(map):
"""
Retornar una lista con todos los valores de la tabla de hash
"""
ltset = lt.newList()
for pos in range(lt.size(map['table'])):
bucket = lt.getElement(map['table'], pos + 1)
for element in range(lt.size(bucket)):
entry = lt.getElement(bucket, element + 1)
lt.addLast(ltset, entry['value'])
return ltset
def test_insertElement (self):
self.lst = slt.newList()
self.assertEqual (slt.isEmpty(self.lst), True)
self.assertEqual (slt.size(self.lst), 0)
slt.insertElement (self.lst, self.book1, 1)
self.assertEqual (slt.size(self.lst), 1)
slt.insertElement (self.lst, self.book2, 1)
self.assertEqual (slt.size(self.lst), 2)
book = slt.getElement(self.lst, 1)
self.assertDictEqual (book, self.book2)
book = slt.getElement(self.lst, 2)
self.assertDictEqual (book, self.book1)
def test_removeFirst(self):
self.lst = slt.newList('ARRAY_LIST')
slt.addLast(self.lst, self.book1)
slt.addLast(self.lst, self.book2)
slt.removeFirst(self.lst)
book = slt.getElement(self.lst, 1)
self.assertEqual(slt.isEmpty(self.lst), False)
self.assertEqual(slt.size(self.lst), 1)
self.assertDictEqual(book, self.book2)
slt.removeFirst(self.lst)
self.assertEqual(slt.isEmpty(self.lst), True)
self.assertEqual(slt.size(self.lst), 0)
def test_removeLast(self):
self.lst = slt.newList('ARRAY_LIST')
self.assertEqual(slt.isEmpty(self.lst), True)
self.assertEqual(slt.size(self.lst), 0)
slt.addLast(self.lst, self.movie1)
self.assertEqual(slt.size(self.lst), 1)
slt.addLast(self.lst, self.movie2)
self.assertEqual(slt.size(self.lst), 2)
slt.removeLast(self.lst)
movie = slt.getElement(self.lst, 1)
self.assertEqual(slt.isEmpty(self.lst), False)
self.assertEqual(slt.size(self.lst), 1)
self.assertDictEqual(movie, self.movie1)
def req4(criteria, lstCast, lstMov):
"""
Retorna la cantidad de elementos que cumplen con un criterio para una columna dada
"""
# Guardar los id de las peliculas del actor
idMov = lt.newList("ARRAY_LIST", compFunc)
# Guardar el nombre del director y el numero de las colaboraciones
myDirectorDic = {}
for i in range(lt.size(lstCast)):
director = lt.getElement(lstCast, i)
if criteria == director['actor1_name'] or criteria == director['actor2_name'] or criteria == director['actor3_name'] or criteria == director['actor4_name'] or criteria == director['actor5_name']:
lt.addLast(idMov, director['id'])
dir_name = director['director_name']
# revisa si la llave existe
if dir_name in myDirectorDic:
myDirectorDic[dir_name] = int(myDirectorDic[dir_name]) + 1
else:
myDirectorDic[dir_name] = 1
pelicula = lt.newList("ARRAY_LIST", compFunc)
numPel = 0
calProm = 0.0
for i in range(lt.size(lstMov)):
id = lt.getElement(lstMov, i)['id']
if lt.isPresent(idMov, id) > 0:
lt.addLast(pelicula, lt.getElement(lstMov, i)['title'])
numPel += 1
calProm += float(lt.getElement(lstMov, i)['vote_average'])
if numPel == lt.size(idMov):
break
prom = 0.0
if numPel != 0:
prom = calProm / numPel
# Busca el director con mayores colaboraciones
actual = 0
name = ""
for k, v in myDirectorDic.items():
if actual < int(v):
actual = int(v)
name = str(k)
res = "Para el actor " + str(criteria) + "\nEl director con el cual más a trabajado es: " + str(
name) + "\nSu peliculas tienen un calficación promedio de: " + str(prom) + "\nEl numero de peliculas del actor es: " + str(numPel) + "\n"
return pelicula, res
def new_copy(lst, datastructure="SINGLE_LINKED", cmpfunction=None):
copia = lt.newList(datastructure, cmpfunction)
for i in range(1, lt.size(lst) + 1):
a = lt.getElement(lst, i)
lt.addLast(copia, a)
return copia
def degree(graph, vertex):
"""
Retorna el numero de arcos asociados al vertice vertex
"""
element = map.get(graph['vertices'], vertex)
lst = element['value']
return (lt.size(lst))
def ranking_genero(genero: str, num_peliculas: int, lst1: list, lst2: list,
criterio: int):
t1_start = process_time() #tiempo inicial
movies_lt = lt.newList(datastructure='ARRAY_LIST', cmpfunction=None)
j = 1
filas = len(lst1)
while j < filas:
elemento = lst1[j]["genres"]
if genero in elemento:
movie_name = lst1[j]["original_title"]
movie_vote_average = float(lst1[j]["vote_average"])
movie_vote_count = float(lst1[j]["vote_count"])
movie = {
'movie_name': movie_name,
'vote_average': movie_vote_average,
'vote_count': movie_vote_count
}
lt.addLast(movies_lt, movie)
j = j + 1
if criterio == 1:
mg.mergesort(movies_lt, greater_num)
if criterio == 2:
mg.mergesort(movies_lt, greater_rating)
pedazo_mejores = lt.subList(movies_lt, 1, num_peliculas)
pos_inicial_peores = lt.size(movies_lt) - num_peliculas
pedazo_peores = lt.subList(movies_lt, pos_inicial_peores, num_peliculas)
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
return pedazo_mejores["elements"], pedazo_peores["elements"]
def ranking_peliculas2(num_peliculas: int, lst1: list, lst2: list,
criterio2: int):
t1_start = process_time() #tiempo inicial
movies_lt = lt.newList(datastructure='ARRAY_LIST', cmpfunction=None)
i = 1
filas = len(lst1)
while i < filas:
movie_name = lst1[i]["original_title"]
movie_vote_average = float(lst1[i]["vote_average"])
movie_vote_count = float(lst1[i]["vote_count"])
movie = {
'movie_name': movie_name,
'vote_average': movie_vote_average,
'vote_count': movie_vote_count
}
lt.addLast(movies_lt, movie)
i = i + 1
if criterio2 == 1:
mg.mergesort(movies_lt, mejor_calificada)
if criterio2 == 2:
mg.mergesort(movies_lt, peor_calificada)
conjunto_mejores_calificadas = lt.subList(movies_lt, 1, num_peliculas)
pos_inicial_peores_calificadas = lt.size(movies_lt) - num_peliculas
conjunto_peores_calificadas = lt.subList(movies_lt,
pos_inicial_peores_calificadas,
num_peliculas)
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
return conjunto_mejores_calificadas[
"elements"], conjunto_peores_calificadas["elements"]
def moviesByActor(casting, details):
peliculas_dirigidas_por_x_director = lt.newList('SINGLE_LINKED', None)
actor = input("Ingrese el actor:\n")
t1_start = process_time()
iter = listiterator.newIterator(casting)
while listiterator.hasNext(iter):
d = listiterator.next(iter)
if d["actor1_name"] == actor or d["actor2_name"] == actor or d[
"actor3_name"] == actor or d["actor4_name"] == actor or d[
"actor5_name"] == actor:
lt.addFirst(peliculas_dirigidas_por_x_director, d)
peliculas = lt.newList('SINGLE_LINKED', None)
directores = {}
iter1 = listiterator.newIterator(peliculas_dirigidas_por_x_director)
while listiterator.hasNext(iter1):
ide = listiterator.next(iter1)
iter2 = listiterator.newIterator(details)
while listiterator.hasNext(iter2):
p = listiterator.next(iter2)
if ide["id"] == p["id"]:
lt.addFirst(peliculas, p)
print(p["original_title"])
if ide["director_name"] in directores:
directores[ide["director_name"]] += 1
else:
directores[ide["director_name"]] = 1
#encontrar directores pelis
maximo_colab = max(directores, key=directores.get)
#encontrar los datos
numero_peliculas_director = lt.size(peliculas)
suma_promedio_voto = 0
iter = listiterator.newIterator(peliculas)
while listiterator.hasNext(iter):
s = listiterator.next(iter)
suma_promedio_voto += float(s["vote_average"])
promedio_pelis = 0
if (numero_peliculas_director > 0):
promedio_pelis = suma_promedio_voto / numero_peliculas_director
#print("Peliculas dirigidas por "+ director +": " + str(peliculas['title'])) Encontrar los nombres de las peliculas
print("Numero de películas de " + actor + ": " +
str(numero_peliculas_director))
print("Promedio de calificación de las peliculas del actor: " +
str(promedio_pelis))
print("el director con mayor número de colaboraciones es: " + maximo_colab)
def valueSet(map):
"""
Retornar una lista con todos los valores de la tabla de hash
"""
ltset = lt.newList()
for pos in range(lt.size(map['table'])):
entry = lt.getElement(map['table'], pos + 1)
if (entry['value'] != None and entry['value'] != '__EMPTY__'):
lt.addLast(ltset, entry['value'])
return ltset
def keySet(map):
"""
Retorna una lista con todas las llaves de la tabla de hash
"""
ltset = lt.newList()
for pos in range(lt.size(map['table'])):
entry = lt.getElement(map['table'], pos + 1)
if (entry['key'] != None and entry['key'] != '__EMPTY__'):
lt.addLast(ltset, entry['key'])
return ltset
def req6(x, criteria, sentido, lstMov, genre):
pelicula = lt.newList("ARRAY_LIST")
numPel = 0
voteProm = 0.0
voteAverage = 0.0
for i in range(lt.size(lstMov)):
if lt.getElement(lstMov, i)['genres'].find(genre) != -1:
lt.addLast(pelicula, lt.getElement(lstMov, i))
res = "THE " + str(x) + " "
if criteria == 0 and sentido == 0:
sort.mergesort(pelicula, lessV)
res = res + "WORST VOTE "
elif criteria == 0 and sentido == 1:
sort.mergesort(pelicula, greaterV)
res = res + "BEST VOTE "
elif criteria == 1 and sentido == 0:
sort.mergesort(pelicula, lessA)
res = res + "WORST AVERAGE "
else:
sort.mergesort(pelicula, greaterA)
res = res + "BEST AVERAGE "
sub = lt.subList(pelicula, 1, x)
for i in range(lt.size(sub)):
numPel += 1
voteProm += float(lt.getElement(sub, i)['vote_count'])
voteAverage += float(lt.getElement(sub, i)['vote_average'])
prom1 = 0.0
prom2 = 0.0
if numPel != 0:
prom1 = voteProm/numPel
prom2 = voteAverage/numPel
res = res + genre + " Movies\n Promedio de votos: " + \
str(prom1) + " Votación promedio: " + str(prom2) + "\n"
return sub, res
def isEmpty(map):
"""
Informa si la tabla de hash se encuentra vacia
"""
empty = True
for pos in range(lt.size(map['table'])):
entry = lt.getElement(map['table'], pos + 1)
if (entry['key'] != None and entry['key'] != '__EMPTY__'):
empty = False
break
return empty
def isEmpty(map):
"""
Informa si la tabla de hash se encuentra vacia
"""
bucket = lt.newList()
empty = True
for pos in range(lt.size(map['table'])):
bucket = lt.getElement(map['table'], pos + 1)
if lt.isEmpty(bucket) == False:
empty = False
break
return empty
def outdegree(graph, vertex):
"""
Retorna el numero de arcos que salen del grafo vertex
"""
try:
if (graph['directed']):
element = map.get(graph['vertices'], vertex)
lst = element['value']
return (lt.size(lst))
return 0
except:
return None
def test_addFirstMultiElements(self):
"""
Con muchos elementos en la lista
"""
self.lst = slt.newList('SINGLE_LINKED_LIST')
slt.addFirst(self.lst, self.book1)
slt.addFirst(self.lst, self.book2)
slt.addFirst(self.lst, self.book3)
slt.addFirst(self.lst, self.book4)
slt.addFirst(self.lst, self.book5)
self.assertEqual(slt.size(self.lst), 5)
book = slt.firstElement(self.lst)
self.assertDictEqual(book, self.book5)
def size(lst):
""" Informa el número de elementos de la lista.
Args
lst: La lista a examinar
Raises:
Exception
"""
try:
return lt.size(lst)
except Exception as exp:
error.reraise(exp, 'TADList->size: ')
def shellSort(lst, lessfunction, column):
n = lt.size(lst)
h = 1
while h < n / 3: # Se calcula el tamaño del primer gap. La lista se h-ordena con este tamaño
h = 3 * h + 1 # por ejemplo para n = 100, h toma un valor inical de 13 , 4, 1
while (h >= 1):
for i in range(h, n):
j = i
while (j >= h) and lessfunction(lt.getElement(
lst, j + 1), lt.getElement(lst, j - h + 1), column):
lt.exchange(lst, j + 1, j - h + 1)
j -= h
h //= 3 # h se decrementa en un tercio. cuando h es igual a 1, se comporta como insertionsort
