NumPy arrays are stored at one continuous place in memory unlike lists, so processes can access and manipulate them very efficiently.
This behavior is called locality of reference in computer science.
This is the main reason why NumPy is faster than lists. Also it is optimized to work with latest CPU architectures

C:\Users\Your Name>pip install numpy

import numpy
arr = numpy.array([1,2,3,4,5])
print(arr)

import numpy as np
arr = np.array([1,2,3,4,5])
print(arr)

import numpy as np

a = np.array(42)
b = np.array([1, 2, 3, 4, 5])
c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])

#how many dimension appear in each line
print(a.ndim) #0
print(b.ndim) #1
print(c.ndim) #2
print(d.ndim) #3

#Access array element
import numpy as np
num = np.array([2, 4, 5, 7])

print(num[0]) #access the first element:2
print(num[2] + num[3]) #Summation: 12

#Access 2-D array
import numpy as np
num = np.array([[2, 3, 4], [5, 1, 6]])
print(num[1, 2]) #3rd element on 2nd row so 6

#Access 3-D array
import numpy as np
num = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]])
print(num[0, 0, 1]) #2

#Negative indexing
import numpy as np
num = np.array([[2, 4, 1], [3, 5, 6]])
print(num[1, -1]) #6

[3, -2, -1, 0, 2, 4, 1]
at the first i take
pivot 1:
3 > 1, -2 < 1, -1 < 1, 0 < 1, 2 > 1, 4 > 1
then elements smaller that 1 are -2, -1, 0
elements greater than 1 are 3, 2, 4
and then [-2,-1,0] 1 [3, 2, 4]

now what i've to do is to arrange elements smaller than 1 as a pivot take 0
pivot 0: -2 < 0, -1 < 0 They're ordered
Know elements up to 1 are ordered:[-2, -1, 0, 1]
the next is to sort elements right of 1: those are [3, 2, 4]
as a pivot take 4:
3 < 4, 2 < 4 : [3, 2] 4 []
and know take 2 as a pivot: 3 > 2: then [] 2 [3]
combine the process right of 1: ->>[2, 3, 4] Done
now combine the elements left of 1: [-2, -1, 0, 1]

COMBINE ALL OF THEM: [-2, -1, 0, 1, 2, 3, 4] done
I understand in this way

""""
compare numbers with pivot
group them
sort left
sort right
combine

Average time: O(n log n)
""""