Python的工具包[0] -> numpy科学计算 -> numpy 库及使用总结

1 import numpy as np
2 
3 # Change type, all the elements in array should be in same type.
4 matrix = np.array([1, 2, 3, 4])
5 print(matrix, matrix.dtype)         # [1 2 3 4] int32
6 matrix = np.array([1, 2, 3, 4.0])
7 print(matrix, matrix.dtype)         # [ 1.  2.  3.  4.] float64
8 matrix = np.array([1, 2, 3, '4'])
9 print(matrix, matrix.dtype)         # ['1' '2' '3' '4'] <U11

 1 # Basic slice operation
 2 matrix = np.array([[1, 2, 3, 4],
 3              [5, 6, 7, 8],
 4              [9, 10, 11, 12],
 5              [13, 14, 15, 16]])
 6 # Get number certain element(7), [row, column]
 7 print(matrix[1,2])          # 7
 8 # Get all row and column 3
 9 print(matrix[:, 2])         # [3 7 11 15]
10 # Get certain row and column, not contains the max number
11 print(matrix[0:3, 0:2])     ''' [[ 1  2]
12                                  [ 5  6]
13                                  [ 9 10]] '''

1 # Get the number by certain list
2 # (0,0),(1,1),(2,2),(3,3)
3 print(matrix[[0, 1, 2, 3], [0, 1, 2, 3]])   # [1 6 11 16]
4 # Use range method can make it too
5 print(matrix[range(4), range(4)])           # [1 6 11 16]

 1 # Operation to array will act to each element
 2 equal_to_seven = (matrix == 7)
 3 print(equal_to_seven)       ''' [[False False False False]
 4                                  [False False  True False]
 5                                  [False False False False]
 6                                  [False False False False]] '''
 7 
 8 # equal_to_seven can be use as an index, True/False list also can do so
 9 print(matrix[equal_to_seven])       # [7]
10 get_certain_row = [False, True, True, False]
11 print(matrix[get_certain_row])      ''' [[ 5  6  7  8]
12                                          [ 9 10 11 12]] '''
13 # Fetch row where the certain number in
14 matrix = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
15 print(matrix[matrix[:, 2] == 7])    # [[5 6 7 8]]
16 
17 vector = np.array([5, 10, 15, 20])
18 # Find the element equal to ten and five(impossible)
19 equal_to_ten_and_five = (vector == 5) & (vector == 10)
20 print(vector[equal_to_ten_and_five])                    # []
21 # Find the element equal to ten or five
22 equal_to_ten_or_five = (vector == 5) | (vector == 10)   
23 print(vector[equal_to_ten_or_five])                     # [5 10]
24 # Change equal one to other number
25 vector[equal_to_ten_or_five]=50
26 print(vector)                                           # [50 50 15 20]

1 # Change the type of array
2 vector = np.array(['1', '2', '3'])
3 print(vector.dtype, vector)     # <U1 ['1' '2' '3']
4 new_vector = vector.astype(int)
5 print(new_vector.dtype, new_vector)     # int32 [1 2 3]

 1 # Get the min number
 2 # Use print(help(np.array))
 3 vector = np.array([5, 10, 15, 20])
 4 print(vector.min())     # 5
 5 
 6 # Calculate the sum in certain dimension
 7 # 1 for cal sum in row, 0 for cal sum in column
 8 matrix = np.array([[1, 2, 3, 4],
 9              [5, 6, 7, 8],
10              [9, 10, 11, 12],
11              [13, 14, 15, 16]])
12 print(matrix.sum(axis=1))   # [10 26 42 58]
13 print(matrix.sum(axis=0))   # [28 32 36 40]

 1 import numpy as np
 2 
 3 # The simple assignments make no copy, a and b are two names for one same ndarray object
 4 a = np.arange(12)
 5 b = a 
 6 print(b is a) # True
 7 b.shape = (3, 4)
 8 print(a.shape) # (3, 4)
 9 # a and b with same id
10 print(id(a))
11 print(id(b))
12 
13 # The view method creates a new array obj that share with same source data
14 a = np.arange(12)
15 c = a.view()
16 print(c is a) # False
17 # Change the shape of c will not change the shape of a
18 c.shape = (2, 6)
19 print(a.shape) # (12, )
20 # But Change the data of c will change the data of a 
21 c[1, 2] = 1111
22 print(a)
23 # a and b with different id
24 print(id(a))
25 print(id(b))
26 
27 # The copy method makes a complete copy of array and its data
28 a = np.arange(12)
29 d = a.copy()
30 print(d is a) # False

  1 import numpy as np
  2 
  3 a = np.array([20, 30, 40, 50])
  4 b = np.arange(4)
  5 # For (matrix - matrix) will operate for each corresponding elements
  6 # Different shape can not be subtracted unless only one element
  7 c = a - b
  8 print(c)    # [20 29 38 47]
  9 # For (matrix (-/'**'/'<') number) will operate for each elements 
 10 c -= 1
 11 print(c)    # [19 28 37 46]
 12 b = b**2 # (b*b)
 13 print(b) # [0, 1, 4, 9]
 14 print(a<35) # [True, True, False, False]
 15 
 16 # * will multiply each element in corresponding position
 17 # dot will act the dot multiply for matrix(by using matrix_1.dot(matrix_2) or np.dot(matrix_1, matrix_2))
 18 x = np.array([[1, 1],
 19               [0, 1]])
 20 y = np.array([[2, 0],
 21               [3, 4]])
 22 print(x*y)  '''[[2 0]
 23                 [0 4]] '''
 24 print('-------')
 25 print(x.dot(y))     '''[[5 4]
 26                         [3 4]] '''
 27 
 28 print('-------')
 29 print(np.dot(x, y)) '''[[5 4]
 30                         [3 4]]'''
 31 
 32 # exp function to cal e^x for x in matrix
 33 # sqrt function to cal sqrt(x) for x in matrix
 34 m = np.arange(3)
 35 print(m)    # [0 1 2]
 36 print(np.exp(m))    # [ 1.          2.71828183  7.3890561 ]
 37 print(np.sqrt(m))   # [ 0.          1.          1.41421356]
 38 
 39 # floor/ceil function to round(down/up) number of each matrix
 40 x = 10*np.random.random((3, 4))
 41 print(x)    '''[[ 6.69732597  1.18238851  4.10109987  6.40797969]
 42                 [ 6.50193132  2.58724942  5.25748965  2.58338795]
 43                 [ 0.2798712   7.89760089  6.03544519  1.5176369 ]] '''
 44 print('-------')
 45 y = np.floor(x)
 46 print(y)     '''[[ 6.  1.  4.  6.]
 47                  [ 6.  2.  5.  2.]
 48                  [ 0.  7.  6.  1.]] '''
 49 print('-------')
 50 z = np.ceil(x)
 51 print(z)    ''' [[ 7.  2.  5.  7.]
 52                  [ 7.  3.  6.  3.]
 53                  [ 1.  8.  7.  2.]] '''
 54 
 55 # ravel function can flatten a matrix into vector
 56 print(y.ravel())    # [ 6.  1.  4.  6.  6.  2.  5.  2.  0.  7.  6.  1.]
 57 # Shape value can change shape too
 58 y.shape = (6, 2)
 59 print(y)    ''' [[ 6.  1.]
 60                  [ 4.  6.]
 61                  [ 6.  2.]
 62                  [ 5.  2.]
 63                  [ 0.  7.]
 64                  [ 6.  1.]] '''
 65 print('-------')
 66 # T property function
 67 print(y.T)  ''' [[ 6.  4.  6.  5.  0.  6.]
 68                  [ 1.  6.  2.  2.  7.  1.]] '''
 69 print('-------')
 70 # If a dimension is given as -1, this dimension will be calculated automatically
 71 print(y.reshape(6, -1)) ''' [[ 6.  1.]
 72                              [ 4.  6.]
 73                              [ 6.  2.]
 74                              [ 5.  2.]
 75                              [ 0.  7.]
 76                              [ 6.  1.]] '''
 77 
 78 # hstack/vstack function can stack the matrix in h/v direction
 79 a = np.arange(6).reshape(2, 3)
 80 b = np.arange(6).reshape(2, 3)
 81 print(np.hstack((a, b))) '''[[0 1 2 0 1 2]
 82                              [3 4 5 3 4 5]] '''
 83 print(np.vstack((a, b))) '''[[0 1 2]
 84                              [3 4 5]
 85                              [0 1 2]
 86                              [3 4 5]] '''
 87 
 88 # hsplit/vsplit function can split the matrix in h/v direction
 89 x = np.arange(30).reshape(2, -1)
 90 print(x)    ''' [[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
 91                  [15 16 17 18 19 20 21 22 23 24 25 26 27 28 29]] '''
 92 # Split into 3 part (h direction, from one (2, 15) matrix to three (2, 5) matrixes)
 93 print(np.hsplit(x, 3))  '''[array([[ 0,  1,  2,  3,  4],
 94                                    [15, 16, 17, 18, 19]]),
 95                             array([[ 5,  6,  7,  8,  9],
 96                                    [20, 21, 22, 23, 24]]),
 97                             array([[10, 11, 12, 13, 14],
 98                                    [25, 26, 27, 28, 29]])] '''
 99 # Split in certain loction (split the matrix in location(after) column 3 and column 4)
