good sorts

import gc
import multiprocessing
import random
from time import time as _time

gc.enable()


def main():
    opopopop = 0
    strings = [""] * 9
    sorts = [bubble_sort, quick_sort, sort_insert, sort_select, sort_merge, sort_radix, sort_shell, sort_count, tim_sort]
    d = [0] * 9
    l = " " * 6
    # create table
    print("      \u001b[34;1mType \u001b[0m:   "
          "|%s\u001b[32;1mbubble\u001b[0m%s|"
          "|%s\u001b[32;1mquick\u001b[0m %s|"
          "|%s\u001b[32;1minsert\u001b[0m%s|"
          "|%s\u001b[32;1mselect\u001b[0m%s|"
          "|%s\u001b[32;1mmerge\u001b[0m %s|"
          "|%s\u001b[32;1mradix\u001b[0m %s|"
          "|%s\u001b[32;1mshell\u001b[0m %s|"
          "|%s\u001b[32;1mcount\u001b[0m %s|"
          "|%s\u001b[32;1mtim\u001b[0m %s|"
          % (l, l, l, l, l, l, l, l, l, l, l, l, l, l, l, l, l + " ", l + " "))
    for i in range(0, 3):
        for y in range(3, 8):
            # create input
            nums = [random.randint(0, 1000) for f in range(0, pow(10, y))]
            if i > 0:
                nums = sorted(nums)
            if i == 2:
                nums.reverse()
            for w in range(len(sorts)):
                a = nums.copy()
                if w == 1:
                    process = multiprocessing.Process(target=sorts[w], args=(a, 0, len(nums) - 1,))
                else:
                    process = multiprocessing.Process(target=sorts[w], args=(a,))
                process.start()
                b = millis()
                process.join(10)
                if process.is_alive():
                    process.terminate()
                d[w] = (millis() - b)
            # create output strings
            for h in range(0, len(strings)):
                strings[h] = "|   \u001b[36;1m%0.10f\u001b[0m   |" % d[h]
                # yellow if more than 3
                if d[h] >= 1:
                    strings[h] = "|   \u001b[33;1m%0.10f\u001b[0m   |" % d[h]
                # red if overtime
                if d[h] > 9.9999999999:
                    strings[h] = "|   \u001b[31;1m9.9999999999\u001b[0m   |"
                if d[h] == min(d):
                    strings[h] = "|   \u001b[39;1m%0.10f\u001b[0m   |" % d[h]
            # print
            print("\u001b[35m%10d\u001b[0m :   %s%s%s%s%s%s%s%s%s"
                  % (pow(10, y), strings[0], strings[1], strings[2], strings[3], strings[4], strings[5], strings[6], strings[7], strings[8]))
            for j in range(9):
                opopopop += d[j]
            gc.collect()
        if i == 0:
            print("\n    \u001b[34;1mAlready sorted:\u001b[0m\n")
        if i == 1:
            print("\n    \u001b[34;1mSorted and reversed:\u001b[0m\n")
    print("Total time: %s" % opopopop)


def quick_sort(nums, start, end):
    if start >= end:
        return
    i, j = start, end
    opora = nums[random.randint(start, end)]
    while i <= j:
        while nums[i] < opora:
            i += 1
        while nums[j] > opora:
            j -= 1
        if i <= j:
            nums[i], nums[j] = nums[j], nums[i]
            i, j = i + 1, j - 1
    quick_sort(nums, start, j)
    quick_sort(nums, i, end)


def bubble_sort(nums):
    n = 1
    while n < len(nums):
        for i in range(0, len(nums) - n):
            if nums[i] > nums[i + 1]:
                nums[i], nums[i + 1] = nums[i + 1], nums[i]
        n += 1


def sort_insert(nums):
    for i in range(0, len(nums)):
        j = i - 1
        current = nums[i]
        while j >= 0 and nums[j] > current:
            nums[j + 1] = nums[j]
            j -= 1
        nums[j + 1] = current
    return nums


def sort_select(nums):
    for i in range(len(nums)):
        nums_min = i
        for j in range(i + 1, len(nums)):
            if nums[j] < nums[nums_min]:
                nums_min = j
        nums[i], nums[nums_min] = nums[nums_min], nums[i]


def merge(left, right):
    nums = []
    while left and right:
        if left[0] < right[0]:
            nums.append(left.pop(0))
        else:
            nums.append(right.pop(0))
    if left:
        nums.extend(left)
    if right:
        nums.extend(right)
    return nums


def sort_merge1(nums):
    length = len(nums)
    if length >= 2:
        mid = int(length / 2)
        nums = merge(sort_merge(nums[:mid]), sort_merge(nums[mid:]))
    return nums


def sort_merge(nums):
    nums = sort_merge1(nums)


def sort_shell(nums):
    n = len(nums)
    gap = n // 2
    while gap > 0:
        for i in range(gap, n):
            intern = nums[i]
            j = i
            while j >= gap and nums[j - gap] > intern:
                nums[j] = nums[j - gap]
                j -= gap
            nums[j] = intern
        gap /= 2
        gap = int(gap)


def sort_radix(nums):
    for i in range(1, len(str(max(nums))) + 1):
        table = [[] for f in range(0, 10)]
        for y in nums:
            table[int((y / pow(10, i)) % 10)].append(y)
        index = 0
        for y in table:
            for o in range(0, len(y)):
                nums[index] = y[o]
                index += 1


def sort_count(nums):
    max_val = max(nums) + 1
    inter = [0] * (max_val + 1)
    for a in nums:
        inter[a] += 1
    i = 0
    for a in range(max_val):
        for c in range(inter[a]):
            nums[i] = a
            i += 1
    return nums


def tim_sort(nums):
    nums.sort()


def millis():
    return _time()


if __name__ == '__main__':
    main()