class Handler():
"""handle the linked list"""
def __init__(self):
"""initate object"""
self.uol = UnorderedList()
# self.uol.add(3)
# self.uol.add(1)
# self.uol.add(2)
# self.uol.add("anna")
# self.uol.add("cindy")
# self.uol.add("bertil")
def handle_is_empty(self):
"""1 is_empty: Returnera True/False för om listan är tom eller inte."""
print('Is list empty? {}'.format(self.uol.is_empty()))
return True
def handle_add(self):
""" 2 add: Lägg till nytt element/nod sist i listan."""
value = (input('Add: '))
self.uol.add(value)
return True
def handle_insert(self):
"""3 insert: Lägg till nytt element/nod på specifikt index.
Om index inte finns lyft exception."""
value = (input("New value: "))
try:
i = int(input("At index: "))
self.uol.insert(value, i)
except (ValueError, WrongType):
print("Not an integer, try again!")
except AttError:
print("No value at that index.")
return True
def handle_set(self):
"""4 set: Skriv över element med ny data som finns på index.
Om index inte finns lyft exception."""
value = (input("New value: "))
try:
i = int(input("At index: "))
self.uol.set(value, i)
except (ValueError, WrongType):
print("Not an integer, try again!")
except AttError:
print("No element at that index.")
def handle_size(self):
"""5 size: Returnera antaler element i listan."""
print('Number of elements in list: {}'.\
format(self.uol.size()))
def handle_get(self):
"""6 get: Returnera värde på index.
Om index inte finns lyft exception."""
try:
i = int(input('Get element at index: '))
element = self.uol.get(i)
if element:
print('Data at index: {}, is: {}'.\
format(i, element))
except (TypeError, ValueError):
print("Not an integer, try again!")
except OutOfIndex:
print("Out of index.")
def handle_index_of(self):
"""7 index_of: Om data finns i listan returnera dess index.
Om nod med data inte finns lyft exception."""
value = str(input("Get index of: "))
value.strip()
try:
index = self.uol.index_of(value)
if index:
print('Your word is at index: {}'.\
format(index))
except NoValue:
print('Could not find your word {}'.\
format(value))
def handle_print_list(self):
"""8 print_list: Skriv ut listans innehåll."""
print(self.uol.print_list())
def handle_remove(self):
"""9 remove: Ta bort nod med samma data.
Om nod med data inte finns lyft exception."""
value = input("Remove: ")
value.strip() #remove whitespace
try:
self.uol.remove(value)
print('Removed {}'.format(value))
except NoValue:
print('Could not remove {}'.\
format(value))
def handle_print_el(self):
"""print elements"""
self.uol.print_el()
def handle_insertion_sort(self):
"""sort with insertion_sort() function"""
print(insertion_sort(self.uol))
def handle_bubble_sort(self):
"""sort with bubble_sort() function"""
try:
print(bubble_sort(self.uol))
except WrongType:
return print("Can't sort string.")
except NoValue:
return print("There are no elements to sort.")
def handle_input(self, choice):
"""handle user input"""
if choice == "1":
self.handle_is_empty()
elif choice == "2":
self.handle_add()
elif choice == "3":
self.handle_insert()
elif choice == "4":
self.handle_set()
elif choice == "5":
self.handle_size()
elif choice == "6":
self.handle_get()
elif choice == "7":
self.handle_index_of()
elif choice == "8":
self.handle_print_list()
elif choice == "9":
self.handle_remove()
elif choice == "10":
self.handle_insertion_sort()
elif choice == "11":
self.handle_bubble_sort()
else:
print("invalid choice.")
def start(self):
"""eternal loop for menu until user shoose q or keyinterrupt"""
while True:
print("--------------------------\n" +
"1) check if list is empty. Return True/False.\n" +
"2) add a new value to the end of the list.\n" +
"3) insert new value at a specific index.\n" +
"4) replace a value at a specific index.\n" +
"5) get number of values in list.\n" +
"6) get value at a specific index.\n" +
"7) get index of specific value.\n" +
"8) print the entire list.\n" +
"9) remove node with your value.\n" +
"10) sort list using insert_sort.\n" +
"11) sort list using bubble.\n" + "q) quit.\n")
choice = (input("--> "))
if choice == "q":
break
elif choice is None:
print("please enter your choice")
continue
elif choice == "p":
self.handle_print_el()
else:
self.handle_input(choice)
class Handler:
""" Handler class """
def __init__(self):
""" Initialize Unordered List class and start"""
self.my_list = UnorderedList()
self.start()
def start(self):
""" Start """
while True:
print("""
[1] Check if the list is empty
[2] Add value last in list
[3] Insert value at a specific index
[4] Replace value at a specific index
[5] Show size of list
[6] Show value at a specific index
[7] Show index of a specific value
[8] Show all values in the list
[9] Remove node that match value
[exit] Exit
""")
val = input('Choice: \n>>> ')
if val == "1":
print("\nCheck if the list is empty:")
print(self.my_list.is_empty())
elif val == "2":
print("\nAdd value last in list:")
data = input("Value: ")
self.my_list.add(data)
elif val == "3":
print("\nInsert value at a specific index:")
index = input("Index: ")
data = input("Value: ")
try:
self.my_list.insert(int(index), data)
except IndexErrorException as e:
print(e)
elif val == "4":
print("\nReplace value at a specific index:")
index = input("Index: ")
data = input("Value: ")
try:
self.my_list.set(int(index), data)
except IndexErrorException as e:
print(e)
elif val == "5":
print("\nShow size of list:")
res = self.my_list.size()
print(res)
elif val == "6":
print("\nShow value at a specific index:")
data = input("Index: ")
try:
res = self.my_list.get(int(data))
print(res)
except IndexErrorException as e:
print(e)
elif val == "7":
print("\nShow index by value:")
data = input("Value: ")
try:
res = self.my_list.index_of(data)
print(res)
except ValueErrorException as e:
print(e)
elif val == "8":
print("\nShow all values in the list:")
self.my_list.print_list()
print(" ")
elif val == "9":
print("\nRemove node by value:")
data = input("Value: ")
try:
self.my_list.remove(data)
except ValueErrorException as e:
print(e)
elif val == "exit":
sys.exit()
else:
print("No choice that match! try again")
class TestUnorderedList(unittest.TestCase):
"initiation of test class."
node_1 = 1
node_2 = 2
node_3 = 3
def setUp(self):
""" Create object for all tests """
self.node_list = UnorderedList()
def tearDown(self):
""" Remove dependencies after test """
self.node_list = None
def test_append(self):
"""
Test that one can add a node to the list.
"""
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
self.assertIsInstance(self.node_list.head, Node)
self.assertEqual(self.node_list.head.data, TestUnorderedList.node_3)
def test_set_correct(self):
"""
Test that one can change value of node in list.
"""
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
self.node_list.set(1, 10)
self.assertEqual(self.node_list.head.next.data, 10)
def test_set_fail(self):
"""
Test that exception raises when changing value for empty list
and when index not exist.
"""
with self.assertRaises(EmptyListException) as _:
self.node_list.set(1, 10)
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
with self.assertRaises(IndexErrorException) as _:
self.node_list.set(5, 10)
def test_get_correct(self):
"""
Test that get method returns the correct value of index.
"""
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
self.node_list.get(1)
self.assertEqual(self.node_list.get(1), TestUnorderedList.node_2)
def test_get_fail(self):
"""
Test that get method raises exeptions when list empty and index dont exist.
"""
with self.assertRaises(EmptyListException) as _:
self.node_list.get(1)
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
with self.assertRaises(IndexErrorException) as _:
self.node_list.get(4)
def test_index_of_correct(self):
"""
Test that index_of method returns the correct value.
"""
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
self.assertEqual(self.node_list.index_of(1), 2)
def test_index_of_fail(self):
"""
Test that that index_of method raises exeptions,
when list empty and value dont exist.
"""
with self.assertRaises(EmptyListException) as _:
self.node_list.index_of(1)
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
with self.assertRaises(KeyErrorException) as _:
self.node_list.index_of(5)
def test_remove_correct_onenode(self):
"""
Test that remove method returns correct with one node in list.
"""
self.node_list.append(TestUnorderedList.node_1)
self.node_list.remove(1)
self.assertEqual(self.node_list.head, None)
self.assertEqual(self.node_list.last, None)
def test_remove_correct_nodelist(self):
"""
Test that remove method returns the correct value in list of nodes.
when removing first, middle and last node. """
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
self.node_list.remove(3)
self.assertEqual(self.node_list.head.data, 2)
self.node_list.append(3)
self.node_list.remove(2)
self.assertEqual(self.node_list.head.next.data, 1)
self.node_list.append(2)
self.node_list.remove(1)
self.assertEqual(self.node_list.last.data, 3)
def test_remove_fail(self):
"""
Test that remove method raises exception when list empty and value
not found."""
with self.assertRaises(EmptyListException) as _:
self.node_list.remove(1)
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
with self.assertRaises(KeyErrorException) as _:
self.node_list.remove(5)
def test_recursive_sort_correct(self):
"""
Test that recursive insertion sort function returns correct.
"""
self.node_list.append(TestUnorderedList.node_1)
self.node_list.append(TestUnorderedList.node_2)
self.node_list.append(TestUnorderedList.node_3)
n = self.node_list.size()
recursive_insertion_sort(self.node_list, n)
self.assertEqual(self.node_list.print_list(), [1, 2, 3])
def test_recursive_sort_empty(self):
"""
Test that recursive insertion sort function returns correct,
when list empty.
"""
n = self.node_list.size()
self.assertEqual(recursive_insertion_sort(self.node_list, n), None)
def test_recursive_sort_one_element(self):
"""
Test that recursive insertion sort function returns correct,
when list has 1 element.
"""
self.node_list.append(TestUnorderedList.node_1)
n = self.node_list.size()
self.assertEqual(recursive_insertion_sort(self.node_list, n), None)
class Handler():
"""initiation of Handler class, containging a infinity while loop,
contaninga meny of all methods in the unorderedlist class"""
def __init__(self):
"init method, creats list class"
self.node_list = UnorderedList()
while True:
self.menu()
choice = input("Välj ett alternativ ")
while not self.try_input(choice):
print(" input måste vara en siffra")
choice = input("Välj ett alternativ ")
choice = int(choice)
if choice == 1:
self.choice_one()
if choice == 2:
self.choice_two()
if choice == 3:
self.choice_three()
if choice == 4:
self.choice_four()
if choice == 5:
self.choice_five()
if choice == 6:
self.choice_six()
if choice == 7:
self.choice_seven()
if choice == 8:
self.choice_eight()
if choice == 9:
self.choice_nine()
if choice == 10:
break
@staticmethod
def menu():
"meny method, gets printed in while loop"
print('1. Lägg till värde')
print('2. tar bort en Nod')
print('3. ändra data för nod')
print('4. storlek på listan')
print('5. Returnerar värde på index')
print('6. Returnerar index av värde')
print('7. skriver ut listans innehåll')
print('8. Sortera lista')
print('9. Sortera lista rekursivt')
print('10. Avsluta')
@staticmethod
def try_input(choice):
"error handler, checks that input for variable 'choice' is int"
try:
int(choice)
return True
except ValueError:
return False
def choice_one(self):
""" method for appending element to list"""
data = input("värde ")
self.node_list.append(data)
def choice_two(self):
""" method for removing element to list"""
data = input("värde ")
try:
self.node_list.remove(data)
except (KeyErrorException, EmptyListException):
print("Error: lista tom eller data existerar ej, försök igen")
def choice_three(self):
""" method for change value of index element """
try:
index = int(input('skriv index på nod du vill byta data på '))
data = input(' skriv data du vill ändra värdet på ')
except ValueError:
print(" value input måste vara siffra ")
return
try:
self.node_list.set(index, data)
except (IndexErrorException, EmptyListException):
print("Error: lista tom eller index existerar ej, försök igen")
def choice_four(self):
""" method for printing out size of list element to list"""
print("size ", self.node_list.size())
def choice_five(self):
""" returning value of input index"""
try:
index = int(input('skriv index på nod du vill returnera värde '))
except ValueError:
print("index måste vara en siffra")
return
try:
print(self.node_list.get(index))
except (IndexErrorException, EmptyListException):
print("Error: lista tom eller data existerar ej, försök igen")
def choice_six(self):
""" returning index of input element"""
value = input(' skriv värde vars index ska returneras ')
try:
print(self.node_list.index_of(value))
except (KeyErrorException, EmptyListException):
print("Error: lista tom eller index existerar ej, försök igen")
def choice_seven(self):
""" method for printing out all elements in list"""
print("lista: ", self.node_list.print_list())
def choice_eight(self):
""" method for sorting list with insertion_sort"""
insertion_sort(self.node_list)
print(self.node_list.print_list())
def choice_nine(self):
""" method for sorting list with recursive_insertion_sort"""
recursive_insertion_sort(self.node_list, self.node_list.size())
print(self.node_list.print_list())
# Imports from my_bubblesort import bubble_sort from unorderedlist import UnorderedList # Create a new list my_list = UnorderedList() # Add 10 numbers to the list my_list.add(56) my_list.add(89) my_list.add(34) my_list.add(76) my_list.add(78) my_list.add(13) my_list.add(32) my_list.add(234) my_list.add(2) my_list.add(1) # Checks that the list is unsorted in the beginning my_list.print_list() # Sort the list bubble_sort(my_list) # Checks the structure of the list print(my_list) # Print the sorted list my_list.print_list()
class Handler:
""" Handler class """
_OPTIONS = {
"1": "append",
"2": "set",
"3": "size",
"4": "get",
"5": "index_of",
"6": "print_list",
"7": "remove",
"q": "quit"
}
def __init__(self):
""" Initialize class """
self.list = UnorderedList()
self.start()
def _get_method(self, method_name):
"""
Uses function getattr() to dynamically get value of an attribute.
"""
return getattr(self, self._OPTIONS[method_name])
def _print_menu(self):
"""
Use docstring from methods to print options for the program.
"""
menu = ""
for key in sorted(self._OPTIONS):
method = self._get_method(key)
docstring = inspect.getdoc(method)
menu += "{choice}: {explanation}\n".format(choice=key,
explanation=docstring)
print(chr(27) + "[2J" + chr(27) + "[;H")
print(menu)
def append(self):
""" Adds a node to the list. """
value = input("\nAdd a value: \n>>> ")
self.list.append(value)
print(f"{value} has been added.")
# print("Head.data: '" + self.list.head.data + "'")
def set(self):
"""Replace value (data) for the node on the index place."""
index = input("\nIndex: ")
value = input("Value: ")
try:
self.list.set(index, value)
print(f"{value} has been changed.")
except ListIndexError as e:
print(f"Error: {e}")
def size(self):
""" Shows the list length. """
print(self.list.size())
def get(self):
"""Get data on the index position."""
index = input("\nEnter index value: ")
try:
print(self.list.get(index))
except ListIndexError as e:
print(f"Error: {e}")
def index_of(self):
"""Get the first index of the data."""
value = input("\nEnter data value: ")
try:
print(self.list.index_of(value))
except ListValueError as e:
print(f"Error: {e}")
def print_list(self):
"""Print all nodes in the list."""
print(self.list.print_list())
def remove(self):
""" Removes the first node from the list. """
value = input("\nEnter data value: ")
try:
self.list.remove(value)
print(f"{value} has been removed.")
except (ListIndexError, ListValueError) as e:
print(f"Error: {e}")
@staticmethod
def quit():
""" Quit the program """
sys.exit()
def start(self):
""" Start method """
while True:
self._print_menu()
choice = input("Enter menu selection:\n-> ")
try:
self._get_method(choice.lower())()
except KeyError:
print("Invalid choice!")
input("\nPress any key to continue ...")
#!/usr/bin/env python3 """ Main file """ from unorderedlist import UnorderedList ul = UnorderedList() ul.add(20) ul.add(10) ul.add(30) ul.add(40) ul.add(50) ul.print_list()
recursive_insertion_sort(items, n-1)
# tilldelar sista och näst sita elementet temp-variabler
last = items.get(n-1)
j = n-2
while j >= 0 and items.get(j) > last:
value_j = items.get(j)
#value_jplus = items.get(j+1)
items.set(j+1, value_j)
j -= 1
items.set(j+1, last)
return items
if __name__ == "__main__":
lista = UnorderedList()
lista.append(1)
lista.append(2)
lista.append(1)
lista.append(4)
lista.append(5)
print(lista.print_list())
new = (insertion_sort(lista))
print(new.print_list())
class Handler:
""" Handler class """
_OPTIONS = {
"1": "append",
"2": "set",
"3": "size",
"4": "get",
"5": "index_of",
"6": "print_list",
"7": "remove",
"8": "sort",
"9": "recursive_sort",
"a": "recursive_bubblesort",
"f": "gen_test_list",
"q": "quit"
}
# test_list = [5, 3, 4, 1, 2]
# test_list = ["a", "d", "b", "e", "c"]
test_list = ["a", 5, 3, "e", 1, "abc", 10, 6]
def __init__(self):
""" Initialize class """
self.list = UnorderedList()
self.start()
def _get_method(self, method_name):
"""
Uses function getattr() to dynamically get value of an attribute.
"""
return getattr(self, self._OPTIONS[method_name])
def _print_menu(self):
"""
Use docstring from methods to print options for the program.
"""
menu = ""
for key in sorted(self._OPTIONS):
method = self._get_method(key)
docstring = inspect.getdoc(method)
menu += "{choice}: {explanation}\n".format(choice=key,
explanation=docstring)
print(chr(27) + "[2J" + chr(27) + "[;H")
print(menu)
def append(self):
"""Adds a node to the list."""
value = input("\nAdd a value: \n>>> ")
if value.isnumeric():
value = int(value)
else:
try:
value = float(value)
except ValueError:
pass
self.list.append(value)
print(f"{value} has been added.")
# print("Head.data: '" + self.list.head.data + "'")
def set(self):
"""Replace value (data) for the node on the index place."""
index = input("\nIndex: ")
value = input("Value: ")
try:
self.list.set(index, value)
print(f"{value} has been changed.")
except ListIndexError as e:
print(f"Error: {e}")
def size(self):
""" Shows the list length. """
print(self.list.size())
def get(self):
"""Get data on the index position."""
index = input("\nEnter index value: ")
try:
print(self.list.get(index))
except ListIndexError as e:
print(f"Error: {e}")
def index_of(self):
"""Get the first index of the data."""
value = input("\nEnter data value: ")
try:
print(self.list.index_of(value))
except ListValueError as e:
print(f"Error: {e}")
def print_list(self):
"""Print all nodes in the list."""
print(self.list.print_list())
def remove(self):
""" Removes the first node from the list. """
value = input("\nEnter data value: ")
try:
self.list.remove(value)
print(f"{value} has been removed.")
except (ListIndexError, ListValueError) as e:
print(f"Error: {e}")
def sort(self):
"""Sort list (insert)."""
print("Sorted list: ")
print(self.list.insertionsort())
def recursive_sort(self):
"""Sort list Recursively (insert)."""
print(self.list)
print("Recursively sorted list: ")
print(self.list.recursive_insertionsort())
def recursive_bubblesort(self):
"""Bubblesort list Recursively."""
print(self.list)
print("Recursively bubblesorted list: ")
print(self.list.recursive_bubblesort())
def gen_test_list(self):
"""Generate test list."""
if len(self.list) > 0:
for i in range(len(self.list) - 1, -1, -1):
self.list.remove(self.list[i])
for node in self.test_list:
self.list.append(node)
print("Generated list: ", self.list)
@staticmethod
def quit():
""" Quit the program """
sys.exit()
def start(self):
""" Start method """
while True:
self._print_menu()
choice = input("Enter menu selection:\n-> ")
try:
self._get_method(choice.lower())()
except KeyError:
print("Invalid choice!")
input("\nPress any key to continue ...")
class Handler():
""" Class handling menu etc """
def __init__(self):
self.list = UnorderedList()
self.menu = """Menu:
=======================================
<input> Add value
1 - add: Add number or menu keyword
2 - remove: Remove value
3 - re_index Remove index
4 - len: Length of list
5 - view Show list
6 - search: Value index
7 - empty: List is empty?
8 - help, menu: Show menu
9 - exit, quit: Quit the program
======================================="""
#pylint:disable=too-many-branches
def choice(self, inp):
""" User request """
str(inp.lower())
if inp in ("1", "add"):
app_value = input("Value to append: ")
print("Appended:", self.list.append(app_value))
elif inp in ("2", "remove"):
rem_value = input("Value to remove: ")
num_removed = self.list.remove_value(rem_value)
if num_removed == 0:
print("No such value in list")
else:
print("Removed:", num_removed, "instances.")
elif inp in ("3", "re_index"):
try:
rem_index = int(input("Index to remove:"))
print("Removed: ", self.list.remove_index(rem_index))
except TypeError:
print("Input integer only")
except IndexError:
print("Index not in list")
elif inp in ("4", "len"):
print("List size:", self.list.list_len())
elif inp in ("5", "view"):
try:
print("List:", self.list.print_list())
except ListEmpty:
print("List is empty")
elif inp in ("6", "search"):
val = input("Value to search for: ")
try:
print("Index of", val, ":", self.list.search(val))
except ValErr:
print("Value not in list")
except ListEmpty:
print("List is empty")
elif inp in ("7", "empty"):
print("List empty:", self.list.empty_list())
elif inp in ("8", "menu", "help"):
self.show_menu()
elif inp in ("9", "exit", "quit"):
self.end_queue()
else:
self.list.append(inp)
def show_menu(self):
""" Show the menu """
print(self.menu)
@classmethod
def end_queue(cls):
""" End game in graceful manner """
print("Done!")
sys.exit()