def peliculas_por_actor(listaActores, listaPeliculas, nombreActor):
pos_actor = lt.isPresent(listaActores, nombreActor)
actor = lt.getElement(listaActores, pos_actor)
itera = it.newIterator(actor["peliculas"])
print("Contidad de peliculas actor ", nombreActor, ": ",
actor["peliculas"]["size"], "\n")
average = 0
while it.hasNext(itera):
id_pelicula = it.next(itera)
posicion = lt.isPresent(listaPeliculas, id_pelicula)
peliculas = lt.getElement(listaPeliculas, posicion)
average += float(peliculas["vote_average"])
print(peliculas["original_title"])
promedio = average / actor["peliculas"]["size"]
print("El promedio de todas sus peliculas es:\n", promedio)
#con que directores ha trabajado mas
itera = it.newIterator(actor["director"])
while it.hasNext(itera):
diretor = it.next(itera)
print("director ", diretor)
shell.shellSort1(actor["director"], greater, "count")
print("Director con mas colaboraciones:\n")
print(lt.getElement(actor["director"], 1))
def peliculas_por_director(lstDirectores, lstPelicuas, criterio):
pos = lt.isPresent(lstDirectores, criterio)
if pos == 0:
print("No existe diretor")
return None
else:
director = lt.getElement(lstDirectores, pos)
listaBuenasPeliculas = {'peliculas': None, 'promedio': None}
listaBuenasPeliculas['peliculas'] = lt.newList()
lista_ids = director['ids_peliculas']
itera = it.newIterator(lista_ids)
average = 0
while it.hasNext(itera):
id = it.next(itera)
pos1 = lt.isPresent(lstPelicuas, id)
peli = lt.getElement(lstPelicuas, pos1)
if float(peli['vote_average']) >= 6:
lt.addLast(listaBuenasPeliculas['peliculas'],
peli['original_title'])
average = average + float(peli['vote_average'])
listaBuenasPeliculas['promedio'] = average
return listaBuenasPeliculas
def cargar_listaActores(file, sep=";"):
lst = lt.newList('SINGLE_LINKED', comparar_actores)
dialect = csv.excel()
dialect.delimiter = sep
nombres_actores = [
"actor1_name", "actor2_name", "actor3_name", "actor4_name",
"actor5_name"
]
try:
with open(file, encoding="utf-8") as csvfile:
spamreader = csv.DictReader(csvfile, dialect=dialect)
for row in spamreader:
#print(row)
# agregar una lista para los directores
#directores ={}
#directores["director"] =lt.newList('SINGLE_LINKED', comparar_directores) #lista directores
for nombreCol in nombres_actores:
actor = {}
actor["nombre"] = row[nombreCol]
posicion1 = lt.isPresent(lst, actor["nombre"])
if posicion1 == 0:
actor["peliculas"] = lt.newList(
) #ids Peliculas del actor
actor["director"] = lt.newList(
'SINGLE_LINKED',
comparar_director) #lista directores
lt.addLast(actor["peliculas"], row["id"])
director = {}
director["nombre"] = row["director_name"]
director["count"] = 1
lt.addLast(actor["director"], director)
lt.addLast(lst, actor)
else:
actores = lt.getElement(lst, posicion1)
lt.addLast(actores["peliculas"], row["id"])
#validra si ya esta el director o no
pos_director = lt.isPresent(actores["director"],
row["director_name"])
if pos_director == 0: # no esta crear director
director = {}
director["nombre"] = row["director_name"]
director["count"] = 1
lt.addLast(actores["director"], director)
else: # ya esta ese director aumnetar count en uno
director = lt.getElement(actores["director"],
pos_director)
director["count"] = director["count"] + 1
except:
print("Hubo un error con la carga del archivo")
return lst
def cargar_peliculas_por_genero(file, sep=";"):
lst = lt.newList(
'SINGLE_LINKED',
comparar_genero) #Usando implementacion linkedlist
print("Cargando archivo ....")
dialect = csv.excel()
dialect.delimiter = sep
with open(file, encoding="utf-8") as csvfile:
spamreader = csv.DictReader(csvfile, dialect=dialect)
for row in spamreader:
generos = row['genres'].split("|")
for genero in generos:
elemento = {}
elemento["genero"] = genero
posicion1 = lt.isPresent(
lst, elemento["genero"])
if posicion1 == 0: # no esta
elemento["peliculas"] = lt.newList(
'SINGLE_LINKED', comparar_pelicula
) #lista con las peliculas por genero
elemento["sum_Votos"] = int(
row["vote_count"])
elemento["sum_average"] = float(
row["vote_average"])
lt.addLast(elemento["peliculas"],
row["original_title"])
lt.addLast(
lst, elemento
) # se adiciona a la lista de todos los elemnetos lst
else:
elemento_row = lt.getElement(
lst, posicion1)
#revisar si la peicula ya esta
posi_peli = lt.isPresent(
elemento_row['peliculas'],
row["original_title"])
if posi_peli == 0:
lt.addLast(elemento_row["peliculas"],
row["original_title"])
elemento_row["sum_Votos"] += int(
row["vote_count"])
elemento_row["sum_average"] += float(
row["vote_average"])
return lst
def addBookTag(catalog, tag, comparefunction, comparegoodreadsid):
"""
Agrega una relación entre un libro y un tag asociado a dicho libro
"""
bookid = tag['goodreads_book_id']
tagid = tag['tag_id']
pos = lt.isPresent(catalog['tags'], tagid, comparefunction)
if pos:
tagbook = lt.getElement(catalog['tags'], pos)
tagbook['total_books'] += 1
tagbook['count'] += int(tag['count'])
posbook = lt.isPresent(catalog['books'], bookid, comparegoodreadsid)
if posbook:
book = lt.getElement(catalog['books'], posbook)
lt.addLast(tagbook['books'], book)
def conocer_un_actor(lista1, lista2, name):
retorno = {
'ids': [],
'movies_names': [],
'average': 0.0,
'director_name': []
}
it_list1 = it.newIterator(lista1)
mayor = ""
res = 0
while it.hasNext(it_list1) == True:
data = it.next(it_list1)
for i in range(1, 6):
if data['actor' + str(i) + '_name'].lower().strip() == name:
retorno['ids'].append(data["id"])
retorno["director_name"].append(data["director_name"])
for i in retorno['ids']:
pos = lt.isPresent(lista2, {'id': i})
retorno['movies_names'].append(
lt.getElement(lista2, pos)['original_title'])
retorno['average'] += float(lt.getElement(lista2, pos)['vote_average'])
for i in retorno['director_name']:
if retorno['director_name'].count(i) > res:
res = retorno['director_name'].count(i)
mayor = i
if len(retorno['ids']) > 0:
return (retorno['movies_names'],
round(retorno['average'] / len(retorno['ids']), 2), mayor)
else:
return -1
def loadActors(catalog):
'''
Carga todos los actores
'''
t1_start = process_time() #tiempo inicial
castingfile = cf.data_dir + 'themoviesdb/MoviesCastingRaw-small.csv'
dialect = csv.excel()
dialect.delimiter=';'
with open(castingfile, encoding='utf-8') as csvfile:
spamreader = csv.DictReader(csvfile, dialect=dialect)
movie_counter = 1
casting = ['actor1_name', 'actor2_name', 'actor3_name', 'actor4_name', 'actor5_name']
for row in spamreader:
for actor in casting:
actor_name = row[actor]
if not actor_name == 'none':
director_name = row['director_name']
pos = lt.isPresent(actor_name, catalog['actors'], equal)
if pos != 0:
model.updateActor(catalog, pos, movie_counter, director_name)
else:
model.addActor(catalog, row, movie_counter)
movie_counter += 1
t1_stop = process_time() #tiempo inicial
print('Tiempo de ejecución carga actores',t1_stop-t1_start,' segundos')
endActorslist_controller(catalog)
def cargar_directores(file, sep=";"):
lst = lt.newList(
'SINGLE_LINKED',
comparar_director) #Usando implementacion linkedlist
print("Cargando archivo ....")
t1_start = process_time() #tiempo inicial
dialect = csv.excel()
dialect.delimiter = sep
try:
with open(file, encoding="utf-8") as csvfile:
spamreader = csv.DictReader(csvfile,
dialect=dialect)
for row in spamreader:
director = {}
director["nombre"] = row["director_name"]
posicion1 = lt.isPresent(
lst, director["nombre"])
if posicion1 == 0:
director["peliculas"] = lt.newList()
lt.addLast(director["peliculas"],
row["id"])
lt.addLast(lst, director)
else:
directores = lt.getElement(lst, posicion1)
lt.addLast(directores["peliculas"],
row["id"])
except:
print("Hubo un error con la carga del archivo")
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", t1_stop - t1_start,
" segundos")
return lst
def getBookInList(catalog, bookTitle):
"""
Retorna el libro desde la lista a partir del titulo
"""
pos = lt.isPresent(catalog['booksList'], bookTitle, compareByTitle)
if pos:
return lt.getElement(catalog['booksList'], pos)
return None
def getMovieInList(catalog, movieTitle):
"""
Retorna el libro desde la lista a partir del titulo
"""
pos = lt.isPresent(catalog['moviesList'], movieTitle, compareByTitle)
if pos:
return lt.getElement(catalog['moviesList'], pos)
return None
def cargar_peliculas_genero(file, sep=";"):
lst = lt.newList('SINGLE_LINKED',
comparar_genero) #Usando implementacion linkedlist
print("Cargando archivo ....")
t1_start = process_time() #tiempo inicial
dialect = csv.excel()
dialect.delimiter = sep
try:
with open(file, encoding="utf-8") as csvfile:
spamreader = csv.DictReader(csvfile, dialect=dialect)
for row in spamreader:
generos = row['genres'].split("|")
#print(generos)
for genero in generos:
elemento = {}
elemento["genero"] = genero
# lst es la lista con todos los elementos
posicion1 = lt.isPresent(lst, elemento["genero"])
if posicion1 == 0: # no esta
elemento["peliculas"] = lt.newList(
'SINGLE_LINKED', comparar_pelicula
) #lista con las peliculas por genero
elemento["sum_Votos"] = int(row["vote_count"])
lt.addLast(elemento["peliculas"],
row["original_title"])
lt.addLast(
lst, elemento
) # se adiciona a la lista de todos los elemnetos lst
else:
elemento_row = lt.getElement(lst, posicion1)
#revisar si la peicula ya esta
posi_peli = lt.isPresent(elemento_row['peliculas'],
row["original_title"])
if posi_peli == 0:
lt.addLast(elemento_row["peliculas"],
row["original_title"])
elemento_row["sum_Votos"] += int(row["vote_count"])
except:
print("Hubo un error con la carga del archivo")
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
return lst
def test_deleteElement(lstmovies, movies):
pos = lst.isPresent(lstmovies, movies[2])
assert pos > 0
movie = lst.getElement(lstmovies, pos)
assert movie == movies[2]
lst.deleteElement(lstmovies, pos)
assert lst.size(lstmovies) == 4
movie = lst.getElement(lstmovies, pos)
assert movie == movies[3]
def test_deleteElement(lstbooks, books):
pos = lt.isPresent(lstbooks, books[2])
assert pos > 0
book = lt.getElement(lstbooks, pos)
assert book == books[2]
lt.deleteElement(lstbooks, pos)
assert lt.size(lstbooks) == 4
book = lt.getElement(lstbooks, pos)
assert book == books[3]
def addMovieListVoteData(catalog, row):
"""
Adiciona información a una película
"""
movies = catalog["moviesList"]
movie_pos = lt.isPresent(movies, row["id"], comparemovies)
if movie_pos != 0:
movie = lt.getElement(movies, movie_pos)
model.addMovieListVoteData(movie, row)
def getBooksByAuthor(catalog, authorname, compareauthors):
"""
Retorna un autor con sus libros a partir del nombre del autor
"""
posauthor = lt.isPresent(catalog['authors'], authorname, compareauthors)
if posauthor > 0:
author = lt.getElement(catalog['authors'], posauthor)
return author
return None
def getBooksByAuthor(catalog, director_name, compareauthors):
"""
Retorna un autor con sus libros a partir del nombre del autor
"""
directore = lt.isPresent(catalog['Directores'], director_name,
compareauthors)
if directore > 0:
direc = lt.getElement(catalog['Directores'], directore)
return direc
return None
def getMoviesByActor(catalog, act_name):
"""
Esta función retorna el primer actor con el nombre indicado
"""
iterator = it.newIterator(catalog['actors'])
iterator = catalog['actors']
iterator2 = catalog['movies']
suma = 0
peliculas = lt.newList("ARRAY_LIST")
director = ""
numdirector = -1
posicion = lt.isPresent(iterator, act_name, ct.comparepeople)
if posicion != 0:
actor = lt.getElement(iterator, posicion)
for pelicula in actor["movie_id"]["elements"]:
for element in iterator2["elements"]:
if element["id"] == pelicula:
lt.addLast(peliculas, element)
suma += float(element["vote_average"])
for direc in actor["dir_name"]["elements"]:
cont = actor["dir_name"]["elements"].count(direc)
if numdirector < cont:
numdirector = cont
director = direc
contador = lt.size(actor["movie_id"])
promedio = round(suma / (contador), 2)
print('El número de películas del actor es: ',contador,',\nSu promedio de votos es: ',promedio,\
"\nel director que más lo ha dirigido es: ", director )
else:
print("El actor ingresado no se encuentra en la lista")
return peliculas
"""
for elemento in iterator['elements']:
directores=0
director= ""
if act_name.lower() in elemento['name'].lower():
for elemento2 in iterator2['elements']:
if elemento['movie_id']["elements"]==elemento2['id']:
suma+=float(elemento2['vote_average'])
for elemento3 in iterator3['elements']:
directorescontador=0
if elemento['dir_name']==elemento3['name'].lower():
directorescontador+=1
if directorescontador> directores:
director== elemento["dir_name"]
directores= directorescontador
"""
"""
def test_adjacents(self):
graph = g.newGraph(7, self.comparenames, directed=True)
g.insertVertex(graph, 'Bogota')
g.insertVertex(graph, 'Yopal')
g.insertVertex(graph, 'Cali')
g.insertVertex(graph, 'Medellin')
g.insertVertex(graph, 'Pasto')
g.insertVertex(graph, 'Barranquilla')
g.insertVertex(graph, 'Manizales')
g.addEdge(graph, 'Bogota', 'Yopal')
g.addEdge(graph, 'Bogota', 'Medellin')
g.addEdge(graph, 'Bogota', 'Pasto')
g.addEdge(graph, 'Bogota', 'Cali')
g.addEdge(graph, 'Cali', 'Bogota')
g.addEdge(graph, 'Yopal', 'Medellin')
g.addEdge(graph, 'Medellin', 'Pasto')
g.addEdge(graph, 'Pasto', 'Bogota')
g.addEdge(graph, 'Cali', 'Pasto')
g.addEdge(graph, 'Cali', 'Barranquilla')
g.addEdge(graph, 'Barranquilla', 'Manizales')
g.addEdge(graph, 'Pasto', 'Manizales')
self.assertEqual(g.numEdges(graph), 12)
self.assertEqual(g.numVertex(graph), 7)
lst = g.adjacents(graph, 'Bogota')
self.assertEqual(lt.size(lst), 4)
self.assertTrue(lt.isPresent(lst, 'Cali', self.comparelst))
self.assertTrue(lt.isPresent(lst, 'Yopal', self.comparelst))
self.assertTrue(lt.isPresent(lst, 'Pasto', self.comparelst))
self.assertTrue(lt.isPresent(lst, 'Medellin', self.comparelst))
self.assertFalse(lt.isPresent(lst, 'Barranquilla', self.comparelst))
lst = g.adjacents(graph, 'Manizales')
self.assertEqual(lt.size(lst), 0)
def AddActor1(actor, actor_name, catalog):
"""
Revisa si el recuadro es none, si ya estaba presente el actor en la lista actualiza
su informacióm, en caso contrario crea el actor
"""
if actor[actor_name].lower() != "none":
if lt.isPresent(catalog["actors"], actor[actor_name],
ct.comparepeople) != 0:
UpdateActor(catalog, actor, actor[actor_name])
else:
a = newActor(actor[actor_name], actor['id'],
actor["director_name"])
lt.addLast(catalog['actors'], a)
def loadGenres (catalog):
'''
Carga el catálogo de géneros del archivo. Por cada género se cargan sus libros
'''
t1_start = process_time() #tiempo inicial
movies = catalog['movies']
for movie in movies:
genre_name = movie['genres']
pos = lt.isPresent(genre_name, catalog['genres'], equal)
if pos != 0:
model.updateGenre(catalog, movie, pos)
else:
model.addGenre(catalog, movie)
t1_stop = process_time() #tiempo final
print('Tiempo de ejecución carga peliculas',t1_stop-t1_start,' segundos')
endGenreslist_controller(catalog)
def peliculas_por_genero(listagenero, criterio):
pos = lt.isPresent(listagenero, criterio)
if pos == 0:
print(" No se necontro este genero")
return
else:
generos = lt.getElement(listagenero, pos)
lista_peliculas = generos["peliculas"]
itera = it.newIterator(lista_peliculas)
print("Las Peliculas del genero ", criterio, " son:")
while it.hasNext(itera):
pelicula = it.next(itera)
print(pelicula)
print("Numero de peliculas por genero: ", criterio, " es:",
lista_peliculas['size'])
print("El promedio en votos por genero: ", criterio, " es:",
generos['sum_Votos'] / lista_peliculas['size'])
def addBookAuthor(catalog, authorname, book, compareauthors):
"""
Adiciona un autor a lista de autores, la cual guarda referencias a los libros de dicho autor
"""
authors = catalog['authors']
posauthor = lt.isPresent(authors, authorname, compareauthors)
if posauthor > 0:
author = lt.getElement(authors, posauthor)
else:
author = newAuthor(authorname)
lt.addLast(authors, author)
lt.addLast(author['books'], book)
if (author['average_rating'] == 0.0):
author['average_rating'] = float(book['average_rating'])
else:
author['average_rating'] = (author['average_rating'] +
float(book['average_rating'])) / 2
def add_Movie_director(catalog, director_name, pelicula, compareauthors):
"""
Adiciona un autor a lista de autores, la cual guarda referencias a los libros de dicho autor
"""
directores = catalog['Directores']
posauthor = lt.isPresent(directores, director_name, compareauthors)
if posauthor > 0:
director = lt.getElement(directores, posauthor)
else:
director = newDirector(director_name)
lt.addLast(directores, director)
lt.addLast(director['Peliculas'], pelicula)
if (director['vote_average'] == 0.0):
director['vote_average'] = float(pelicula['vote_average'])
else:
director['vote_average'] = (director['vote_average'] +
float(pelicula['vote_average'])) / 2
def countBooksByTag(catalog, tag):
t1_start = process_time() #tiempo inicial
tags = catalog['tags']
bookcount = 0
pos = lt.isPresent(tags, tag, comparetagnames)
if pos > 0:
tag_element = lt.getElement(tags, pos)
if tag_element != None:
iterator = it.newIterator(catalog['book_tags'])
while it.hasNext(iterator):
book_tag = it.next(iterator)
if tag_element['tag_id'] == book_tag['tag_id']:
bookcount += 1
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución conteo libros por género", t1_stop - t1_start,
" segundos")
return bookcount
def conocerUnDirector(lst1, lst2, name):
retorno = {'ids': [], 'movies_names': [], 'average': 0.0}
it_list1 = it.newIterator(lst1)
while it.hasNext(it_list1) == True:
data = it.next(it_list1)
if data['director_name'].lower().strip() == name:
retorno['ids'].append(data['id'])
for i in retorno['ids']:
pos = lt.isPresent(lst2, {'id': i})
retorno['movies_names'].append(
lt.getElement(lst2, pos)['original_title'])
retorno['average'] += float(lt.getElement(lst2, pos)['vote_average'])
try:
size = len(retorno['movies_names'])
movies = retorno['movies_names']
average = round(retorno['average'] / size, 2)
except:
return -1
return (movies, average, size)
def tripCityforDates (catalog, start_date, end_date):
start_date=strToDate(start_date, '%m/%d/%Y') #Convertir fecha
end_date=strToDate(end_date, '%m/%d/%Y') #Convertir fecha
dateList = oms.valueRange(catalog['dateTree'], start_date, end_date, greater) #Lista de llaves entre las fechas dadas
response=''
tripsCityDays = map.newMap(capacity=11, maptype='CHAINING') #Se almacenan
if dateList:
print(dateList)
iteraDate=it.newIterator(dateList)
while it.hasNext(iteraDate):
dateElement = it.next(iteraDate)
#print(dateElement)
if oms.get(catalog['dateTree'],dateElement, greater):#Si el nodo tiene un valor asociado
if map.isEmpty(tripsCityDays):#Si cities está vacío, se le asigna el map de accidentes por ciudad del primer nodo
tripsCityDays = oms.get(catalog['dateTree'], dateElement, greater)
else: #De lo contrario, se compara cada ciudad del map de cada nodo con el map
ciudadesNodo = map.keySet(dateElement)#Lista de las ciudades que tuvieron accidentes en esa fecha(nodo)
ciudadesCities = map.keySet(tripsCityDays)
iteraCiudades = it.newIterator(ciudadesNodo)
while it.hasNext(iteraCiudades):
ciudadElement=it.next(iteraCiudades)# que está en el map de cada nodo
if ciudadElement:
if lt.isPresent(ciudadesCities, ciudadElement, compareByKey): #Se verifica si la ciudad está en los valores del map
num=map.get(tripsCityDays, ciudadElement)['value']
num+=map.get(dateElement, ciudadElement)['value']
map.put(tripsCityDays, ciudadElement, num)
else:
num= map.get(dateElement, ciudadElement)['value']
map.put(dateElement, ciudadElement, num)
if not map.isEmpty(tripsCityDays):
cityList= map.keySet(tripsCityDays)
iteracity=it.newIterator(cityList)
while it.hasNext(iteracity):
cityKey = it.next(iteracity)
response += str(cityKey) + ':' + str(map.get(tripsCityDays,cityKey)['value']) + " "
return response
return None
def loadDirectors(catalog):
'''
Carga todos los directores
'''
t1_start = process_time() #tiempo inicial
castingfile = cf.data_dir + 'themoviesdb/MoviesCastingRaw-small.csv'
dialect = csv.excel()
dialect.delimiter=';'
with open(castingfile, encoding='utf-8') as csvfile:
spamreader = csv.DictReader(csvfile, dialect=dialect)
movie_counter = 1
for row in spamreader:
director_name = row['director_name']
pos = lt.isPresent(director_name, catalog['directors'], equal)
if pos != 0:
model.updateDirector(catalog, pos, movie_counter)
else:
model.addDirector(catalog, row, movie_counter)
movie_counter += 1
t1_stop = process_time() #tiempo inicial
print('Tiempo de ejecución carga directores',t1_stop-t1_start,' segundos')
model.endDirectorslist(catalog['directors'])
def cargar_listaDirectores(file, sep=";"):
lst = lt.newList('SINGLE_LINKED', comparar_director)
dialect = csv.excel()
dialect.delimiter = sep
try:
with open(file, encoding="utf-8") as csvfile:
spamreader = csv.DictReader(csvfile, dialect=dialect)
for row in spamreader:
director = {}
director["nombre"] = row["director_name"]
posicion1 = lt.isPresent(lst, director["nombre"])
if posicion1 == 0:
director["ids_peliculas"] = lt.newList()
lt.addLast(director["ids_peliculas"], row['id'])
lt.addFirst(lst, director)
else:
director = lt.getElement(lst, posicion1)
lt.addLast(director["ids_peliculas"], row['id'])
except:
print("Hubo un error con la carga del archivo")
return lst
def main():
"""
Método principal del programa, se encarga de manejar todos los metodos adicionales creados
Instancia una lista vacia en la cual se guardarán los datos cargados desde el archivo
Args: None
Return: None
"""
while True:
printMenu() #imprimir el menu de opciones en consola
inputs = input(
'Seleccione una opción para continuar\n') #leer opción ingresada
if len(inputs) > 0:
if int(inputs[0]) == 1: #opcion 1
lstmovies = loadMovies()
elif int(inputs[0]) == 2: #opcion 2
pass
elif int(inputs[0]) == 3: #opcion 3
def cargar_directores(file, sep=";"):
lst = lt.newList(
'SINGLE_LINKED',
comparar_director) #Usando implementacion linkedlist
print("Cargando archivo ....")
t1_start = process_time() #tiempo inicial
dialect = csv.excel()
dialect.delimiter = sep
try:
with open(file, encoding="utf-8") as csvfile:
spamreader = csv.DictReader(csvfile,
dialect=dialect)
for row in spamreader:
director = {}
director["nombre"] = row["director_name"]
posicion1 = lt.isPresent(
lst, director["nombre"])
if posicion1 == 0:
director["peliculas"] = lt.newList()
lt.addLast(director["peliculas"],
row["id"])
lt.addLast(lst, director)
else:
directores = lt.getElement(lst, posicion1)
lt.addLast(directores["peliculas"],
row["id"])
except:
print("Hubo un error con la carga del archivo")
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", t1_stop - t1_start,
" segundos")
return lst
def cargar_peliculas(file, sep=";"):
lst = lt.newList('SINGLE_LINKED', comparar_id)
print("Cargando archivo ....")
#t1_start = process_time() #tiempo inicial
dialect = csv.excel()
dialect.delimiter = sep
try:
with open(file, encoding="utf-8") as csvfile:
spamreader = csv.DictReader(csvfile,
dialect=dialect)
for row in spamreader:
lt.addLast(lst, row)
except:
print("Hubo un error con la carga del archivo")
#t1_stop = process_time() #tiempo final
#print("Tiempo de ejecución ",t1_stop-t1_start," segundos")
return lst
lista_directores = cargar_directores(
cf.data_dir + "themoviesdb/AllMoviesCastingRaw.csv")
lista_peliculas = cargar_peliculas(
cf.data_dir + "themoviesdb/AllMoviesDetailsCleaned.csv")
print("longitud de la lista\n")
nombre_director = input("Ingrese el nombre de un director:\n")
pos = lt.isPresent(lista_directores, nombre_director)
directorr = lt.getElement(lista_directores, pos)
print(
"El numero de peliculas dirigidas por el director son:\n",
directorr["peliculas"]["size"])
itera = it.newIterator(directorr["peliculas"])
average = 0
while it.hasNext(itera):
elemento = it.next(itera)
posicion = lt.isPresent(lista_peliculas, elemento)
peliculas = lt.getElement(lista_peliculas, posicion)
print(peliculas["original_title"])
average += float(peliculas["vote_average"])
promedio = average / directorr["peliculas"]["size"]
print("El promedio de todas sus peliculas es:\n", promedio)
elif int(inputs[0]) == 4: #opcion 4
def cargar_listaActores(file, sep=";"):
lst = lt.newList('SINGLE_LINKED', comparar_actores)
dialect = csv.excel()
dialect.delimiter = sep
nombres_actores = [
"actor1_name", "actor2_name", "actor3_name",
"actor4_name", "actor5_name"
]
try:
with open(file, encoding="utf-8") as csvfile:
spamreader = csv.DictReader(csvfile,
dialect=dialect)
for row in spamreader:
#print(row)
# agregar una lista para los directores
#directores ={}
#directores["director"] =lt.newList('SINGLE_LINKED', comparar_directores) #lista directores
for nombreCol in nombres_actores:
actor = {}
actor["nombre"] = row[nombreCol]
posicion1 = lt.isPresent(
lst, actor["nombre"])
if posicion1 == 0:
actor["peliculas"] = lt.newList(
) #ids Peliculas del actor
actor["director"] = lt.newList(
'SINGLE_LINKED', comparar_director
) #lista directores
lt.addLast(actor["peliculas"],
row["id"])
director = {}
director["nombre"] = row[
"director_name"]
director["count"] = 1
lt.addLast(actor["director"], director)
lt.addLast(lst, actor)
else:
actores = lt.getElement(lst, posicion1)
lt.addLast(actores["peliculas"],
row["id"])
#validra si ya esta el director o no
pos_director = lt.isPresent(
actores["director"],
row["director_name"])
if pos_director == 0: # no esta crear director
director = {}
director["nombre"] = row[
"director_name"]
director["count"] = 1
lt.addLast(actores["director"],
director)
else: # ya esta ese director aumnetar count en uno
director = lt.getElement(
actores["director"],
pos_director)
director["count"] = director[
"count"] + 1
except:
print("Hubo un error con la carga del archivo")
return lst
def cargar_peliculas(file, sep=";"):
lst = lt.newList('SINGLE_LINKED', comparar_id)
print("Cargando archivo ....")
#t1_start = process_time() #tiempo inicial
dialect = csv.excel()
dialect.delimiter = sep
try:
with open(file, encoding="utf-8") as csvfile:
spamreader = csv.DictReader(csvfile,
dialect=dialect)
for row in spamreader:
lt.addLast(lst, row)
except:
print("Hubo un error con la carga del archivo")
#t1_stop = process_time() #tiempo final
#print("Tiempo de ejecución ",t1_stop-t1_start," segundos")
return lst
listaActores = cargar_listaActores(
cf.data_dir + "themoviesdb/AllMoviesCastingRaw.csv")
listaPelicuas = cargar_peliculas(
cf.data_dir + "themoviesdb/AllMoviesDetailsCleaned.csv")
criterio = input("Nombre del actor : ")
peliculas_por_actor(listaActores, listaPelicuas, criterio)
elif int(inputs[0]) == 5: #opcion 5
genero = input("Ingrese el genero:\n")
itera = it.newIterator(lstmovies)
average = 0
numero = 0
lista_peliculas = lt.newList('ARRAY_LIST', cmpfunction=None)
while it.hasNext(itera):
elemento = it.next(itera)
if elemento["genres"] is None:
pass
else:
if genero in elemento["genres"]:
numero += 1
try:
average += float(elemento["vote_average"])
lt.addLast(lista_peliculas,
elemento["original_title"])
except:
pass
promedio = average / numero
tamano = lt.size(lista_peliculas)
if tamano == 0:
print("No hay peliculas que coincidan con el genero.")
else:
iteraa = it.newIterator(lista_peliculas)
while it.hasNext(iteraa):
pelicula = it.next(iteraa)
print(pelicula)
print("La cantidad de peliculas de este genero es:", tamano)
print("El promedio es:", promedio)
elif int(inputs[0]) == 6: #opcion 6
def cargar_peliculas_por_genero(file, sep=";"):
lst = lt.newList(
'SINGLE_LINKED',
comparar_genero) #Usando implementacion linkedlist
print("Cargando archivo ....")
dialect = csv.excel()
dialect.delimiter = sep
with open(file, encoding="utf-8") as csvfile:
spamreader = csv.DictReader(csvfile, dialect=dialect)
for row in spamreader:
generos = row['genres'].split("|")
for genero in generos:
elemento = {}
elemento["genero"] = genero
posicion1 = lt.isPresent(
lst, elemento["genero"])
if posicion1 == 0: # no esta
elemento["peliculas"] = lt.newList(
'SINGLE_LINKED', comparar_pelicula
) #lista con las peliculas por genero
elemento["sum_Votos"] = int(
row["vote_count"])
elemento["sum_average"] = float(
row["vote_average"])
lt.addLast(elemento["peliculas"],
row["original_title"])
lt.addLast(
lst, elemento
) # se adiciona a la lista de todos los elemnetos lst
else:
elemento_row = lt.getElement(
lst, posicion1)
#revisar si la peicula ya esta
posi_peli = lt.isPresent(
elemento_row['peliculas'],
row["original_title"])
if posi_peli == 0:
lt.addLast(elemento_row["peliculas"],
row["original_title"])
elemento_row["sum_Votos"] += int(
row["vote_count"])
elemento_row["sum_average"] += float(
row["vote_average"])
return lst
lista_Genero = cargar_peliculas_por_genero(
cf.data_dir + "themoviesdb/AllMoviesDetailsCleaned.csv")
columna = input("1. Por votos, 2. Por promedio\n")
orden = input("1. Las Mejores , 2. Las peores\n")
cantidad = input("Numero de peliculas a retornar\n")
ranking_peliculas_por_genero(lista_Genero, columna, orden,
cantidad)
elif int(inputs[0]) == 0: #opcion 0, salir
sys.exit(0)
def getBooksByTag(catalog, tag):
tags = catalog['tags']
pos = lt.isPresent(tags, tag, comparetagnames)
if pos:
elem = lt.getElement(tags, pos)
return elem