def conocerActor(listaCalif, listaDirector, nombre) -> tuple:
lista1 = lt.newList("ARRAY_LIST")
lista2 = lt.newList("ARRAY_LIST")
diccDirectores = {}
contador = 0
contador2 = 0
for i in range(0, lt.size(listaDirector)):
if (listaDirector["elements"][i]["actor1_name"].lower()
== nombre.lower()
) or (listaDirector["elements"][i]["actor2_name"].lower()
== nombre.lower()) or (
listaDirector["elements"][i]["actor3_name"].lower()
== nombre.lower()) or (
listaDirector["elements"][i]["actor4_name"].lower()
== nombre.lower()) or (listaDirector["elements"][i]
["actor5_name"].lower()
== nombre.lower()):
lt.addLast(lista1, i)
contador += float(listaCalif["elements"][i]["vote_average"])
contador2 += 1
titPeli = listaCalif["elements"][i]["title"]
titDirec = listaDirector["elements"][i]["director_name"]
lt.addLast(lista1, titPeli)
lt.addLast(lista2, titDirec)
tam = lt.size(lista2)
if contador2 == 0:
return lista1["elements"], 0, 0, "Ninguno"
for i in range(0, tam):
if lista2["elements"][i] not in list(diccDirectores.keys()):
diccDirectores[lista2["elements"][i]] = 1
else:
diccDirectores[lista2["elements"][i]] += 1
llaves = list(diccDirectores.keys())
valores = list(diccDirectores.values())
mayor = max(valores)
director = llaves[valores.index(mayor)]
prom = contador / contador2
return lista1["elements"], contador2, prom, director
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:
#print(row)
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"])
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 addActor (catalog, row):
"""
Adiciona un actor a la lista de actores
"""
name1=row["actor1_name"]
name2=row['actor2_name']
name3=row['actor3_name']
name4=row['actor4_name']
name5=row['actor5_name']
id_m=row['id']
director=row['director_name']
movie= None
average_vote= None
peliculas= catalog['peliculas_prom']
size = lt.size(peliculas)
iterator = it.newIterator(peliculas)
while it.hasNext(iterator) and movie==None:
pelicula = it.next(iterator)
if pelicula['id']==id_m:
movie=pelicula['title']
average_vote=pelicula['vote_average']
repetido1=0
repetido2=0
repetido3=0
repetido4=0
repetido5=0
size = lt.size(catalog['actores'])
if size:
iterator = it.newIterator(catalog['actores'])
while it.hasNext(iterator):
actor = it.next(iterator)
if name1 == actor["name"]:
repetido1=1
updateActor(actor, movie, average_vote, director)
elif name2 == actor["name"]:
repetido2=1
updateActor(actor, movie, average_vote, director)
elif name3 == actor["name"]:
repetido3=1
updateActor(actor, movie, average_vote, director)
elif name4 == actor["name"]:
repetido4=1
updateActor(actor, movie, average_vote, director)
elif name5 == actor["name"]:
repetido5=1
updateActor(actor, movie, average_vote, director)
if repetido1==0 and name1!=None:
director_mas=director
a1 = newActor (name1, movie, average_vote, director, director_mas)
lt.addLast (catalog['actores'], a1)
if repetido2==0 and name2!=None:
director_mas=director
a2 = newActor (name2, movie, average_vote, director, director_mas)
lt.addLast (catalog['actores'], a2)
if repetido3==0 and name3!=None:
director_mas=director
a3 = newActor (name3, movie, average_vote, director, director_mas)
lt.addLast (catalog['actores'], a3)
if repetido4==0 and name4!=None:
director_mas=director
a4 = newActor (name4, movie, average_vote, director, director_mas)
lt.addLast (catalog['actores'], a4)
if repetido5==0 and name5!=None:
director_mas=director
a5 = newActor (name5, movie, average_vote, director, director_mas)
lt.addLast (catalog['actores'], a5)
def crear_ranking_peliculas(decision1,decision2,movies,cantidad_count=10,cantidad_average=10):
tiempo1=process_time()
peliculas_count=lt.newList("ARRAY_LIST")
peliculas_average=lt.newList("ARRAY_LIST")
if(decision1.lower() == "mas votadas"):
for i in range(1,lt.size(movies)):
elemento=lt.getElement(movies,i)
datos={}
datos["titulo"]=elemento["title"]
datos["votos"]=int(elemento["vote_count"])
lt.addLast(peliculas_count,datos)
she.shellSort(peliculas_count,comparador_ascendente)
elif(decision1.lower() == "menos votadas"):
for i in range(1,lt.size(movies)+1):
elemento=lt.getElement(movies,i)
datos={}
datos["titulo"]=elemento["title"]
datos["votos"]=int(elemento["vote_count"])
lt.addLast(peliculas_count,datos)
she.shellSort(peliculas_count,comparador_descendente)
if(decision2.lower() == "mejor calificadas"):
for i in range(1,lt.size(movies)+1):
elemento=lt.getElement(movies,i)
datos2={}
datos2["titulo"]=elemento["title"]
datos2["promedio"]=float(elemento["vote_average"])
lt.addLast(peliculas_average,datos2)
she.shellSort(peliculas_average,comparador_ascendente_average)
elif(decision2.lower() == "peor calificadas"):
for i in range(1,lt.size(movies)+1):
elemento=lt.getElement(movies,i)
datos2={}
datos2["titulo"]=elemento["title"]
datos2["promedio"]=float(elemento["vote_average"])
lt.addLast(peliculas_average,datos2)
she.shellSort(peliculas_average,comparador_descendente_average)
total_count=lt.newList("ARRAY_LIST")
total_average=lt.newList("ARRAY_LIST")
x=0
x2=0
for i in range(1,lt.size(peliculas_count)):
elemento=lt.getElement(peliculas_count,i)
x+=1
lt.addLast(total_count,elemento)
if(x == cantidad_count):
break
for i in range(1,lt.size(peliculas_average)):
elemento=lt.getElement(peliculas_average,i)
x2+=1
lt.addLast(total_average,elemento)
if(x2 == cantidad_average):
break
tiempo2=process_time()
return (total_count,total_average,tiempo2-tiempo1)
def addMovie (catalog, row):
m = newMovie (row['title'], row['vote_average'], row['vote_count'], row['release_date'], row['id'])
lt.addLast (catalog['peliculas_prom'], m)
lt.addLast (catalog['votos_totales'], m)
def addCategoria(catalog, categoria):
"""
Adiciona un tag a la lista de tags
"""
t = newCategoria(categoria['name'])
lt.addLast(catalog['Categorias'], t)
def addDirector (catalog, director):
"""
Adiciona un director a la lista de directores
"""
d = newDirector (director['director_name'], director['id'])
lt.addLast (catalog['directors'], d)
# print(sys.getrecursionlimit())
sys.setrecursionlimit(10000)
lista = lt.newList('ARRAY_LIST', None)
def printList(lista):
iter = listiterator.newIterator(lista)
while listiterator.hasNext(iter):
c = listiterator.next(iter)
print(c["apellido"], ",", c["nombre"])
with open("Data/p3.csv", encoding="utf-8-sig") as csvfile:
reader = csv.DictReader(csvfile, delimiter=',')
for row in reader:
lt.addLast(lista, row)
t1_start = process_time()
#======================================
# Ordenar personas ascendentemente por (apellido, nombre)
#======================================
def less(e1, e2):
if e1["apellido"] < e2["apellido"]:
return True
elif e1["apellido"] == e2["apellido"] and e1["nombre"] < e2["nombre"]:
return True
else:
def rankingPorGenero (list1, generoBuscado:str):
#generate list by given genre
resultList2= lt.newList()
averageVotes=0
currentNumVotes=0
totalVotes=0
#este loop recorre el array importado del csv y crea un array nuevo con el contenido que cumple el criterio
for i in range (0, lt.size(list1)):
if (lt.getElement(list1, i)['genres'] in normalizeCase(generoBuscado)): #case insensitive
lt.addLast(resultList2, (lt.getElement(list1, i))) #se agrega a la lista resultado
print ("Las peliculas encontradas son:" )
for j in range (lt.size(resultList2)): #loop para imprimir todos los titulos encontrados con un indice
print((j, (lt.getElement(resultList2,j))['original_title']))
print ("se encontraron" , lt.size(resultList2) , "del genero especificado \n")
#ask for input selection
print ("Ingrese su selección de peliculas para el ranking\n puede ingresar numeros (1,2,3) o rangos(1-3)\n separados con una coma")
rankingSearchInput=str(input ("Ingrese las peliculas escogidas:\n"))
#turn selection String into number array
searchParameters= numberStringtoList(rankingSearchInput)
#create new array with given indexes
#no se utiliza el metodo lt.sublist pues este no incluye intervalos
rankingList= lt.newList()
for n in range (len(searchParameters)):
lt.addLast(rankingList, (lt.getElement(resultList2,n)))
#rankingList.append(resultList[searchParameters[n]])
for o in range(lt.size(rankingList)):
print(o+1, (lt.getElement(resultList2,o))['original_title'])
print('Se seleccionaron ', lt.size(rankingList), ' peliculas')
#ask for sorting criteria1
printMenuSortingcriteria()
criteriaInput=str(input ("Ingrese el criterio para el ranking:\n"))
#ask for sorting order
if int (criteriaInput)==1: #vote count
searchCriteria = 'vote_count'
elif int(criteriaInput)==2: #vote average
searchCriteria='vote_average'
#ask for sorting
printMenuSortingOrder()
orderInput=str(input ("seleccione el orden para el ranking\n"))
if int (orderInput)==1: #descendente
#orderedRankingList= rankingList
orderedRankingList= lt.newList()
orderedRankingList=insertion.insertionSortVoteCount (rankingList)
for n in range(lt.size(orderedRankingList)):
print((n+1, orderedRankingList[n]['original_title'], orderedRankingList[n]['vote_count']))
elif int(orderInput)==2: #vote average
searchCriteria='vote_average'#ascendente
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 know_actor(actor, listadetails, listacasting):
t1_start = process_time() #tiempo inicia
try:
listapeliculas = lt.newList("ARRAY_LIST")
listaid = lt.newList("ARRAY_LIST")
totalpeliculas = 0
calificacion = 0
listadirectores = []
for i in range(1, int(lt.size(listacasting)) + 1):
a = (lt.getElement(listacasting, i))["id"]
if (lt.getElement(listacasting, i))["actor1_name"] == actor:
lt.addLast(listaid, a)
listadirectores.append((lt.getElement(listacasting,
i))["director_name"])
elif (lt.getElement(listacasting, i))["actor2_name"] == actor:
lt.addLast(listaid, a)
listadirectores.append((lt.getElement(listacasting,
i))["director_name"])
elif (lt.getElement(listacasting, i))["actor3_name"] == actor:
lt.addLast(listaid, a)
listadirectores.append((lt.getElement(listacasting,
i))["director_name"])
elif (lt.getElement(listacasting, i))["actor4_name"] == actor:
lt.addLast(listaid, a)
listadirectores.append((lt.getElement(listacasting,
i))["director_name"])
elif (lt.getElement(listacasting, i))["actor5_name"] == actor:
lt.addLast(listaid, a)
listadirectores.append((lt.getElement(listacasting,
i))["director_name"])
for i in range(1, (lt.size(listaid)) + 1):
for j in range(1, int(lt.size(listadetails)) + 1):
if str(lt.getElement(listaid, i)) == str(
(lt.getElement(listadetails, j))["id"]):
lt.addLast(listapeliculas, (lt.getElement(listadetails,
j))["title"])
totalpeliculas += 1
calificacion += float((lt.getElement(listadetails,
j))["vote_average"])
promedio = calificacion / totalpeliculas
director = mode(listadirectores)
print("Peliculas del actor: ")
for i in range(1, (lt.size(listapeliculas)) + 1):
print(lt.getElement(listapeliculas, i))
print(
"-------------------------------------------------------------------"
)
print("Numero de peliculas del actor: " + str(totalpeliculas))
print(
"-------------------------------------------------------------------"
)
print("Promedio de calificacion de peliculas: " +
str(round(promedio, 2)))
print(
"-------------------------------------------------------------------"
)
print("Director con mas peliculas: " + str(director))
except:
print("Error, nombre incorrecto. Intente de nuevo.")
t1_stop = process_time() #tiempo final
print(
"-------------------------------------------------------------------")
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
def get_director_movie_ids(search, result, director):
iterator = it.newIterator(search)
while it.hasNext(iterator):
element = it.next(iterator)
if director.lower() in element['director_name'].lower(): # filtrar por nombre
lt.addLast(result, element['id'])
def newGenre(g,row):
newgenre = {'genre':"", 'genreMovies':None}
newgenre['genre']=g
newgenre['genreMovies']=lt.newList()
lt.addLast(newgenre['genreMovies'],row['id'])
return newgenre
def addAccidentList (catalog,row):
accidents = catalog['AccidentsList']
accident = newAccident(row)
lt.addLast(accidents,accident)
def info_actor(lst, lst_b, n_actor):
lista = lt.newList(ar)
lista_directores = []
#Encontar id y directores correspondientes al actor
for i in range(1, (lt.size(lst)) - 1):
if (lt.getElement(lst, i))["actor1_name"] == n_actor:
pelicula = lt.getElement(lst, i)["id"]
director = lt.getElement(lst, i)["director_name"]
lt.addLast(lista, pelicula)
#lista.append(pelicula)
lista_directores.append(director)
elif (lt.getElement(lst, i))["actor2_name"] == n_actor:
pelicula = lt.getElement(lst, i)["id"]
director = lt.getElement(lst, i)["director_name"]
lt.addLast(lista, pelicula)
#lista.append(pelicula)
lista_directores.append(director)
elif (lt.getElement(lst, i))["actor3_name"] == n_actor:
pelicula = lt.getElement(lst, i)["id"]
director = lt.getElement(lst, i)["director_name"]
lt.addLast(lista, pelicula)
# lista.append(pelicula)
lista_directores.append(director)
elif (lt.getElement(lst, i))["actor4_name"] == n_actor:
pelicula = lt.getElement(lst, i)["id"]
director = lt.getElement(lst, i)["director_name"]
lt.addLast(lista, pelicula)
#lista.append(pelicula)
lista_directores.append(director)
elif (lt.getElement(lst, i))["actor5_name"] == n_actor:
pelicula = lt.getElement(lst, i)["id"]
director = lt.getElement(lst, i)["director_name"]
lt.addLast(lista, pelicula)
#lista.append(pelicula)
lista_directores.append(director)
else:
None
#Si no halló al actor, detiene la función
if lt.size(lista) == 0:
print("No se ha encontrado el actor requerido")
return -1
#hallo promedio de votación
else:
peliculas_del_actor = lt.newList('ARRAY_LIST')
promedio = 0.0
contador = 0
contador_d = 0
for i in range(1, (lt.size(lista)) + 1):
for g in range(1, (lt.size(lst_b)) - 1):
if lt.getElement(lst_b, g)["id"] == lt.getElement(lista, i):
lt.addLast(peliculas_del_actor,
(lt.getElement(lst_b, g)["title"]))
promedio += float(lt.getElement(lst_b, g)["vote_average"])
contador += 1
else:
None
promedio = round((promedio / contador), 2)
#Hallo el director más recurrente
lista_mayor = []
for i in lista_directores:
variable = 0
lista_mayor.append(lista_directores.count(i))
director_resultado = max(lista_mayor)
director_más_recurrente = ""
#Imprimo los resultados
print("\n")
print(n_actor + " ha trabajado en: " + str(contador) +
" peliculas. \n")
print("Las peliculas en las que ha participado " + n_actor + " son: ")
print(peliculas_del_actor["elements"])
print("\n")
print(
"El promedio de la calificación de las películas en las que ha participado "
+ n_actor + " es: " + str(promedio) + "\n")
if director_resultado == 1:
director_más_recurrente = "Este actor ha trabajado solo 1 vez con cada director"
else:
for i in lista_directores:
if lista_directores.count(i) == director_resultado:
director_más_recurrente = (
"El director más recurrente con este actor es: " + i)
print(director_más_recurrente)
def addTag(catalog, tag):
"""
Adiciona un tag a la lista de tags
"""
t = newTagBook(tag['tag_name'], tag['tag_id'])
lt.addLast(catalog['tags'], t)
def AllmoviesDirector(catalog, dirname, director):
for i in director["directorMovies"]['elements']:
movie = getMovieInMapId(catalog, i)
director["sum_average_rating"] += movie["vote_average"]
lt.addLast(director["movies"], movie)
return director
def addBookTag(catalog, booktag):
"""
Adiciona un tag a la lista de tags
"""
t = newBookTag(booktag['tag_id'], booktag['goodreads_book_id'])
lt.addLast(catalog['book_tags'], t)
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 rankingGenero(listaDetalles, genero, numPel, decision) -> tuple:
listaCalif = lt.newList("ARRAY_LIST")
contador = 0
contador2 = 0
for i in range(0, lt.size(listaDetalles)):
if (genero.lower() in listaDetalles["elements"][i]["genres"].lower()):
ind = listaDetalles["elements"][i]
lt.addLast(listaCalif, ind)
if decision == 1:
listaMasVotos = lt.newList("ARRAY_LIST")
SSort.shellSort(listaCalif, greaterCount)
for i in range(0, numPel + 1):
elem = listaCalif["elements"][i]
lt.addLast(listaMasVotos, elem["title"])
contador += float(elem["vote_count"])
contador2 += 1
if contador2 == 0:
return "No hay títulos.", 0
prom = contador / contador2
return listaMasVotos["elements"], prom
elif decision == 2:
listaMenosVotos = lt.newList("ARRAY_LIST")
SSort.shellSort(listaCalif, lessCount)
for i in range(0, numPel + 1):
elem = listaCalif["elements"][i]
lt.addLast(listaMenosVotos, elem["title"])
contador += float(elem["vote_count"])
contador2 += 1
if contador2 == 0:
return "No hay títulos.", 0
prom = contador / contador2
return listaMenosVotos["elements"], prom
elif decision == 3:
listaMejorAverage = lt.newList("ARRAY_LIST")
SSort.shellSort(listaCalif, greaterVote)
for i in range(0, numPel + 1):
elem = listaCalif["elements"][i]
lt.addLast(listaMejorAverage, elem["title"])
contador += float(elem["vote_average"])
contador2 += 1
if contador2 == 0:
return "No hay títulos.", 0
prom = contador / contador2
return listaMejorAverage["elements"], prom
elif decision == 4:
listaPeorAverage = lt.newList("ARRAY_LIST")
SSort.shellSort(listaCalif, lessVote)
for i in range(0, numPel + 1):
elem = listaCalif["elements"][i]
lt.addLast(listaPeorAverage, elem["title"])
contador += float(elem["vote_average"])
contador2 += 1
if contador2 == 0:
return "No hay títulos.", 0
prom = contador / contador2
return listaPeorAverage["elements"], prom
def lstpeliculas(peliculas):
lst = slt.newList()
for each in peliculas:
slt.addLast(lst, each)
return lst
def lstmovies(movies):
slt = lst.newList(list_type, cmpfunction)
for i in range(0, 5):
lst.addLast(slt, movies[i])
return slt
def updateDirector(director, average, movieTitle):
director['sum_average_rating'] += average
lt.addLast(director['directorMovies'], movieTitle)
def lstbooks(books):
#lst = lt.newList('ARRAY_LIST', cmpfunction)
lst = lt.newList('SINGLE_LINKED', cmpfunction)
for i in range(0, 5):
lt.addLast(lst, books[i])
return lst
sys.setrecursionlimit(10000)
lista = lt.newList('ARRAY_LIST', None)
def printList(lista):
iter = listiterator.newIterator(lista)
while listiterator.hasNext(iter):
c = listiterator.next(iter)
print(c)
with open("Data/p1.csv", encoding="utf-8-sig") as csvfile:
reader = csv.DictReader(csvfile, delimiter=';')
for row in reader:
lt.addLast(lista, row["num"])
#======================================
# Ordenar numeros descendetemente
#======================================
def less(e1, e2):
return e1 < e2
#=======================================
l = lt.subList(lista, 1, lt.size(lista))
t1_start = process_time()
insertionsort.insertionSort(l, less)
def addvideo(catalog, video):
lt.addLast(catalog["videos"], video)
def loadCSVFile(self, file, lst):
input_file = csv.DictReader(open(file))
for row in input_file:
lt.addLast(lst, row)
def addcategory(catalog, categoria):
lt.addLast(catalog["categorias"], categoria)
def loadCSVFile(file, lst):
input_file = csv.DictReader(open(file, encoding = "utf-8"))
for row in input_file:
lt.addLast(lst, row)
def crear_ranking_gen(movies,orden,tipo,genero,numero_de_peliculas=10):
if(tipo.lower() == "ascendente"):
if(orden.lower() == "votos" ):
peliculas_genero=lt.newList("ARRAY_LIST")
eleccion_usuario=lt.newList("ARRAY_LIST")
for i in range(1,lt.size(movies)):
elemento=lt.getElement(movies,i)
if(genero.lower() in elemento["genres"].lower()):
pelis={}
pelis["titulo"]=elemento["title"]
pelis["votos"]=float(elemento["vote_count"])
pelis["promedio"]=float(elemento["vote_average"])
lt.addLast(peliculas_genero,pelis)
she.shellSort(peliculas_genero,comparador_ascendente)
for i in range(1,lt.size(peliculas_genero)):
lt.addLast(eleccion_usuario,lt.getElement(peliculas_genero,i))
if(lt.size(eleccion_usuario) == numero_de_peliculas):
break
return eleccion_usuario
elif(orden.lower() == "promedio" ):
peliculas_genero=lt.newList("ARRAY_LIST")
eleccion_usuario=lt.newList("ARRAY_LIST")
for i in range(1,lt.size(movies)):
elemento=lt.getElement(movies,i)
if(genero.lower() in elemento["genres"].lower()):
pelis={}
pelis["titulo"]=elemento["title"]
pelis["votos"]=float(elemento["vote_count"])
pelis["promedio"]=float(elemento["vote_average"])
lt.addLast(peliculas_genero,pelis)
she.shellSort(peliculas_genero,comparador_ascendente_average)
for i in range(1,lt.size(peliculas_genero)):
lt.addLast(eleccion_usuario,lt.getElement(peliculas_genero,i))
if(lt.size(eleccion_usuario) == numero_de_peliculas):
break
return eleccion_usuario
elif(tipo.lower() == "descendente"):
if(orden.lower() == "votos" ):
peliculas_genero=lt.newList("ARRAY_LIST")
eleccion_usuario=lt.newList("ARRAY_LIST")
for i in range(1,lt.size(movies)):
elemento=lt.getElement(movies,i)
if(genero.lower() in elemento["genres"].lower()):
pelis={}
pelis["titulo"]=elemento["title"]
pelis["votos"]=float(elemento["vote_count"])
pelis["promedio"]=float(elemento["vote_average"])
lt.addLast(peliculas_genero,pelis)
she.shellSort(peliculas_genero,comparador_descendente)
for i in range(1,lt.size(peliculas_genero)):
lt.addLast(eleccion_usuario,lt.getElement(peliculas_genero,i))
if(lt.size(eleccion_usuario) == numero_de_peliculas):
break
she.shellSort(eleccion_usuario,comparador_descendente_average)
return eleccion_usuario
elif(orden.lower() == "promedio" ):
peliculas_genero=lt.newList("ARRAY_LIST")
eleccion_usuario=lt.newList("ARRAY_LIST")
for i in range(1,lt.size(movies)):
elemento=lt.getElement(movies,i)
if(genero.lower() in elemento["genres"].lower()):
pelis={}
pelis["titulo"]=elemento["title"]
pelis["votos"]=float(elemento["vote_count"])
pelis["promedio"]=float(elemento["vote_average"])
lt.addLast(peliculas_genero,pelis)
she.shellSort(peliculas_genero,comparador_descendente_average)
for i in range(1,lt.size(peliculas_genero)):
lt.addLast(eleccion_usuario,lt.getElement(peliculas_genero,i))
if(lt.size(eleccion_usuario) == numero_de_peliculas):
break
she.shellSort(eleccion_usuario,comparador_descendente)
return eleccion_usuario
