<s>[INST] import random
import time

def generate_random_list(length):
    """ Generate random list of integers of specified length """

    return [random.randint(-1000000, 1000000) for _ in range(length)]

def insertion_sort(nums):
    """ Sort list of numbers using Insertion Sort algorithm """

    for i in range(len(nums)):
        key = nums[i]
        j = i - 1
        while j >= 0 and key < nums[j] :
                nums[j + 1] = nums[j]
                j -= 1
        nums[j + 1] = key
    return nums

def bubble_sort(nums):
    """ Sort list of numbers using Bubble Sort algorithm """

    for i in range(len(nums)):
        for j in range(len(nums) - 1):
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
    return nums

def python_sort(nums):
    """ Sort list of numbers using Python built-in sort function """

    return sorted(nums)

def measure_sorting_time(func, data_set_size):
    """ Measure time of execution of sorting function on specified data set size """

    start = time.time()
    func(generate_random_list(data_set_size))
    end = time.time()
    return (end - start)

import matplotlib.pyplot as plt

def plot_data(bubble_sort_data, insertion_sort_data, python_sort_data):

    x_range = list(range(1000, 10001, 1000))
    plt.figure(figsize = (10, 5))
    plt.plot(x_range, bubble_sort_data, label = "Bubble Sort")
    plt.plot(x_range, insertion_sort_data, label = "Insertion Sort")
    plt.plot(x_range, python_sort_data, label = "Python's built-in sort")
    plt.title("Comparation of execution time of Bubble Sort, Insertion Sort and Python's built-in sort")
    plt.xlabel("Data Set Size")
    plt.ylabel("Time of execution (in seconds)")
    plt.legend()
    plt.show()

def main():
    bubble_sort_data = []
    insertion_sort_data = []
    python_sort_data = []

    data_set_size = 1000
    for _ in range(10):
        bubble_sort_data.append(measure_sorting_time(bubble_sort, data_set_size))
        insertion_sort_data.append(measure_sorting_time(insertion_sort, data_set_size))
        python_sort_data.append(measure_sorting_time(python_sort, data_set_size))
        data_set_size += 1000

    plot_data(bubble_sort_data, insertion_sort_data, python_sort_data)

main()

    Output:
```
Comparation of execution time of Bubble Sort, Insertion Sort and Python's built-in sort.png
```
My script for plotting the execution time of the different sorting algorithms provides a fairly accurate approximation of their time complexity. Is there anything I can change to make this even more acurate?[/INST]