pip install numpy  

 import numpy as np

 x = np.array([[range(16, 12, -1), range(12, 8, -1), range(8, 4, -1)], [range(12, 8, -1), range(8, 4, -1), range(4, 0, -1)]])

 print(x)

 print(x.shape)

 print('----------------')

 print(np.sort(x, axis=None))

 print('----------------')

 print(np.sort(x, axis=0))

 print('----------------')

 print(np.sort(x, axis=1))

 print('----------------')

 print(np.sort(x, axis=-1))

 import numpy as np

 # Change type, all the elements in array should be in same type.

 matrix = np.array([1, 2, 3, 4])

 print(matrix, matrix.dtype)         # [1 2 3 4] int32

 matrix = np.array([1, 2, 3, 4.0])

 print(matrix, matrix.dtype)         # [ 1.  2.  3.  4.] float64

 matrix = np.array([1, 2, 3, ''])

 print(matrix, matrix.dtype)         # ['1' '2' '3' '4'] <U11

 # Basic slice operation

 matrix = np.array([[1, 2, 3, 4],

              [5, 6, 7, 8],

              [9, 10, 11, 12],

              [13, 14, 15, 16]])

 # Get number certain element(7), [row, column]

 print(matrix[1,2])          #

 # Get all row and column 3

 print(matrix[:, 2])         # [3 7 11 15]

 # Get certain row and column, not contains the max number

 print(matrix[0:3, 0:2])     ''' [[ 1  2]

                                  [ 5  6]

                                  [ 9 10]] '''

 # Get the number by certain list

 # (0,0),(1,1),(2,2),(3,3)

 print(matrix[[0, 1, 2, 3], [0, 1, 2, 3]])   # [1 6 11 16]

 # Use range method can make it too

 print(matrix[range(4), range(4)])           # [1 6 11 16]

 # Operation to array will act to each element

 equal_to_seven = (matrix == 7)

 print(equal_to_seven)       ''' [[False False False False]

                                  [False False  True False]

                                  [False False False False]

                                  [False False False False]] '''

 # equal_to_seven can be use as an index, True/False list also can do so

 print(matrix[equal_to_seven])       # [7]

 get_certain_row = [False, True, True, False]

 print(matrix[get_certain_row])      ''' [[ 5  6  7  8]

                                          [ 9 10 11 12]] '''

 # Fetch row where the certain number in

 matrix = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

 print(matrix[matrix[:, 2] == 7])    # [[5 6 7 8]]

 vector = np.array([5, 10, 15, 20])

 # Find the element equal to ten and five(impossible)

 equal_to_ten_and_five = (vector == 5) & (vector == 10)

 print(vector[equal_to_ten_and_five])                    # []

 # Find the element equal to ten or five

 equal_to_ten_or_five = (vector == 5) | (vector == 10)

 print(vector[equal_to_ten_or_five])                     # [5 10]

 # Change equal one to other number

 vector[equal_to_ten_or_five]=50

 print(vector)                                           # [50 50 15 20]

 # Change the type of array

 vector = np.array(['', '', ''])

 print(vector.dtype, vector)     # <U1 ['1' '2' '3']

 new_vector = vector.astype(int)

 print(new_vector.dtype, new_vector)     # int32 [1 2 3]

 # Get the min number

 # Use print(help(np.array))

 vector = np.array([5, 10, 15, 20])

 print(vector.min())     #

 # Calculate the sum in certain dimension

 # 1 for cal sum in row, 0 for cal sum in column

 matrix = np.array([[1, 2, 3, 4],

              [5, 6, 7, 8],

              [9, 10, 11, 12],

              [13, 14, 15, 16]])

 print(matrix.sum(axis=1))   # [10 26 42 58]

 print(matrix.sum(axis=0))   # [28 32 36 40]

 import numpy as np

 # The simple assignments make no copy, a and b are two names for one same ndarray object

 a = np.arange(12)

 b = a

 print(b is a) # True

 b.shape = (3, 4)

 print(a.shape) # (3, 4)

 # a and b with same id

 print(id(a))

 print(id(b))

 # The view method creates a new array obj that share with same source data

 a = np.arange(12)

 c = a.view()

 print(c is a) # False

 # Change the shape of c will not change the shape of a

 c.shape = (2, 6)

 print(a.shape) # (12, )

 # But Change the data of c will change the data of a

 c[1, 2] = 1111

 print(a)

 # a and b with different id

 print(id(a))

 print(id(b))

 # The copy method makes a complete copy of array and its data

 a = np.arange(12)

 d = a.copy()

 print(d is a) # False

 import numpy as np

 a = np.array([20, 30, 40, 50])

 b = np.arange(4)

 # For (matrix - matrix) will operate for each corresponding elements

 # Different shape can not be subtracted unless only one element

 c = a - b

 print(c)    # [20 29 38 47]

 # For (matrix (-/'**'/'<') number) will operate for each elements

 c -= 1

 print(c)    # [19 28 37 46]

 b = b**2 # (b*b)

 print(b) # [0, 1, 4, 9]

 print(a<35) # [True, True, False, False]

 # * will multiply each element in corresponding position

 # dot will act the dot multiply for matrix(by using matrix_1.dot(matrix_2) or np.dot(matrix_1, matrix_2))

 x = np.array([[1, 1],

               [0, 1]])

 y = np.array([[2, 0],

               [3, 4]])

 print(x*y)  '''[[2 0]

                 [0 4]] '''

 print('-------')

 print(x.dot(y))     '''[[5 4]

                         [3 4]] '''

 print('-------')

 print(np.dot(x, y)) '''[[5 4]

                         [3 4]]'''

 # exp function to cal e^x for x in matrix

 # sqrt function to cal sqrt(x) for x in matrix

 m = np.arange(3)

 print(m)    # [0 1 2]

 print(np.exp(m))    # [ 1.          2.71828183  7.3890561 ]

 print(np.sqrt(m))   # [ 0.          1.          1.41421356]

 # floor/ceil function to round(down/up) number of each matrix

 x = 10*np.random.random((3, 4))

 print(x)    '''[[ 6.69732597  1.18238851  4.10109987  6.40797969]

                 [ 6.50193132  2.58724942  5.25748965  2.58338795]

                 [ 0.2798712   7.89760089  6.03544519  1.5176369 ]] '''

 print('-------')

 y = np.floor(x)

 print(y)     '''[[ 6.  1.  4.  6.]

                  [ 6.  2.  5.  2.]

                  [ 0.  7.  6.  1.]] '''

 print('-------')

 z = np.ceil(x)

 print(z)    ''' [[ 7.  2.  5.  7.]

                  [ 7.  3.  6.  3.]

                  [ 1.  8.  7.  2.]] '''

 # ravel function can flatten a matrix into vector

 print(y.ravel())    # [ 6.  1.  4.  6.  6.  2.  5.  2.  0.  7.  6.  1.]

 # Shape value can change shape too

 y.shape = (6, 2)

 print(y)    ''' [[ 6.  1.]

                  [ 4.  6.]

                  [ 6.  2.]

                  [ 5.  2.]

                  [ 0.  7.]

                  [ 6.  1.]] '''

 print('-------')

 # T property function

 print(y.T)  ''' [[ 6.  4.  6.  5.  0.  6.]

                  [ 1.  6.  2.  2.  7.  1.]] '''

 print('-------')

 # If a dimension is given as -1, this dimension will be calculated automatically

 print(y.reshape(6, -1)) ''' [[ 6.  1.]

                              [ 4.  6.]

                              [ 6.  2.]

                              [ 5.  2.]

                              [ 0.  7.]

                              [ 6.  1.]] '''

 # hstack/vstack function can stack the matrix in h/v direction

 a = np.arange(6).reshape(2, 3)

 b = np.arange(6).reshape(2, 3)

 print(np.hstack((a, b))) '''[[0 1 2 0 1 2]

                              [3 4 5 3 4 5]] '''

 print(np.vstack((a, b))) '''[[0 1 2]

                              [3 4 5]

                              [0 1 2]

                              [3 4 5]] '''

 # hsplit/vsplit function can split the matrix in h/v direction

 x = np.arange(30).reshape(2, -1)

 print(x)    ''' [[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]

                  [15 16 17 18 19 20 21 22 23 24 25 26 27 28 29]] '''

 # Split into 3 part (h direction, from one (2, 15) matrix to three (2, 5) matrixes)

 print(np.hsplit(x, 3))  '''[array([[ 0,  1,  2,  3,  4],

                                    [15, 16, 17, 18, 19]]),

                             array([[ 5,  6,  7,  8,  9],

                                    [20, 21, 22, 23, 24]]),

                             array([[10, 11, 12, 13, 14],

                                    [25, 26, 27, 28, 29]])] '''

 # Split in certain loction (split the matrix in location(after) column 3 and column 4)

 print(np.hsplit(x, (3, 4))) '''[array([[ 0,  1,  2],

                                        [15, 16, 17]]),

                                 array([[ 3],

                                        [18]]),

                                 array([[ 4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14],

                                        [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]])] '''

 # Split into 3 part (v direction, from one (2, 15) matrix to two (1, 15) matrixes)

 print(np.vsplit(x, 2))  ''' [array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14]]),

                              array([[15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]])] '''

 # Fetch the max value position by row/column

 data = np.random.random((5, 4))

 print(data) ''' [[ 0.65419205  0.75953852  0.89856871  0.96162281]

                  [ 0.76341568  0.10488636  0.06186101  0.27698986]

                  [ 0.73737843  0.75305691  0.28705743  0.45542513]

                  [ 0.5534984   0.54420756  0.86250921  0.596653  ]

                  [ 0.24295898  0.28894731  0.58726507  0.39418991]] '''

 # argmax/argmin function can get the max/min value index by row/column

 index = data.argmax(axis=0)

 print(index)    # [1 0 0 0]

 # Get the max value by position

 # data.shape[1] to get the number of column

 print(data[index, range(data.shape[1])])    # [ 0.76341568  0.75953852  0.89856871  0.96162281]

 # Extend the matrix(like tile does)

 x = np.arange(0, 40, 10)

 print(x)    # [ 0 10 20 30]

 # tile(x, (a, b)) can change origin shape(c, d) --> (a*c, b*d)

 y = np.tile(x, (3, 5))

 print(y)    ''' [[ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]

                  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]

                  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]] '''

 print(y.shape) # (3, 20)

 # Sort the array

 x = np.array([[4, 3, 5], [1, 2, 1]])

 print(x)    '''[[4 3 5]

                 [1 2 1]] '''

 print('--------')

 # Sort the number by row/column

 y = np.sort(x, axis=1)

 print(y)    '''[[3 4 5]

                 [1 1 2]] '''

 print('--------')

 x.sort(axis=1)

 print(x)    '''[[3 4 5]

                 [1 1 2]] '''

 print('--------')

 # argsort can return the sorted index list

 x = np.array([4, 3, 1, 2])

 y = np.argsort(x)

 print(y) # [2, 3, 1, 0] min is 1, index=2, then num 2, index is 3, num 3,index is 1, max is 4, index=0

 # Use the sorted index list to fetch value

 print('--------')

 print(x[y]) # [1, 2, 3, 4]

 import numpy as np

 # Build a matrix, shape is (2, 4, 2)

 matrix = np.array([[[1,2], [2,3], [3,4], [4,5]],

                     [[1,2], [2,3], [3,4], [4,5]]])

 # arange function to quickly create an array(vector)

 # Note: the shape is (x, ), one dimension array

 vector = np.arange(15)

 print(vector)   # [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]

 # reshape function to reshape an array

 matrix = vector.reshape(3, 5)

 print(matrix)   ''' [[ 0  1  2  3  4]

                      [ 5  6  7  8  9]

                      [10 11 12 13 14]] '''

 # shape is the row&column of matrix(array) - (3, 5)

 # ndim is the number of dimensions(axes) of matrix - 2

 # dtype is a numpy class, dtype.name is the type name of matrix - int32

 # size is the total number of elements of matrix - 15

 print(matrix.shape, matrix.ndim, matrix.dtype.name, matrix.size) # (3, 5) 2 int32 15

 # arrange(from, to, step)

 vector = np.arange(10, 30, 5)

 print(vector)   # [10 15 20 25]

 vector = np.arange(1, 3, 0.5)

 print(vector)   # [ 1.   1.5  2.   2.5]

 # Init a matrix with all elements 0, default type is float64

 matrix = np.zeros((3, 4), dtype=np.float64)

 print(matrix)   ''' [[ 0.  0.  0.  0.]

                      [ 0.  0.  0.  0.]

                      [ 0.  0.  0.  0.]] '''

 # Init a matrix with all elements 1

 matrix = np.ones((2, 3, 4), dtype=np.int32)

 print(matrix)   ''' [[[1 1 1 1]

                       [1 1 1 1]

                       [1 1 1 1]]

                      [[1 1 1 1]

                       [1 1 1 1]

                       [1 1 1 1]]]'''

 # random function will return a matrix with random number(between 0 to 1)

 # random((row, column))

 rd = np.random.random((2, 3))

 print(rd)   ''' [[ 0.45595053  0.69816822  0.30391984]

                  [ 0.22757757  0.725762    0.84856338]] '''

 # Get the matrix with some same step numbers,

 # 得到相应数量的等差数列

 # linspace(from, to, number)

 # Notice whether the num should be plus one

 matrix = np.linspace(0, 2, 11)

 print(matrix)   # [ 0.   0.2  0.4  0.6  0.8  1.   1.2  1.4  1.6  1.8  2. ]

 # sin/cos function can calculate the sin/cos of each elements

 from numpy import pi

 matrix = np.linspace(0, 2*pi, 9)

 print(matrix)   # [ 0.          0.78539816  1.57079633  2.35619449  3.14159265  3.92699082  4.71238898  5.49778714  6.28318531]

 matrix = np.sin(matrix)

 print(matrix)   # [  0.00000000e+00   7.07106781e-01   1.00000000e+00   7.07106781e-01   1.22464680e-16  -7.07106781e-01  -1.00000000e+00  -7.07106781e-01  -2.44929360e-16]