def test_empty(slt):
assert lst.isEmpty(slt) == True
assert lst.size(slt) == 0
def main():
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
print("Recursion Limit:", sys.getrecursionlimit())
catalog = initCatalog()
loadData(catalog)
print('Tamaño Lista accidentes cargados: ' +
str(lt.size(catalog['AccidentList'])))
print('Tamaño árbol Accidentes por ID: ' +
str(tree.size(catalog['AccidentIDTree'])))
print('Tamaño árbol accidentes por fecha : ' +
str(tree.size(catalog['yearsTree'])))
print('Altura árbol por ID: ' +
str(tree.height(catalog['AccidentIDTree'])))
print('Altura árbol por fecha: ' +
str(tree.height(catalog['yearsTree'])))
elif int(inputs[0]) == 2:
title = input("Nombre del titulo a buscar: ")
book = controller.getBookTree(catalog, title)
if book:
print("Libro encontrado:", book['title'],
book['average_rating'])
else:
print("Libro No encontrado")
elif int(inputs[0]) == 3:
date = input("Ingrese la fecha en formato anio-mes-dia: ")
rank = controller.rankBookTree(catalog, date)
print("Hay ", rank, " accidentes antes de " + date)
elif int(inputs[0]) == 4:
fecha = input('ingrese la fehca de la forma %YYYY-%mm-%dd: ')
estado = controller.getEstate(catalog, fecha)
if estado:
print('el estado con mayor cantidad de accidentes en la fecha',
fecha, 'es ', str(estado['Estado']), 'con ',
str(estado['Accidentes']), 'accidentes.')
else:
print("no se encontro estado ")
elif int(inputs[0]) == 5:
year = input(
"Ingrese la fecha a consultar de la forma %YYYY-%mm-%dd::")
response = controller.getBookByYearRating(catalog, year)
if response:
print(response)
else:
print("No se encontraron Accidentes para la fecha", year)
elif int(inputs[0]) == 6:
years = input(
"Ingrese los años desde y hasta (%YYYY-%mm-%dd %Y-%m-%dd):")
counter = controller.getBooksCountByYearRange(catalog, years)
if counter:
print("Cantidad de accidentes entre las fechas", years, ":")
lista = map.valueSet(counter)
for i in range(1, lt.size(lista)):
print(lt.getElement(lista, i))
else:
print("No se encontraron accidentes para el rango de fechas",
years)
else:
sys.exit(0)
sys.exit(0)
def main():
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
print("Recursion Limit:", sys.getrecursionlimit())
catalog = initCatalog()
loadData(catalog)
print('Tamaño Lista libros cargados: ' +
str(lt.size(catalog['booksList'])))
print('Tamaño árbol Libros por titulo: ' +
str(map.size(catalog['booksTitleTree'])))
print('Tamaño árbol Libros por año : ' +
str(map.size(catalog['yearsTree'])))
print('Altura árbol por titulo: ' +
str(map.height(catalog['booksTitleTree'])))
print('Altura árbol por año: ' +
str(map.height(catalog['yearsTree'])))
elif int(inputs[0]) == 2:
title = input("Nombre del titulo a buscar: ")
book = controller.getBookTree(catalog, title)
if book:
print("Libro encontrado:", book['title'],
book['average_rating'])
else:
print("Libro No encontrado")
elif int(inputs[0]) == 3:
title = input("Nombre del titulo a buscar (rank): ")
rank = controller.rankBookTree(catalog, title)
print("Hay ", rank, " titulos menores (rank) que " + title)
elif int(inputs[0]) == 4:
pos = int(
input(
"Posición del k-esimo titulo del libro (select) a obtener: "
))
book = controller.selectBookTree(catalog, pos)
if book:
print("Libro en posición:", pos, ":", book['value']['title'],
book['value']['average_rating'])
else:
print("Libro no encotrado en posicion: ", pos)
elif int(inputs[0]) == 5:
year = input("Ingrese el año a consultar:")
response = controller.getBookByYearRating(catalog, year)
if response:
print(response)
else:
print("No se encontraron libro para el año", year)
elif int(inputs[0]) == 6:
year = input("Ingrese la fecha a consultar: ")
Severity = input('ingrese la severidad: ')
response = controller.getBookByYearRating(catalog, year,
int(Severity))
if response:
print('En la fecha ' + str(year) + ' se presentaron ' +
str(response) + ' accidentes de severidad ' +
str(Severity))
else:
print("No se encontraron accidentes para la fecha", year)
else:
sys.exit(0)
sys.exit(0)
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
else:
print ('No se encontraron peliculas')
"""
Menu principal
"""
while True:
printMenu()
inputs =input('Seleccione una opción para continuar\n')
if int(inputs[0])==1:
print("Cargando información de los archivos ....")
catalog = initCatalog ()
loadData (catalog)
print ('Peliculas cargadas: ' + str(lt.size(catalog['movies'])))
print ('Directores cargados: ' + str(lt.size(catalog['directors'])))
elif int(inputs[0])==2:
number = input ("Buscando las TOP ?: ")
movies = controller.getBestMovies (catalog, int(number))
printBestMovies (movies)
elif int(inputs[0])==3:
dir_name = input("Nombre del director a buscar: ")
movies = controller.getMoviesByDirector (catalog, dir_name)
print(movies)
elif int(inputs[0])==4:
def create_ranking(listadetails, parametro_average_best,
parametro_average_worst, parametro_count_best,
parametro_count_worst):
t1_start = process_time() #tiempo inicial
try:
averagebest, averageworst, countbest, countworst = order_list(
listadetails, parametro_average_best, parametro_average_worst,
parametro_count_best, parametro_count_worst)
if parametro_average_best > 0:
print(
"-------------------------------------------------------------------"
)
print("MEJOR VALORADAS")
#print(averagebest)
lista = []
x = lt.size(averagebest)
print(x)
for i in range(1, x + 1):
y = lt.getElement(averagebest, i)
lista.append(y["original_title"])
print(lista)
if parametro_average_worst > 0:
print(
"-------------------------------------------------------------------"
)
print("PEOR VALORADAS")
lista = []
x = lt.size(averageworst)
print(x)
for i in range(1, x + 1):
y = lt.getElement(averageworst, i)
lista.append(y["original_title"])
print(lista)
if parametro_count_best > 0:
print(
"-------------------------------------------------------------------"
)
print("MEJOR VOTADAS")
lista = []
#print(countbest)
x = lt.size(countbest)
print(x)
for i in range(1, x + 1):
y = lt.getElement(countbest, i)
lista.append(y["original_title"])
print(lista)
if parametro_count_worst > 0:
print(
"-------------------------------------------------------------------"
)
print("PEOR VOTADAS")
lista = []
x = lt.size(countworst)
print(x)
for i in range(1, x + 1):
y = lt.getElement(countworst, i)
lista.append(y["original_title"])
print(lista)
except:
print(
"Hubo un error al ingresar parametros, por favor vuelva a intentarlo."
)
t1_stop = process_time() #tiempo final
print(
"-------------------------------------------------------------------")
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
def create_ranking_gender(listadetails, name_gender, parametro_average_best,
parametro_average_worst, parametro_count_best,
parametro_count_worst):
t1_start = process_time() #tiempo inicial
try:
lista_genero = filtrar_por_genero(listadetails, name_gender)
averagebest, averageworst, countbest, countworst = order_list(
lista_genero, parametro_average_best, parametro_average_worst,
parametro_count_best, parametro_count_worst)
x = lt.size(lista_genero)
sumatoria = 0
for i in range(1, x + 1):
y = lt.getElement(lista_genero, i)
sumatoria += float(y["vote_count"])
promedio = sumatoria / x
promedio = round(promedio, 2)
promedio_final = "El promedio de votos de de " + name_gender + " es : " + str(
promedio) + " votos"
print(promedio_final)
sumatoria_average = 0
for i in range(1, x + 1):
y = lt.getElement(lista_genero, i)
sumatoria_average += float(y["vote_average"])
promedio_average = sumatoria_average / x
promedio = round(promedio_average, 2)
promedio_average_final = "El promedio de calificaciones de las películas de " + name_gender + " es : " + str(
promedio) + "."
if parametro_average_best > 0:
print(
"-------------------------------------------------------------------"
)
print("MEJOR VALORADAS: " + name_gender)
#print(averagebest)
lista = []
x = lt.size(averagebest)
print(x)
for i in range(1, x + 1):
y = lt.getElement(averagebest, i)
lista.append(y["original_title"])
print(lista)
if parametro_average_worst > 0:
print(
"-------------------------------------------------------------------"
)
print("PEOR VALORADAS: " + name_gender)
lista = []
x = lt.size(averageworst)
print(x)
for i in range(1, x + 1):
y = lt.getElement(averageworst, i)
lista.append(y["original_title"])
print(lista)
if parametro_count_best > 0:
print(
"-------------------------------------------------------------------"
)
print("MEJOR VOTADAS: " + name_gender)
lista = []
#print(countbest)
x = lt.size(countbest)
print(x)
for i in range(1, x + 1):
y = lt.getElement(countbest, i)
lista.append(y["original_title"])
print(lista)
if parametro_count_worst > 0:
print(
"-------------------------------------------------------------------"
)
print("PEOR VOTADAS: " + name_gender)
lista = []
x = lt.size(countworst)
print(x)
for i in range(1, x + 1):
y = lt.getElement(countworst, i)
lista.append(y["original_title"])
print(lista)
print(
"-------------------------------------------------------------------"
)
print(promedio_average_final)
print(
"-------------------------------------------------------------------"
)
print(promedio_final)
except:
print("Género inválido, intente de nuevo.")
t1_stop = process_time() #tiempo final
print(
"-------------------------------------------------------------------")
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
def test_empty(lst):
assert lt.isEmpty(lst) == True
assert lt.size(lst) == 0
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Inicializando Catálogo ....")
catalog = initCatalog()
elif int(inputs[0]) == 2:
print("Cargando información de los archivos ....")
loadData(catalog)
print('Libros cargados: ' + str(lt.size(catalog['books'])))
print('Autores cargados: ' + str(lt.size(catalog['authors'])))
print('Géneros cargados: ' + str(lt.size(catalog['tags'])))
elif int(inputs[0]) == 3:
number = input("Buscando los TOP ?: ")
books = controller.getBestBooks(catalog, int(number))
printBestBooks(books)
elif int(inputs[0]) == 4:
authorname = input("Nombre del autor a buscar: ")
author = controller.getBooksByAuthor(catalog, authorname)
printAuthorData(author)
elif int(inputs[0]) == 5:
label = input("Etiqueta a buscar: ")
def test_removeFirst(lstbooks, books):
assert lt.size(lstbooks) == 5
lt.removeFirst(lstbooks)
assert lt.size(lstbooks) == 4
book = lt.getElement(lstbooks, 1)
assert book == books[1]
def test_removeLast(lstbooks, books):
assert lt.size(lstbooks) == 5
lt.removeLast(lstbooks)
assert lt.size(lstbooks) == 4
book = lt.getElement(lstbooks, 4)
assert book == books[3]
def Requerimiento6(numero, parametro, genero, orden, lista):
lista_retorno = lt.newList(datastructure="SINGLE_LINKED")
contador1 = 0
peliculas = []
while contador1 < numero:
mayor = 0
menor = 99999999999
titulo = ""
if parametro == "promedio" and orden == "mayor":
for i in range(1, lt.size(lista)):
actual = lt.getElement(lista, i)
if float(actual["vote_average"]) > mayor and actual[
"title"] not in peliculas and genero in actual[
"genres"]:
mayor = float(actual["vote_average"])
titulo = actual["title"]
lt.addFirst(lista_retorno, [{
"Película": titulo
}, {
"Promedio": mayor
}])
peliculas.append(titulo)
contador1 += 1
if parametro == "contar" and orden == "mayor":
for i in range(1, lt.size(lista)):
actual = lt.getElement(lista, i)
if float(actual["vote_count"]) > mayor and actual[
"title"] not in peliculas and genero in actual[
"genres"]:
mayor = float(actual["vote_count"])
titulo = actual["title"]
lt.addFirst(lista_retorno, [{
"Película": titulo
}, {
"Votos": mayor
}])
peliculas.append(titulo)
contador1 += 1
if parametro == "promedio" and orden == "menor":
for i in range(1, lt.size(lista)):
actual = lt.getElement(lista, i)
if float(actual["vote_average"]) < menor and actual[
"title"] not in peliculas and genero in actual[
"genres"]:
menor = float(actual["vote_average"])
titulo = actual["title"]
lt.addFirst(lista_retorno, [{
"Película": titulo
}, {
"Promedio": menor
}])
peliculas.append(titulo)
contador1 += 1
if parametro == "contar" and orden == "menor":
for i in range(1, lt.size(lista)):
actual = lt.getElement(lista, i)
if float(actual["vote_count"]) < menor and actual[
"title"] not in peliculas and genero in actual[
"genres"]:
menor = float(actual["vote_count"])
titulo = actual["title"]
lt.addFirst(lista_retorno, [{
"Película": titulo
}, {
"Votos": menor
}])
peliculas.append(titulo)
contador1 += 1
if parametro == "promedio" and orden == "mayor":
lt.shell(lista_retorno, comparacion_promedio_mayor)
if parametro == "promedio" and orden == "menor":
lt.shell(lista_retorno, comparacion_promedio_menor)
if parametro == "contar" and orden == "mayor":
lt.shell(lista_retorno, comparacion_contar_mayor)
if parametro == "contar" and orden == "menor":
lt.shell(lista_retorno, comparacion_contar_menor)
return print(lista_retorno)
def test_removeLast(lstmovies, movies):
assert lst.size(lstmovies) == 5
lst.removeLast(lstmovies)
assert lst.size(lstmovies) == 4
movie = lst.getElement(lstmovies, 4)
assert movie == movies[3]
def test_removeFirst(lstmovies, movies):
assert lst.size(lstmovies) == 5
lst.removeFirst(lstmovies)
assert lst.size(lstmovies) == 4
movie = lst.getElement(lstmovies, 1)
assert movie == movies[1]
def loadMoviesDetails():
listadetails = loadCSVFile("Data/themoviesdb/AllMoviesDetailsCleaned.csv"
) #llamar funcion cargar datos
print("Datos cargados details, ", lt.size(listadetails),
" elementos cargados")
return listadetails
def loadMovies(dire):
lst = loadCSVFile(dire,compareRecordIds)
print("Datos cargados, " + str(lt.size(lst)) + " elementos cargados")
return lst
def loadMoviesCasting():
listacasting = loadCSVFile("Data/themoviesdb/AllMoviesCastingRaw.csv")
print("Datos cargados casting, ", lt.size(listacasting),
" elementos cargados")
return listacasting
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
"""
#"themoviesdb/MoviesCastingRaw-small.csv"
#"themoviesdb/SmallMoviesDetailsCleaned.csv"
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
datos_casting=loadMovies("themoviesdb/AllMoviesCastingRaw.csv")
datos_movies=loadMovies("themoviesdb/AllMoviesDetailsCleaned.csv")
elif int(inputs[0])==2: #opcion 2
decision1=int(input("Sí desea que sus peliculas se ordenen como más votadas digite :1, si por el contrario desea que sea como menos votadas digite 0.\n"))
decision2=int(input("Sí desea que sus peliculas se ordenen como mejor calificadas con respecto al promedio :1, si por el contrario desea que sean las peor calificadas digite 0.\n"))
cantidad=input("¿Desea una cantidad por defecto para ambas listas? si/no\n")
if(cantidad.lower() == "no"):
cantidad1=int(input("Digite el tamaño de su ranking peliculas mas votadas/menos votadas:\n"))
cantidad2=int(input("Digite el tamaño de su ranking peliculas mejor/peor promedio:\n"))
if(decision1 == 1 and decision2 == 1):
elementos=fun.crear_ranking_peliculas("mas votadas","mejor calificadas",datos_movies,cantidad1,cantidad2)
print("_________________________________________")
print("Top",cantidad1,"Peliculas mejor votadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[0])+1):
print(x,lt.getElement(elementos[0],i)["titulo"])
x+=1
print("_________________________________________")
print("_________________________________________")
print("Top",cantidad2,"Peliculas mejor calificadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[1])+1):
print(x,lt.getElement(elementos[1],i)["titulo"])
x+=1
print("_________________________________________")
elif(decision1 == 0 and decision2 == 0):
elementos=fun.crear_ranking_peliculas("menos votadas","peor calificadas",datos_movies,cantidad1,cantidad2)
print("_________________________________________")
print("Top",cantidad1,"Peliculas menos votadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[0])+1):
print(x,lt.getElement(elementos[0],i)["titulo"])
x+=1
print("_________________________________________")
print("_________________________________________")
print("Top",cantidad2,"Peliculas peor calificadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[1])+1):
print(x,lt.getElement(elementos[1],i)["titulo"])
x+=1
print("_________________________________________")
elif(decision1 == 1 and decision2 == 0):
elementos=fun.crear_ranking_peliculas("mas votadas","mejor calificadas",datos_movies,cantidad1,cantidad2)
print("_________________________________________")
print("Top",cantidad1,"Peliculas mejor votadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[0])+1):
print(x,lt.getElement(elementos[0],i)["titulo"])
x+=1
print("_________________________________________")
print("_________________________________________")
print("Top",cantidad2,"Peliculas peor calificadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[1])+1):
print(x,lt.getElement(elementos[1],i)["titulo"])
x+=1
print("_________________________________________")
elif(decision1 == 0 and decision2 == 1):
elementos=fun.crear_ranking_peliculas("mas votadas","mejor calificadas",datos_movies,cantidad1,cantidad2)
print("_________________________________________")
print("Top",cantidad1,"Peliculas menos votadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[0])+1):
print(x,lt.getElement(elementos[0],i)["titulo"])
x+=1
print("_________________________________________")
print("_________________________________________")
print("Top",cantidad2,"Peliculas mejor calificadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[1])+1):
print(x,lt.getElement(elementos[1],i)["titulo"])
x+=1
print("_________________________________________")
elif(cantidad.lower() == "si"):
if(decision1 == 1 and decision2 == 1):
elementos=fun.crear_ranking_peliculas("mas votadas","mejor calificadas",datos_movies)
print("_________________________________________")
print("Top","10","Peliculas mejor votadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[0])+1):
print(x,lt.getElement(elementos[0],i)["titulo"])
x+=1
print("_________________________________________")
print("_________________________________________")
print("Top","10","Peliculas mejor calificadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[1])+1):
print(x,lt.getElement(elementos[1],i)["titulo"])
x+=1
print("_________________________________________")
elif(decision1 == 0 and decision2 == 0):
elementos=fun.crear_ranking_peliculas("menos votadas","peor calificadas",datos_movies)
print("_________________________________________")
print("Top","10","Peliculas menos votadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[0])+1):
print(x,lt.getElement(elementos[0],i)["titulo"])
x+=1
print("_________________________________________")
print("_________________________________________")
print("Top","10","Peliculas peor calificadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[1])+1):
print(x,lt.getElement(elementos[1],i)["titulo"])
x+=1
print("_________________________________________")
elif(decision1 == 1 and decision2 == 0):
elementos=fun.crear_ranking_peliculas("mas votadas","mejor calificadas",datos_movies)
print("_________________________________________")
print("Top","10","Peliculas mejor votadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[0])+1):
print(x,lt.getElement(elementos[0],i)["titulo"])
x+=1
print("_________________________________________")
print("_________________________________________")
print("Top","10","Peliculas peor calificadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[1])+1):
print(x,lt.getElement(elementos[1],i)["titulo"])
x+=1
print("_________________________________________")
elif(decision1 == 0 and decision2 == 1):
elementos=fun.crear_ranking_peliculas("mas votadas","mejor calificadas",datos_movies)
print("_________________________________________")
print("Top","10","Peliculas menos votadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[0])+1):
print(x,lt.getElement(elementos[0],i)["titulo"])
x+=1
print("_________________________________________")
print("_________________________________________")
print("Top","10","Peliculas mejor calificadas.")
print("_________________________________________")
x=1
for i in range(1,lt.size(elementos[1])+1):
print(x,lt.getElement(elementos[1],i)["titulo"])
x+=1
print("_________________________________________")
elif int(inputs[0])==3: #opcion 3
director=input("Digite el director que desea buscar:\n")
conocer_director=fun.conocer_a_director(director,datos_casting,datos_movies)
print("_________________________________________")
print("Número de películas:",conocer_director[2]," ","Promedio de calificación:",conocer_director[1])
print("_________________________________________")
x=1
for i in conocer_director[0]:
print(x,i)
x+=1
print("_________________________________________")
elif int(inputs[0])==4: #opcion 4
actor=input("¿qué actor desea consultar?:\n")
peliculasxx=fun.conocer_a_actor(datos_movies,datos_casting,actor)
print("_________________________________________")
print("Actor:",actor,"Número de películas:",peliculasxx[1],"Promedio de calificación:",peliculasxx[2],"Director con más colaboraciones:",peliculasxx[3])
print("_________________________________________")
x=1
for i in range(1,lt.size(peliculasxx[0])+1):
print(x,lt.getElement(peliculasxx[0],i))
x+=1
print("_________________________________________")
print("Actor:",actor,"Número de películas:",peliculasxx[1],"Promedio de calificación:",peliculasxx[2],"Director con más colaboraciones:",peliculasxx[3])
print("_________________________________________")
elif int(inputs[0])==5: #opcion 5
genero=input("Elija el género que desea buscar:\n")
peliculasx=fun.entender_un_genero(genero,datos_movies)
print("_________________________________________")
print("Genero:",genero,"con una votación promedio de:",peliculasx[2],"y un número de peliculas de :",lt.size(peliculasx[0]))
print("_________________________________________")
x=1
for i in range(1,lt.size(peliculasx[0])+1):
print(x,lt.getElement(peliculasx[0],i))
x+=1
print("Genero:",genero,"con una votación promedio de:",peliculasx[2],"y un número de peliculas de :",lt.size(peliculasx[0]))
print("_________________________________________")
elif int(inputs[0])==6: #opcion 6
genero=input("¿Cuál género desea buscar?:\n")
ascendente_descendente=input("Sí desea una lista de las mejores peliculas digite:ascendente,si desea una lista de las peores peliculas digite: descendente. \n")
criterio=input("Elija con que criterio desea realizar su búsqueda, por número de votos digite: votos, para que sea con respecto al promedio digite: promedio. \n")
deseo=input("¿desea un ranking por defecto(10 películas)?: Si o No:\n")
tamaño=0
if(deseo.lower() == "si" ):
resultado=fun.crear_ranking_gen(datos_movies,criterio,ascendente_descendente,genero)
elif(deseo.lower() == "no" ):
tamaño=int(input("Elija el número de peliculas que desea para su ranking:\n"))
resultado=fun.crear_ranking_gen(datos_movies,criterio,ascendente_descendente,genero,tamaño)
if(ascendente_descendente == "ascendente"):
print("_________________________________________")
if(deseo == "si"):
print("Top 10 mejores peliculas de:",genero)
print("Top,Titulo,Votos,Promedio")
print("_________________________________________")
x=1
for i in range(1,lt.size(resultado)+1):
print(x,(lt.getElement(resultado,i))["titulo"],",",(lt.getElement(resultado,i))["votos"],",",(lt.getElement(resultado,i))["promedio"])
x+=1
print("_________________________________________")
elif(deseo== "no"):
print("top",tamaño,"mejores peliculas de:",genero)
print("Top,Titulo,Votos,Promedio")
print("_________________________________________")
x=1
for i in range(1,lt.size(resultado)+1):
print(x,(lt.getElement(resultado,i))["titulo"],",",(lt.getElement(resultado,i))["votos"],",",(lt.getElement(resultado,i))["promedio"])
x+=1
print("_________________________________________")
elif(ascendente_descendente == "descendente"):
print("_________________________________________")
if(deseo == "si"):
print("Top 10 peores peliculas de",genero)
print("Top,Titulo,Votos,Promedio")
print("_________________________________________")
x=1
for i in range(1,lt.size(resultado)+1):
print(x,(lt.getElement(resultado,i))["titulo"],",",(lt.getElement(resultado,i))["votos"],",",(lt.getElement(resultado,i))["promedio"])
x+=1
print("_________________________________________")
elif(deseo== "no"):
print("top",tamaño,"peores peliculas de:",genero)
print("Top,Titulo,Votos,Promedio")
print("_________________________________________")
x=1
for i in range(1,lt.size(resultado)+1):
print(x,(lt.getElement(resultado,i))["titulo"],",",(lt.getElement(resultado,i))["votos"],",",(lt.getElement(resultado,i))["promedio"])
x+=1
print("_________________________________________")
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 mergeSort(lst, lessfunction):
lstaux = lt.subList(
lst, 1, lt.size(lst)
) #crear una lista auxiliar del mismo tamaNo y con el mismo contenido
sort(lst, lstaux, lessfunction, 1, lt.size(lst))
def loadMoviesCasting ():
lst = loadCSVFile("Data/themoviesdb/MoviesCastingRaw-small.csv",compareRecordIds)
print("Datos cargados, " + str(lt.size(lst)) + " elementos cargados")
return lst
def main():
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
print("Recursion Limit:", sys.getrecursionlimit())
catalog = initCatalog()
loadData(catalog)
print('Tamaño Lista libros cargados: ' +
str(lt.size(catalog['booksList'])))
print('Tamaño árbol Libros por titulo: ' +
str(map.size(catalog['booksTitleTree'])))
print('Tamaño árbol Libros por año : ' +
str(map.size(catalog['yearsTree'])))
print('Altura árbol por titulo: ' +
str(map.height(catalog['booksTitleTree'])))
print('Altura árbol por año: ' +
str(map.height(catalog['yearsTree'])))
print('Arbol Accidentes cargados: ' +
str(map.size(catalog['AccidentsTree'])))
print('Lista Accidentes cargados: ' +
str(lt.size(catalog['AccidentsList'])))
print('Altura arbol: ' + str(map.height(catalog['AccidentsTree'])))
elif int(inputs[0]) == 2:
print(
"Para ingresar la fecha, el formato de la misma debe ser: Año-Mes-Día."
+ "\n" +
"Por ejemplo, si desea buscar el 2 de Agosto de 2016, la entrada sería: 2016-02-08"
)
date = input(
"Ingrese la fecha para la cual desea buscar las severidades: ")
res = controller.getSeverityByDate(catalog, date)
if res:
print(res)
else:
print("No se encontraron accidentes para la fecha ", date)
elif int(inputs[0]) == 6:
title = input("Nombre del titulo a buscar: ")
book = controller.getBookTree(catalog, title)
if book:
print("Libro encontrado:", book['title'],
book['average_rating'])
else:
print("Libro No encontrado")
elif int(inputs[0]) == 3:
title = input("Nombre del titulo a buscar (rank): ")
rank = controller.rankBookTree(catalog, title)
print("Hay ", rank, " titulos menores (rank) que " + title)
elif int(inputs[0]) == 4:
pos = int(
input(
"Posición del k-esimo titulo del libro (select) a obtener: "
))
book = controller.selectBookTree(catalog, pos)
if book:
print("Libro en posición:", pos, ":", book['value']['title'],
book['value']['average_rating'])
else:
print("Libro no encotrado en posicion: ", pos)
elif int(inputs[0]) == 5:
year = input("Ingrese el año a consultar:")
response = controller.getBookByYearRating(catalog, year)
if response:
print(response)
else:
print("No se encontraron libro para el año", year)
else:
sys.exit(0)
sys.exit(0)
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)
t1_stop = process_time()
# printList(l)
print("InsertionSort:\t", t1_stop - t1_start, " segundos")
#=======================================
l = lt.subList(lista, 1, lt.size(lista))
t1_start = process_time()
selectionsort.selectionSort(l, less)
t1_stop = process_time()
# printList(l)
print("SelectionSort:\t", t1_stop - t1_start, " segundos")
def categorias(catalog, categoria):
categorias = catalog["categorias"]
for i in range(lt.size(categorias)):
a = lt.getElement(categorias, i)
if categoria.lower() in a["name"].lower():
return a["id"]
def loadMovies():
lst = loadCSVFile("theMoviesdb/SmallMoviesDetailsCleaned.csv",
compareRecordIds)
print("Datos cargados, " + str(lt.size(lst)) + " elementos cargados")
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)
Menu principal
"""
datos_cargados = False
while True:
printMenu()
inputs =input('Seleccione una opción para continuar\n')
if int(inputs[0])==1: # 1- Cargar información
print("Cargando información de los archivos ....")
catalog = initCatalog ()
loadData (catalog)
"""
print ('Mapa Libros cargados: ' + str(map.size(catalog['booksMap'])))
print ('Lista Libros cargados: ' + str(lt.size(catalog['booksList'])))
print ('Autores cargados: ' + str(map.size(catalog['authors'])))
"""
print ('Lista: Películas cargadas: ' + str(lt.size(catalog['moviesList'])))
print ('Mapa: Películas cargadas: ' + str(map.size(catalog['moviesMap'])))
print ('Mapa: Actores cargados: ' + str(map.size(catalog['actors'])))
print ('Mapa: Directores cargados: ' + str(map.size(catalog['directors'])))
print ('Mapa: Géneros cargados: ' + str(map.size(catalog['genres'])))
datos_cargados = True
elif int(inputs[0])==2: # 2- Buscar película por título
if not datos_cargados:
"""
bookTitle = input("Nombre del libro a buscar: ")
book = controller.getBookInfo (catalog, bookTitle)
if book:
print("Libro encontrado:",book['title'],",Rating:",book['average_rating'])
else:
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 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
"""
lista = lt.newList() # se require usar lista definida
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
lista = loadCSVFile(
"Data/test2.csv",
"Data/test3.csv") #llamar funcion cargar datos
print("Datos cargados, ", lt.size(lista["Peliculas"]),
" elementos cargados")
elif int(inputs[0]) == 2: #opcion 2
if lista == None or lista[
'size'] == 0: #obtener la longitud de la lista
print("La lista esta vacía")
else:
print("La lista tiene ", lista['size'], " elementos")
elif int(inputs[0]) == 3: #opcion 3
if lista == None or lista[
'size'] == 0: #obtener la longitud de la lista
print("La lista esta vacía")
else:
criteria = input('Ingrese el criterio de búsqueda\n')
columna = input('Ingrese la columna de interes\n')
counter = countElementsFilteredByColumn(
criteria, columna,
lista2) #filtrar una columna por criterio
print("Coinciden ", counter,
" elementos con el crtierio: ", criteria)
elif int(inputs[0]) == 4: #opcion 4
if lista == None or lista[
'size'] == 0: #obtener la longitud de la lista
print("La lista esta vacía")
else:
criteria = input('Ingrese el criterio de búsqueda\n')
counter = countElementsByCriteria(criteria,
"director_name", lista2,
lista)
print("Coinciden ", counter,
" elementos con el crtierio: '", criteria,
"' (en construcción ...)")
elif int(inputs[0]) == 5: #opcion 5
if lista == None or lista[
'size'] == 0: #obtener la longitud de la lista
print("La lista esta vacía")
else:
column = input('Ingrese la columna a organizar\n')
elements = input('Ingrese el numero de datos a mostrar\n')
function = input(
"ingrese si quiere los datos acendentes o decendentes\n"
)
organizar = orderElementsByCriteria(
function, column, lista, elements)
print("estos son los primeros", elements,
"elementos de la lista de acuerdo a", column, ":",
organizar)
elif int(inputs[0]) == 0: #opcion 0, salir
sys.exit(0)
def loadMovies():
lst = loadCSVFile("theMoviesdb/movies-small.csv", compareRecordIds)
print("Datos cargados, " + str(lt.size(lst)) + " elementos cargados")
return lst
