Use the time module to write a decorator function named sort_timer ...

Use the time module to write a decorator function named sort_timer that times how many seconds it takes the decorated function to run. Since sort functions don't need to return anything, have the decorator's wrapper function return that elapsed time.
To get the current time, call time.perf_counter(). Subtracting the begin time from the end time will give you the elapsed time in seconds.
Copy the code for bubble sort and insertion sort from Module 4 and decorate them with sort_timer.
Write a function called compare_sorts that takes the two decorated sort functions as parameters. It should randomly generate a list of 1000 numbers and then make a separate copy of that list, which you can do like this:
list_2 = list(list_1)
Next it should time how long it takes bubble sort to sort one of those copies (using the decorated bubble sort), and then time how long it takes insertion sort to sort the other copy (using the decorated insertion sort). This gets us the first data point for each algorithm. The function should now repeat this for lists of size 2000, 3000, and so on, up to 10000. For each list size, the function should randomly generate a list of that size and time how long it takes each algorithm to sort it. The random numbers should all be integers in the range 1 <= r <= 10000. Once the function has the 10 time data points for each algorithm, it will generate a graph comparing them.
To generate random numbers, you will need to import the random module. The function call random.randint(a, b) returns a random integer N such that a <= N <= b. You should use a = 1 and b = 10000. It's fine if values appear in the list multiple times.
To generate a graph, you will need to install the matplotlib package and import pyplot from it. Here's an example of code to produce a graph comparing two series of data points: from matplotlib import pyplot
pyplot.plot([1, 2, 3, 4, 10], [1, 4, 9, 16, 100], 'ro--', linewidth=2)
pyplot.plot([1, 2, 3, 4, 10], [1, 3, 7, 20, 150], 'go--', linewidth=2)
pyplot.show()
Each of the calls to the plot function plot a line. The call to the show function displays the graph. In the calls to the plot function, the first list is the list of x-coordinates (which for both lines on your graph will be the same array). The second list is the list of y-coordinates. The 'ro--' tells it to use red circles connected by a dashed line and 'go--' is the same except green instead of red. The linewidth parameter is self-explanatory.

Functions:
def bubble_sort(a_list):   
"""   
Sorts a_list in ascending order   
"""   
for pass_num in range(len(a_list) - 1):      
    for index in range(len(a_list) - 1 - pass_num):            
      if a_list[index] > a_list[index + 1]:               
       temp = a_list[index]               
       a_list[index] = a_list[index + 1]               
       a_list[index + 1] = temp


def insertion_sort(a_list):   
"""   
Sorts a_list in ascending order   
"""   
for index in range(1, len(a_list)):      
    value = a_list[index]      
    pos = index - 1      
    while pos >= 0 and a_list[pos] > value:            
      a_list[pos + 1] = a_list[pos]            
      pos -= 1      
    a_list[pos + 1] = value

These solutions may offer step-by-step problem-solving explanations or good writing examples that include modern styles of formatting and construction of bibliographies out of text citations and references. Students may use these solutions for personal skill-building and practice. Unethical use is strictly forbidden.

import time
import random
from matplotlib import pyplot

def sort_timer(sort_f):
    def wrapper(a_list):
       begin_time = time.perf_counter()
       sort_f(a_list)
       end_time = time.perf_counter()
       return end_time - begin_time
    return wrapper

@sort_timer
def bubble_sort(a_list):
    """
    Sorts a_list in ascending order
    """
    for pass_num in range(len(a_list) - 1):
       for index in range(len(a_list) - 1 - pass_num):
            if a_list...