A Concise NumPy tutorial --- array 2

This article mainly introduces the simple NumPy tutorial-array 2, which has some reference value. if you are interested, you can refer to it. NumPy array (2. Array Operations)

Basic operations

Array arithmetic operations are performed by elements one by one. After the array operation, a new array containing the operation result will be created.

>>> a= np.array([20,30,40,50]) >>> b= np.arange( 4) >>> b array([0, 1, 2, 3]) >>> c= a-b >>> c array([20, 29, 38, 47]) >>> b**2 array([0, 1, 4, 9]) >>> 10*np.sin(a) array([ 9.12945251,-9.88031624, 7.4511316, -2.62374854]) >>> a<35 array([True, True, False, False], dtype=bool)

Unlike other matrix languages, the multiplication operator * in NumPy is calculated one by one based on elements. The dot function or the matrix object can be used for matrix multiplication (will be introduced in subsequent chapters)

>>> A = np. array ([[1, 1],... [0, 1])> B = np. array ([2, 0],... [3, 4]) >>> A * B # multiply elements by array ([[2, 0], [0, 4]) >>> np. dot (A, B) # multiply the matrix by array ([[5, 4], [3, 4])

Some operators such as + = and * = are used to change an existing array without creating a new array.

>>> A = np. ones (2, 3), dtype = int) >>> B = np. random. random (2, 3) >>> a * = 3 >>> a array ([[3, 3, 3], [3, 3, 3]) >>> B + = a >>> B array ([[3.69092703, 3.8324276, 3.0114541], [3.18679111, 3.3039349, 3.37600289]) >>> a + = B # B to integer type >>> a array ([[6, 6, 6], [6, 6, 6])

When an array stores different types of elements, the array uses the data type that occupies more bits as its own data type, that is, the data type tends to be more precise (this behavior is called upcast ).

>>> a= np.ones(3, dtype=np.int32) >>> b= np.linspace(0,np.pi,3) >>> b.dtype.name 'float64' >>> c= a+b >>> c array([ 1., 2.57079633, 4.14159265]) >>> c.dtype.name 'float64' >>> d= exp(c*1j) >>> d array([ 0.54030231+0.84147098j,-0.84147098+0.54030231j,   　　　 -0.54030231-0.84147098j]) >>> d.dtype.name 'complex128'

Many non-array operations, such as calculating the sum of all elements of an array, are implemented as methods of The ndarray class. these methods need to be called by instances of The ndarray class during use.

>>> a= np.random.random((2,3)) >>> a array([[ 0.65806048, 0.58216761, 0.59986935],       [ 0.6004008, 0.41965453, 0.71487337]]) >>> a.sum() 　 3.5750261436902333 >>> a.min()    0.41965453489104032 >>> a.max()    0.71487337095581649

These operations regard arrays as a one-dimensional linear list. However, you can perform operations on the specified axis by specifying the axis parameter (that is, the row of the array:

>>> B = np. arange (12 ). reshape (3, 4) >>> B array ([0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11])> B. sum (axis = 0) # calculate the sum of each column, pay attention to understanding the meaning of the axis, refer to the first article of the array ([12, 15, 18, 21]) >>> B. min (axis = 1) # obtain the minimum value of each row array ([0, 4, 8])> B. cumsum (axis = 1) # Calculate the accumulation and array of each row ([0, 1, 3, 6], [4, 9, 15, 22], [8, 17, 27, 38])

Indexing, slicing, and iteration

Like the list and other Python sequences, one-dimensional arrays can be indexed, sliced, and iterated.

>>> A = np. arange (10) ** 3 # Remember, operators are processed by element in the array! >>> A array ([0, 1, 8, 27, 64,125,216,343,512,729]) >>> a [2] 8 >>> a [] array ([8, 27, 64]) >>> a [: 6: 2] =-1000 # equivalent to a [] =-1000, starting from 6th, assign a value to each element as-1000 >>>> a array ([-1000, 1,-1000, 27,-1000,125,216,343,512,729]) >>> [:: -1] # invert a array ([729,512,343,216,125,-1000, 27,-1000, 1,-1000]) >>> for I in :... print I ** (1/3 .),... nan 1.0 nan 3.0 nan 5.0 6.0 7.0 8.0

Multi-dimensional arrays can have an index for each axis. These indexes are given by a comma-separated tuples.

>>> Def f (x, y ):... return 10 * x + y...> B = np. fromfunction (f, (5, 4), dtype = int) # fromfunction is a function, which will be introduced in the next article. >>> B array ([0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23], [30, 31, 32, 33], [40, 41, 42, 43]) >>> B [2, 3] 23 >>> B [0: 5, 1] # array ([1, 11, 21, 31, 41])> B [:, 1] # the same effect as the previous one. array ([1, 11, 21, 31, 41]) >>> B [,:] # array ([10, 11, 12, 13], [20, 21, 22, 23])

When less than the number of provided indexes is less than the number of axes, the given values are replicated in the order of rank. if the index is incorrect, the entire slice is used by default:

>>> B [-1] # The last line is equivalent to B [-1,:], and-1 is the first axis. what is missing is:, which is equivalent to the whole slice. Array ([40, 41, 42, 43])

The expressions in B [I] are treated as I and a series:, to represent the remaining Axis. NumPy also allows you to use "points" like B [I,...].

Point (...) Represents the semicolon necessary for many to generate a complete index tuples. If x is an array with a rank of 5 (that is, it has five axes), then:

• X [1, 2,…] Equivalent to x [1, 2,:,:],

• X [..., 3] is equivalent to x [:, 3].

• X [4 ,..., 5,:] is equivalent to x [4,:,:, 5,:]

>>> C = array ([[0, 1, 2], # 3D array (composed of two 2-dimensional arrays )... [10, 12, 13],... [[100,101,102],... [110,112,113])> c. shape (2, 2, 3) >>> c [1,...] # equivalent to c [1,:,:] or c [1] array ([[100,101,102], [110,112,113])> c [..., 2] # equivalent to c [:,:, 2] array ([2, 13], [102,113])

Multi-dimensional array traversal is based on the first axis:

>>>for row in b: ...  print row ... [0 1 2 3] [10 11 12 13] [20 21 22 23] [30 31 32 33] [40 41 42 43]

If you want to process each element in the array, you can use the flat attribute, which is an array element iterator:

>>>for element in b.flat: ...  print element, ... 0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43

Shape operation

Change the array shape

The array shape depends on the number of elements on each axis:

>>> a= np.floor(10*np.random.random((3,4))) >>> a array([[ 7., 5., 9., 3.],       [ 7., 2., 7., 8.],       [ 6., 8., 3., 2.]]) >>> a.shape (3, 4)

You can modify the shape of an array in multiple ways:

>>>. Ravel () # Flat array ([7 ., 5 ., 9 ., 3 ., 7 ., 2 ., 7 ., 8 ., 6 ., 8 ., 3 ., 2.]) >>> a. shape = (6, 2) >>>. transpose () array ([7 ., 9 ., 7 ., 7 ., 6 ., 3.], [5 ., 3 ., 2 ., 8 ., 8 ., 2.])

The order of array elements flattened by ravel () is usually "C style", that is, based on the behavior, the rightmost index is the fastest changed, therefore, after element a [0, 0], it is a [0, 1]. If the array is changed to another shape (reshape), the array is still "C style. NumPy usually creates an array that stores data in this order. Therefore, ravel () usually does not need to create a copy of the called array. However, if an array is sliced by another array or has unusual options, you may need to create a copy of it. You can also use some optional parameter functions to create a FORTRAN-style array for reshape () and ravel (), that is, the leftmost index changes the fastest.

The reshape function changes the called array shape and returns the array, while the resize function changes the called array itself.

>>> a array([[ 7., 5.],       [ 9., 3.],       [ 7., 2.],       [ 7., 8.],       [ 6., 8.],       [ 3., 2.]]) >>> a.resize((2,6)) >>> a array([[ 7., 5., 9., 3., 7., 2.],       [ 7., 8., 6., 8., 3., 2.]])

If you specify a dimension of-1 in the reshape operation, the precise dimension is calculated based on the actual situation.

The above is all the content of this article. I hope it will help you learn and support PHP.

For more details about NumPy, refer to articles on array 2!