100 print(np.hsplit(x, (3, 4))) '''[array([[ 0,  1,  2],
101                                        [15, 16, 17]]),
102                                 array([[ 3],
103                                        [18]]),
104                                 array([[ 4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14],
105                                        [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]])] '''
106 # Split into 3 part (v direction, from one (2, 15) matrix to two (1, 15) matrixes)
107 print(np.vsplit(x, 2))  ''' [array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14]]),
108                              array([[15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]])] '''
109 
110 # Fetch the max value position by row/column
111 data = np.random.random((5, 4))
112 print(data) ''' [[ 0.65419205  0.75953852  0.89856871  0.96162281]
113                  [ 0.76341568  0.10488636  0.06186101  0.27698986]
114                  [ 0.73737843  0.75305691  0.28705743  0.45542513]
115                  [ 0.5534984   0.54420756  0.86250921  0.596653  ]
116                  [ 0.24295898  0.28894731  0.58726507  0.39418991]] '''
117 # argmax/argmin function can get the max/min value index by row/column
118 index = data.argmax(axis=0)
119 print(index)    # [1 0 0 0]
120 # Get the max value by position
121 # data.shape[1] to get the number of column
122 print(data[index, range(data.shape[1])])    # [ 0.76341568  0.75953852  0.89856871  0.96162281]
123 
124 # Extend the matrix(like tile does)
125 x = np.arange(0, 40, 10)
126 print(x)    # [ 0 10 20 30]
127 # tile(x, (a, b)) can change origin shape(c, d) --> (a*c, b*d)
128 y = np.tile(x, (3, 5))
129 print(y)    ''' [[ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
130                  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
131                  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]] '''
132 print(y.shape) # (3, 20)
133 
134 # Sort the array
135 x = np.array([[4, 3, 5], [1, 2, 1]])
136 print(x)    '''[[4 3 5]
137                 [1 2 1]] '''
138 print('--------')
139 # Sort the number by row/column
140 y = np.sort(x, axis=1)
141 print(y)    '''[[3 4 5]
142                 [1 1 2]] '''
143 print('--------')
144 x.sort(axis=1)
145 print(x)    '''[[3 4 5]
146                 [1 1 2]] '''
147 print('--------')
148 # argsort can return the sorted index list
149 x = np.array([4, 3, 1, 2])
150 y = np.argsort(x)
151 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
152 # Use the sorted index list to fetch value
153 print('--------')
154 print(x[y]) # [1, 2, 3, 4]