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