Example #1
0
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
Example #2
0
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
Example #3
0
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)
Example #5
0
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)
Example #7
0
def addDirector (catalog, director):
    """
    Adiciona un director a la lista de directores
    """
    d = newDirector (director['director_name'], director['id'])
    lt.addLast (catalog['directors'], d)
Example #8
0
# 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:
Example #9
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
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)
Example #11
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")
Example #12
0
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'])
Example #13
0
def newGenre(g,row):
    newgenre = {'genre':"", 'genreMovies':None}
    newgenre['genre']=g
    newgenre['genreMovies']=lt.newList()
    lt.addLast(newgenre['genreMovies'],row['id'])
    return newgenre
Example #14
0
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)
Example #16
0
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)
Example #17
0
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
Example #18
0
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
Example #20
0
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
Example #22
0
def lstmovies(movies):
    slt = lst.newList(list_type, cmpfunction)
    for i in range(0, 5):
        lst.addLast(slt, movies[i])
    return slt
Example #23
0
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
Example #25
0
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)
Example #26
0
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)
Example #28
0
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