def test_repeatedElements_greater(self):
"""
Con elementos repetidos en la lista
"""
self.lst = slt.newList(self.list_type)
slt.addFirst(self.lst, self.movie5)
slt.addFirst(self.lst, self.movie4)
slt.addFirst(self.lst, self.movie6)
slt.addFirst(self.lst, self.movie3)
slt.addFirst(self.lst, self.movie1)
slt.addFirst(self.lst, self.movie6)
slt.addFirst(self.lst, self.movie2)
slt.addFirst(self.lst, self.movie4)
print(
"Repeated elements:----------------------------------------------------"
)
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
print("sorting ....")
sort.selectionSort(self.lst, self.greater)
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
def orderElementsByCriteria(function,lst):
"""
Retorna una lista con cierta cantidad de elementos ordenados por el criterio
"""
t1_start = process_time() #tiempo inicial
lst_count = lt.newList()
lst_count['elements'] = [[],{}]
print(lst_count)
lst_average = lt.newList()
lst_average['elements'] = [[],{}]
for i in range(lt.size(lst)):
lst_count['elements'][0].append(int(lst['elements'][i]['vote_count']))
lst_count['elements'][1][lst['elements'][i]['vote_count']] = lst['elements'][i]['original_title']
lst_average['elements'][0].append(float(lst['elements'][i]['vote_average']))
lst_average['elements'][1][lst['elements'][i]['vote_average']] = lst['elements'][i]['original_title']
if function == '1':
lst_count['elements'][0] = sor1.insertionSort(lst_count['elements'][0])
lst_average['elements'][0] = sor1.insertionSort(lst_average['elements'][0])
elif function == '2':
lst_count['elements'][0] = sor2.selectionSort(lst_count['elements'][0])
lst_average['elements'][0] = sor2.selectionSort(lst_average['elements'][0])
elif function == '3':
lst_count['elements'][0] = sor3.shellSort(lst_count['elements'][0])
lst_average['elements'][0] = sor3.shellSort(lst_average['elements'][0])
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ",t1_stop-t1_start," segundos")
return (lst_count,lst_average)
def test_invertedElements_greater(self):
"""
Lista ordenada inversamente
"""
self.lst = slt.newList(self.list_type)
slt.addFirst(self.lst, self.movie1)
slt.addFirst(self.lst, self.movie2)
slt.addFirst(self.lst, self.movie3)
slt.addFirst(self.lst, self.movie4)
slt.addFirst(self.lst, self.movie5)
slt.addFirst(self.lst, self.movie6)
print(
"Inverted list:----------------------------------------------------"
)
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
print("sorting ....")
sort.selectionSort(self.lst, self.greater)
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
def test_oneElement_greater(self):
"""
Un elemento
"""
self.lst = slt.newList(self.list_type)
slt.addFirst(self.lst, self.movie1)
print(
"one element:----------------------------------------------------")
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
print("sorting ....")
sort.selectionSort(self.lst, self.greater)
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
def test_sort_menor_a_mayor(self):
"""
Lista con elementos en orden aleatorio
"""
print("sorting ....")
sort.selectionSort(self.lst_movies, self.greater)
self.printList(self.lst_movies)
def test_repeatedElements (self):
"""
Con muchos elementos en la lista
"""
self.lst = slt.newList(self.list_type)
slt.addFirst (self.lst, self.book5)
slt.addFirst (self.lst, self.book6)
slt.addFirst (self.lst, self.book14)
slt.addFirst (self.lst, self.book3)
slt.addFirst (self.lst, self.book13)
slt.addFirst (self.lst, self.book10)
slt.addFirst (self.lst, self.book1)
slt.addFirst (self.lst, self.book12)
slt.addFirst (self.lst, self.book2)
slt.addFirst (self.lst, self.book8)
slt.addFirst (self.lst, self.book4)
slt.addFirst (self.lst, self.book11)
slt.addFirst (self.lst, self.book7)
slt.addFirst (self.lst, self.book9)
print ("Repeated elements:----------------------------------------------------")
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(str(key) + ": " + str(value) + ", " for key, value in element.items())
print (result)
print ("sorting ....")
sort.selectionSort (self.lst, self.less)
self.assertTrue(self.verifySorting(self.lst, self.less))
def test_randomElements (self):
"""
Lista con elementos en orden aleatorio
"""
self.lst = slt.newList(self.list_type)
slt.addFirst (self.lst, self.book5)
slt.addFirst (self.lst, self.book6)
slt.addFirst (self.lst, self.book3)
slt.addFirst (self.lst, self.book10)
slt.addFirst (self.lst, self.book1)
slt.addFirst (self.lst, self.book2)
slt.addFirst (self.lst, self.book8)
slt.addFirst (self.lst, self.book4)
slt.addFirst (self.lst, self.book7)
slt.addFirst (self.lst, self.book9)
print ("Random list:----------------------------------------------------")
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
#result = "".join(str(key) + ": " + str(value) + ", " for key, value in element.items())
#print (result)
print ("Sorting ....")
sort.selectionSort (self.lst, self.less)
self.assertTrue(self.verifySorting(self.lst, self.less))
def test_invertedElements (self):
"""
Lista ordenada inversamente
"""
self.lst = slt.newList(self.list_type)
slt.addFirst (self.lst, self.book1)
slt.addFirst (self.lst, self.book2)
slt.addFirst (self.lst, self.book3)
slt.addFirst (self.lst, self.book4)
slt.addFirst (self.lst, self.book5)
slt.addFirst (self.lst, self.book6)
slt.addFirst (self.lst, self.book7)
slt.addFirst (self.lst, self.book8)
slt.addFirst (self.lst, self.book9)
slt.addFirst (self.lst, self.book10)
print ("Inverted list:----------------------------------------------------")
iterator = it.newIterator(self.lst)
count=0
while it.hasNext(iterator):
element = it.next(iterator)
count+=1
result = "".join(str(key) + ": " + str(value) + ", " for key, value in element.items())
print (result)
print ("sorting ....")
sort.selectionSort (self.lst, self.less)
self.assertTrue(self.verifySorting(self.lst, self.less))
def test_orderedElements(self):
"""
Lista ordenada
"""
self.lst = slt.newList(self.list_type)
slt.addFirst(self.lst, self.book10)
slt.addFirst(self.lst, self.book9)
slt.addFirst(self.lst, self.book8)
slt.addFirst(self.lst, self.book7)
slt.addFirst(self.lst, self.book6)
slt.addFirst(self.lst, self.book5)
slt.addFirst(self.lst, self.book4)
slt.addFirst(self.lst, self.book3)
slt.addFirst(self.lst, self.book2)
slt.addFirst(self.lst, self.book1)
print(
"ordered list:----------------------------------------------------"
)
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
print("sorting ....")
sort.selectionSort(self.lst, self.less)
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
def test_sort (self):
"""
Lista con elementos en orden aleatorio
"""
print ("sorting ....")
sort.selectionSort (self.lst_books, self.less)
self.printList (self.lst_books)
def test_randomElements(self):
"""
Lista con elementos en orden aleatorio
"""
self.lst = slt.newList(self.list_type)
slt.addFirst(self.lst, self.movie5)
slt.addFirst(self.lst, self.movie6)
slt.addFirst(self.lst, self.movie3)
slt.addFirst(self.lst, self.movie4)
slt.addFirst(self.lst, self.movie1)
slt.addFirst(self.lst, self.movie2)
print(
"Testing Random list:----------------------------------------------------"
)
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
print("sorting ....")
sort.selectionSort(self.lst, self.less)
iterator = it.newIterator(self.lst)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
def test_loading_CSV_y_ordenamiento_inv():
"""
Prueba que se pueda leer el archivo y que despues de relizar el sort, el orden este correcto
"""
setUp()
sort.selectionSort(lst_movies,greater)
while not (lt.isEmpty(lst_movies)):
x = int(lt.removeLast(lst_movies)['id'])
if not (lt.isEmpty(lst_movies)):
y = int(lt.lastElement(lst_movies)['id'])
else:
break
assert x < y
def test_loading_CSV_y_ordenamiento():
"""
Prueba que se pueda leer el archivo y que despues de relizar el sort, el orden este correcto
"""
setUp()
sort.selectionSort(lst_books, less)
while not (lt.isEmpty(lst_books)):
x = int(lt.removeLast(lst_books)['goodreads_book_id'])
if not (lt.isEmpty(lst_books)):
y = int(lt.lastElement(lst_books)['goodreads_book_id'])
else:
break
assert x > y
def sort(option, elements, function):
if option == 1:
print("sorting by selection sort....")
t1_start = process_time() #tiempo inicial
selsort.selectionSort(elements, function)
if option == 2:
print("sorting by insertion sort....")
t1_start = process_time() #tiempo inicial
inssort.insertionSort(elements, function)
if option == 3:
print("sorting by shell sort....")
t1_start = process_time() #tiempo inicial
shellsort.shellSort(elements, function)
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
def test_loading_CSV_y_ordenamiento(lst_books):
"""
Prueba que se pueda leer el archivo y que despues de relizar el sort, el orden este correcto
"""
element = lt.lastElement(lst_books)
assert element['goodreads_book_id'] == '4374400'
element = lt.firstElement(lst_books)
assert element['goodreads_book_id'] == '2767052'
sort.selectionSort(lst_books, less)
tam = lt.size(lst_books)
assert tam == 149
element = lt.lastElement(lst_books)
assert element['goodreads_book_id'] == '22557272'
element = lt.firstElement(lst_books)
assert element['goodreads_book_id'] == '1'
def order_movies(function, lst_d, req_elements, algorithm, column):
"""
Retorna una lista con cierta cantidad de elementos ordenados por el criterio
"""
if len(lst_d) == 0:
print('Las listas están vacías')
else:
t1_start = process_time() # tiempo inicial
# Sort movies.
if algorithm == 'selection':
if function == 'less':
selection.selectionSort(lst_d, less_count) if column == 'vote_count' \
else selection.selectionSort(lst_d, less_average)
elif function == 'greater':
selection.selectionSort(lst_d, greater_count) if column == 'vote_count' \
else selection.selectionSort(lst_d, greater_average)
elif algorithm == 'shell':
if function == 'less':
shell.shellSort(lst_d, less_count) if column == 'vote_count' \
else shell.shellSort(lst_d, less_average)
elif function == 'greater':
shell.shellSort(lst_d, greater_count) if column == 'vote_count' \
else shell.shellSort(lst_d, greater_average)
elif algorithm == 'insertion':
if function == 'less':
insertion.insertionSort(lst_d, less_count) if column == 'vote_count' \
else insertion.insertionSort(lst_d, less_average)
elif function == 'greater':
insertion.insertionSort(lst_d, greater_count) if column == 'vote_count' \
else insertion.insertionSort(lst_d, greater_average)
t1_stop = process_time() # tiempo final
print(req_elements, 'best' if function == 'greater' else 'worst',
'count:' if column == 'vote_count' else 'average:')
show_movies(lt.subList(lst_d, 0, int(req_elements)), None)
print('Tiempo de ejecución ', t1_stop - t1_start, ' segundos')
def rankingPeliculas(function, lst, criteria, elements):
"""
Retorna el ranking de películas con base en los parámetros
Args:
function
Función de ordenamiento que se va a usar
column:: str
Columna que se usa para realiza el ordenamiento (vote_average o vote_count)
lst
Lista encadenada o arreglo
criteria:: str
Critero para ordenar (less o greater)
elements:: int
Cantidad de elementos para el ranking
Return:
counter :: int
la cantidad de veces ue aparece un elemento con el criterio definido
"""
t1_start = process_time() #tiempo inicial
if function == "selectionsort":
selectionsort.selectionSort(lst, criteria)
if function == "insertionsort":
insertionsort.insertionSort(lst, criteria)
if function == "mergesort":
mergesort.mergesort(lst, criteria)
if function == "quicksort":
quicksort.quickSort(lst, criteria)
if function == "shellsort":
shellsort.shellSort(lst, criteria)
i = 0
ordenado = []
while i < elements:
i += 1
pelicula = lt.getElement(lst, i)
ordenado.append(pelicula)
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
return ordenado
def orderElementsByCriteria(orderfunction, column, lista, compfunction,
elements):
"""
Retorna una lista con cierta cantidad de elementos ordenados por el criterio
"""
t1_start = process_time() #tiempo inicial
if orderfunction == 1:
ins.insertionSort(lista, compfunction, column)
elif orderfunction == 2:
ss.selectionSort(lista, compfunction, column)
elif orderfunction == 3:
shell.shellSort(lista, compfunction, column)
ins.insertionSort(lista, compfunction, column)
iterator = it.newIterator(lista)
ranking = []
x = 1
while it.hasNext(iterator) and x <= elements:
element = it.next(iterator)
ranking.append(element.get("original_title"))
x += 1
t1_stop = process_time() #tiempo final
print("Tiempo de ejecución ", t1_stop - t1_start, " segundos")
return ranking
def sort_movies(algorithm, function, lst_d, column):
if algorithm == 'selection':
if function == 'less':
selection.selectionSort(lst_d, less_count) if column == 'vote_count' \
else selection.selectionSort(lst_d, less_average)
elif function == 'greater':
selection.selectionSort(lst_d, greater_count) if column == 'vote_count' \
else selection.selectionSort(lst_d, greater_average)
elif algorithm == 'shell':
if function == 'less':
shell.shellSort(lst_d, less_count) if column == 'vote_count' \
else shell.shellSort(lst_d, less_average)
elif function == 'greater':
shell.shellSort(lst_d, greater_count) if column == 'vote_count' \
else shell.shellSort(lst_d, greater_average)
elif algorithm == 'insertion':
if function == 'less':
insertion.insertionSort(lst_d, less_count) if column == 'vote_count' \
else insertion.insertionSort(lst_d, less_average)
elif function == 'greater':
insertion.insertionSort(lst_d, greater_count) if column == 'vote_count' \
else insertion.insertionSort(lst_d, greater_average)
def selectionSort(lst, compFunction):
"""
Aplicar selection sort a la lista
"""
sels.selectionSort(lst, compFunction)
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
"""
lista1 = [] # se require usar lista definida peliculas
lista2 = [] # se require usar lista definida directores casting
lista3 = [] # se require usar lista definida books
"""
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/test.csv") #llamar funcion cargar datos
print("Datos cargados, ",lista['size']," 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')
counter=countElementsFilteredByColumn(criteria, "nombre", lista) #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,0,lista)
print("Coinciden ",counter," elementos con el crtierio: '", criteria ,"' (en construcción ...)")
elif int(inputs[0])==0: #opcion 0, salir
sys.exit(0)
"""
while True:
printMenu() #imprimir el menu de opciones en consola
inputs = input(
'Seleccione una opción para continuar: ') #leer opción ingresada
print("Usted selecciono: ", inputs)
if len(inputs) > 0:
if int(inputs) == 1: #opcion 1
lista1 = loadCSVFile(
"Data/theMoviesdb/MoviesDetailsCleaned-large.csv", lista1)
print("Datos cargados de Movies Large, ", len(lista1),
" elementos cargados")
lista2 = loadCSVFile(
"Data/theMoviesdb/MoviesCastingRaw-large.csv", lista2)
print("Datos cargados de Casting Large, ", len(lista2),
" elementos cargados")
input("Clic para cotinuar...")
elif int(inputs) == 2: #opcion 2
lista1 = loadCSVFile(
"Data/theMoviesdb/MoviesDetailsCleaned-small.csv", lista1)
print("Datos cargados de Movies Small, ", len(lista1),
" elementos cargados")
lista2 = loadCSVFile(
"Data/theMoviesdb/MoviesCastingRaw-small.csv", lista2)
print("Datos cargados de Casting Small, ", len(lista2),
" elementos cargados")
input("Clic para cotinuar")
elif int(inputs) == 3: #opcion 3
input("Clic para continuar")
fileToLoad = input(
"Digite el nombre del archivo [ ejemplo: Data/GoodReads/books.csv ] : "
)
lista1 = loadCSVFile(fileToLoad)
print("Datos cargados del archivo [", fileToLoad, " ]: ",
len(lista1))
input("Clic para cotinuar")
elif int(inputs) == 4: #opcion 4
orden = "less"
criterio = 'vote_count'
#print (lista1)
#input ("Clic para avanzar")
lista3 = iSort(lista1, criterio, orden)
print("Se ha ordenado la lista")
elif int(inputs) == 5: #opcion 5
orden = "greater"
criterio = 'vote_count'
#print (lista1)
#input ("Clic para avanzar")
lista3 = iSort(lista1, criterio, orden)
print("Se ha ordenado la lista")
elif int(inputs) == 6: #opcion 6
orden = "less"
criterio = 'vote_average'
#print (lista1)
#input ("Clic para avanzar")
lista3 = iSort(lista1, criterio, orden)
print("Se ha ordenado la lista")
elif int(inputs) == 7: #opcion 7
orden = "greater"
criterio = 'vote_average'
#print (lista1)
#input ("Clic para avanzar")
lista3 = iSort(lista1, criterio, orden)
print("Se ha ordenado la lista")
input("En construccion....Clic para cotinuar")
elif int(inputs) == 8: #opcion 8
cantidad = int(
input("Digite el numero de pelicuales que dea lisar:"))
buscarMovies(lista1, cantidad)
input("En construccion....Clic para cotinuar")
elif int(inputs) == 9: #opcion 9
cantidad = int(
input("Digite el numero de pelicuales que dea lisar:"))
buscarMoviesWorst(lista1, cantidad)
input("En construccion....Clic para cotinuar")
elif int(inputs) == 10: #opcion 10
lista1 = lt.newList(datastructure='ARRAY_LIST')
#lista1=lt.newList (datastructure='SINGLE_LINKED')
#lista1 = lt.newList()
lista1 = loadCSVFileNew(
"Data/theMoviesdb/MoviesDetailsCleaned-small.csv")
shell.shellSort(lista1, lessfunction)
input(
"Se ordenaron ascendentemente las peliculas por el campo ** Vote Count ** ....Clic para cotinuar"
)
elif int(inputs) == 11: #opcion 11
lista1 = lt.newList()
#lista1=lt.newList (datastructure='ARRAY_LIST')
#lista1=lt.newList (datastructure='SINGLE_LINKED')
#lista1 = lt.newList()
lista1 = loadCSVFileNew(
"Data/theMoviesdb/MoviesDetailsCleaned-small.csv")
seSort.selectionSort(lista1, lessfunction)
elif int(inputs) == 12: #opcion 12
input("En construccion....Clic para cotinuar")
elif int(inputs) == 13: #opcion 13
input("En construccion....Clic para cotinuar")
elif int(inputs) == 0: #opcion 0, salir
sys.exit(0)
def test_sort():
"""
Lista con elementos en orden aleatorio
"""
print("sorting ....")
sort.selectionSort(lst_books, less)
def selectionsort(lst, function, condition):
sel.selectionSort(lst, function, condition)
#=======================================
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")
#=======================================
l = lt.subList(lista, 1, lt.size(lista))
t1_start = process_time()
mergesort.mergesort(l, less)
t1_stop = process_time()
# printList(l)
print("MergeSort:\t", t1_stop - t1_start, " segundos")
#=======================================
