Why does my sorting algo with numpy arrayw work slower than with lists?

I was trying to sort a list with sequential bitonic sort and wanted to make it faster by sorting a numpy array instead of a list, but it only became slower. What did I do wrong?

Here is sorting algo:

from datetime import datetime
import numpy as np


def compAndSwap(a, i, j, dire):
    if (dire == 1 and a[i] > a[j]) or (dire == 0 and a[i] < a[j]):
        a[i], a[j] = a[j], a[i]


def bitonicMerge(a, low, cnt, dire):
    if cnt > 1:
        k = cnt // 2
        for i in range(low, low + k):
            compAndSwap(a, i, i + k, dire)
        bitonicMerge(a, low, k, dire)
        bitonicMerge(a, low + k, k, dire)


def bitonicSort(a, low, cnt, dire):
    if cnt > 1:
        k = cnt // 2
        bitonicSort(a, low, k, 1)
        bitonicSort(a, low + k, k, 0)
        bitonicMerge(a, low, cnt, dire)


def sort_(a, N, up):
    bitonicSort(a, 0, N, up)

And here is part when run this algo for list:

with open('data.txt') as f:
    
    line = f.readline()
    a = line[1:-2].split(', ')
    a = list(map(int, a))


n = len(a)

up = 1

time1 = datetime.now()

sort_(a, n, up)

time2 = datetime.now()


print("\nCurrent Time =", time2-time1)

And here is for numpy array:

with open('data.txt') as f:
    line = f.readline()
    a = np.array(line[1:-2].split(', ')).astype('int32')


n = a.size
up = 1

time1 = datetime.now()

sort_(a, n, up)

time2 = datetime.now()

print("\nCurrent Time =", time2-time1)

What did I miss?

You got numpy wrong. Numpy is actually a scientific computing package that is best suited for performing vectorized operations, such as array multiplications. It's not optimized for accessing individual items in an array one at a time.

If you try this simple test:

data = np.random.randint(0, 10000, 1000000)
a = data.tolist()

then measure the time taken by a simple loop without any additional operations.:

%timeit for i in range(data.shape[0]): _ = data[i] # 145 ms ± 50.7 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Do the same for the list:

%timeit for i in range(len(a)): _ = a[i] # 85.1 ms ± 28.2 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

You observe that accessing an item in a numpy array takes more time.

However, utilizing the pre-optimized functions from the numpy library can lead to a significant difference in performance.

%timeit np.sort(data, kind='mergesort') # 100 ms ± 11.5 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

while if you used sorted on a list

%timeit sorted(a) # 449 ms ± 69.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

This comparison is not be accurate since sorted utilizes timsort, which is a modified version of mergesort. Nevertheless, the difference in performance will still be substantial.