1, Basic usage of Numpy array

1. Numpy is a Python scientific computing library used to quickly process arrays of arbitrary dimensions.

2. NumPy provides an N-dimensional array type ndarray, which describes a collection of "items" of the same type.

3. numpy.ndarray supports vectorization.

4. NumPy is written in c language, and the GIL is released at the bottom. Its operation speed on the array is no longer limited by the python interpreter.

2, Array in numpy:

The use of arrays in Numpy is very similar to lists in Python. The differences between them are as follows:

1. Multiple data types can be stored in a list. For example, a = [1,'a'] is allowed, while arrays can only store the same data type.

2. Arrays can be multidimensional. When all the data in multidimensional arrays are numerical types, they are equivalent to matrices in linear algebra and can operate on each other.

3, Create an array (np.ndarray object):

Numpy often deals with arrays, so the first step is to learn to create arrays. The data type of the array in numpy is called ndarray. Here are two ways to create:

1. Generated from lists in Python:

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

2. It is generated using np.arena. The usage of np.arena is similar to range in Python:

import numpy as np
a2 = np.arange(2,21,2)
print(a2)

3. Use np.random to generate an array of random numbers:

a1 = np.random.random(2,2) # Generates an array of random numbers with 2 rows and 2 columns
a2 = np.random.randint(0,10,size=(3,3)) # The element is a random array of 3 rows and 3 columns from 0 to 10

4. Use the function to generate a special array:

import numpy as np
a1 = np.zeros((2,2)) #Generate an array of 2 rows and 2 columns with all elements of 0
a2 = np.ones((3,2)) #Generate an array of 3 rows and 2 columns with all elements being 1
a3 = np.full((2,2),8) #Generate an array of 2 rows and 2 columns with all elements of 8
a4 = np.eye(3) #Generate a 3x3 matrix with element 1 and other elements 0 on the skew square

4, Common properties of ndarray:

ndarray.dtype:

Because the array can only store the same data type, you can get the data type of the elements in the array through dtype. The following are the common data types of ndarray.dtype:

data type	describe	Unique identifier
bool	Boolean type (True or False) stored in one byte	'b'
int8	One byte size, - 128 to 127	'i1'
int16	Integer, 16 bit integer (- 32768 ~ 32767)	'i2'
int32	Integer, 32-bit integer (- 2147483648 ~ 2147483647)	'i4'
int64	Integer, 64 bit integer (- 9223372036854775808 ~ 9223372036854775807)	'i8'
uint8	Unsigned integer, 0 to 255	'u1'
uint16	Unsigned integer, 0 to 65535	'u2'
uint32	Unsigned integer, 0 to 2 * * 32 - 1	'u4'
uint64	Unsigned integer, 0 to 2 * * 64 - 1	'u8'
float16	Semi precision floating point number: 16 bits, sign 1 bit, index 5 bits, precision 10 bits	'f2'
float32	Single precision floating point number: 32 bits, sign 1 bit, exponent 8 bits, precision 23 bits	'f4'
float64	Double precision floating point number: 64 bits, sign 1 bit, index 11 bits, precision 52 bits	'f8'
complex64	Complex number, which represents the real part and imaginary part with two 32-bit floating-point numbers respectively	'c8'
complex128	Complex numbers, representing the real part and imaginary part with two 64 bit floating-point numbers respectively	'c16'
object_	python object	'O'
string_	character string	'S'
unicode_	unicode type	'U'

We can see that Numpy has many more types of values than Python's built-in, because Numpy is designed to efficiently process massive data. For example, if we want to store tens of billions of numbers, and these numbers are no more than 254 (within one byte), we can set dtype to int8, which can save memory space more than using int64 by default. Type related operations are as follows:

1. Default data type:

import numpy as np
a1 = np.array([1,2,3])
print(a1.dtype) 
# If it is a windows system, the default is int32
# If it is a mac or linux system, it is determined according to the system

2. Designate

dtype: 

import numpy as np
a1 = np.array([1,2,3],dtype=np.int64)
# Or a1 = np.array([1,2,3],dtype="i8")
print(a1.dtype)

3. Modification

dtype: 

import numpy as np
a1 = np.array([1,2,3])
print(a1.dtype) # In the window system, the default is int32
# Modify dtype below
a2 = a1.astype(np.int64) # astype does not modify the array itself, but returns the modified result
print(a2.dtype)

ndarray.size:

Gets the total number of elements in the array. For example, there is a two-dimensional array:

   import numpy as np
   a1 = np.array([[1,2,3],[4,5,6]])
   print(a1.size) #6 is printed because there are a total of 6 elements

ndarray.ndim:

The dimension of the array. For example:

   a1 = np.array([1,2,3])
   print(a1.ndim) # Dimension is 1
   a2 = np.array([[1,2,3],[4,5,6]])
   print(a2.ndim) # Dimension is 2
   a3 = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
   print(a3.ndim) # Dimension is 3

ndarray.shape:

The tuple of the dimension of the array. For example, the following code:

   a1 = np.array([1,2,3])
   print(a1.shape) # Output (3,), which means a one-dimensional array with 3 data

   a2 = np.array([[1,2,3],[4,5,6]])
   print(a2.shape) # Output (2,3), which means a binary array, 2 rows and 3 columns

   a3 = np.array([
       [
           [1,2,3],
           [4,5,6]
       ],
       [
           [7,8,9],
           [10,11,12]
       ]
   ])
   print(a3.shape) # Output (2,2,3), which means a three-dimensional array. There are two elements in total, and each element has two rows and three columns

   a44 = np.array([1,2,3],[4,5])
   print(a4.shape) # Output (2,), which means a4 is a one-dimensional array with a total of 2 columns
   print(a4) # Output [list([1, 2, 3]) list([4, 5]), where the outermost layer is an array and the inner layer is a Python list

In addition, we can also modify the dimension of the array through ndarray.reshape. The example code is as follows:

   a1 = np.arange(12) #Generate a one-dimensional array with 12 data
   print(a1) 

   a2 = a1.reshape((3,4)) #It becomes a two-dimensional array with 3 rows and 4 columns
   print(a2)

   a3 = a1.reshape((2,3,2)) #Into a three-dimensional array, a total of 2 blocks, each block is 2 rows and 2 columns
   print(a3)

   a4 = a2.reshape((12,)) # Change the two-dimensional array of a2 into a 12 column one-dimensional array
   print(a4)

   a5 = a2.flatten() # No matter how many dimensions a2 is, it will become a one-dimensional array
   print(a5)

Note that reshape does not modify the original array itself, but returns the modified result. If you want to modify the array itself directly, you can use resize instead of reshape.

ndarray.itemsize:

The size of each element in the array, in bytes. For example, the following code:

   a1 = np.array([1,2,3],dtype=np.int32)
   print(a1.itemsize) # Print 4, because each byte is 8 bits, 32 bits / 8 = 4 bytes

jupyter: