Introduction#

NumPy(Numerical Python) is an extension library for the Python language that supports extensive multi-dimensional array and matrix operations, and also provides a large collection of mathematical functions for array operations.

NumPy is a fast mathematical library, primarily used for array computations, and includes:

• A powerful N-dimensional array object ndarray
• Broadcasting function facilities
• Tools for integrating C/C++/Fortran code
• Functions for linear algebra, Fourier transforms, random number generation, and more

Applications#

NumPy is typically used together with SciPy (Scientific Python) and Matplotlib (the plotting library)

This combination is widely used as a replacement for MATLAB and provides a powerful scientific computing environment, helping us learn data science or machine learning through Python.

SciPy is an open-source Python algorithms library and mathematical toolkit.

SciPy includes modules for optimization, linear algebra, integration, interpolation, special functions, fast Fourier transforms, signal processing and image processing, solving ordinary differential equations, and other computations commonly used in science and engineering.

Matplotlib is the visualization interface for Python programming language and its NumPy numerical extension package.

It provides an API for embedding plots into applications using common GUI toolkits such as Tkinter, wxPython, Qt, or GTK+.

Installation#

• Install from a distribution package
• Install via pip: pip3 install numpy scipy matplotlib

Installation verification

1
from numpy import *
2
eye(4)

NumPy ndarray Object#

One of NumPy’s most important features is its N-dimensional array object, ndarray. It is a collection of elements of the same type, indexed from 0.

An ndarray object is a multidimensional array used to store elements of the same type.

Each element in an ndarray occupies a memory region of the same size.

An ndarray internally consists of the following parts:

• A pointer to the data (a block in memory or in a memory-mapped file).
• A data type (dtype) that describes the fixed-size element slots in the array.
• A tuple representing the array shape, i.e., the size of each dimension.
• A stride tuple, whose integers indicate how many bytes to skip to move to the next element along each dimension.

An ndarray consists of a contiguous one-dimensional memory block plus an indexing scheme that maps each element to a position in that block. Elements are stored in row-major order (C-style) or column-major order (FORTRAN/MatLab-style, i.e. F-order).

1
numpy.array(object,dtype = None,copy = True,order = None,subok = False,ndmin = 0)
2

3
# object:数组或嵌套的数列
4
# dtype:数组元素的数据类型，可选
5
# copy:对象是否需要复制，可选
6
# order:创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
7
# subok:默认返回一个与基类类型一致的数组
8
# ndmin:指定生成数组的最小维度

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

5
a = np.array([[1,  2],  [3,  4]])
6
print (a)
7

8
# 最小维度
9
a = np.array([1, 2, 3, 4, 5], ndmin =  2)
10
print (a)
11

12
# dtype 参数
13
a = np.array([1,  2,  3], dtype = complex)
14
print (a)

Data Types#

NumPy supports many more data types than Python built-ins, and most of them correspond to C language data types. Some of them also map to Python built-in types.

bool,int,intc,intp,int8,int16,int32,int64,uint8,uint16,uint32,uint64,float,float16,float32,float64,complex_,complex128,complex64,complex128

A data type object (an instance of numpy.dtype) describes how the memory area corresponding to an array is used. It describes the following aspects of the data:

• The data type (integer, floating point, or Python object)
• The size of the data (for example, how many bytes an integer uses)
• The byte order of the data (little-endian or big-endian)
• For structured types, the field names, each field’s data type, and the portion of memory occupied by each field
• If the data type is a sub-array, its shape and data type

Byte order is determined by prefixing the data type with < or >. < means little-endian (least significant bytes at lower addresses), and > means big-endian (most significant bytes at lower addresses).

A dtype object is constructed using the following syntax:

1
numpy.dtype(object, align, copy)
2

3
# object - 要转换为的数据类型对象
4
# align - 如果为 true，填充字段使其类似 C 的结构体。
5
# copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用

Usage:

1
import numpy as np
2
# 使用标量类型
3
dt = np.dtype(np.int32)
4
print(dt)
5

6
# 首先创建结构化数据类型
7
dt = np.dtype([('age',np.int8)])
8
# 将数据类型应用于 ndarray 对象
9
a = np.array([(10,),(20,),(30,)], dtype = dt)
10
print(a)

Each built-in type has a unique character code, as shown below:

NumPy Array Attributes#

The number of dimensions in a NumPy array is called its rank, which is the number of axes. A 1D array has rank 1, a 2D array has rank 2, and so on.

In NumPy, each linear array is called an axis, i.e., a dimension. For example, a 2D array can be seen as an array of 1D arrays.

So in NumPy, a one-dimensional direction is an axis. The first axis corresponds to the outer array, and the second axis corresponds to arrays inside it. The number of axes (rank) is the number of dimensions.

In many operations you can specify axis. axis=0 means operating along axis 0 (typically column-wise), while axis=1 means operating along axis 1 (typically row-wise).

Important ndarray attributes in NumPy arrays include:

• ndarray.ndim Rank, i.e., the number of axes or dimensions

  1
  import numpy as np
  2
  
  3
  a = np.arange(24)
  4
  print (a.ndim)             # a 现只有一个维度
  5
  # 现在调整其大小
  6
  b = a.reshape(2,4,3)  # b 现在拥有三个维度
  7
  print (b.ndim)

• ndarray.shape Array dimensions; for a matrix, n rows by m columns

  ndarray.shape can also be used to reshape an array.

  NumPy also provides the reshape function to resize/reshape arrays.

  1
  import numpy as np
  2
  
  3
  a = np.array([[1,2,3],[4,5,6]])
  4
  print (a.shape)
  5
  
  6
  a.shape =  (3,2)
  7
  print (a)
  8
  
  9
  a = np.array([[1,2,3],[4,5,6]])
  10
  b = a.reshape(3,2)
  11
  print (b)

• ndarray.size The total number of array elements, equivalent to n*m in .shape (for matrices)

• ndarray.dtype Element type of the ndarray object

• ndarray.itemsize Size of each element in the ndarray, in bytes

  1
  import numpy as np
  2
  
  3
  # 数组的 dtype 为 int8（一个字节）
  4
  x = np.array([1,2,3,4,5], dtype = np.int8)
  5
  print (x.itemsize)
  6
  
  7
  # 数组的 dtype 现在为 float64（八个字节）
  8
  y = np.array([1,2,3,4,5], dtype = np.float64)
  9
  print (y.itemsize)

• ndarray.flags Memory information of the ndarray object

  Property	Description
  C_CONTIGUOUS (C)	Data is stored in a single C-style contiguous segment
  F_CONTIGUOUS (F)	Data is stored in a single Fortran-style contiguous segment
  OWNDATA (O)	The array owns the memory it uses, or borrows it from another object
  WRITEABLE (W)	The data area is writable; if set to False, the data becomes read-only
  ALIGNED (A)	The data and all elements are properly aligned for hardware
  UPDATEIFCOPY (U)	This array is a copy of another array; when released, the original array content is updated

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

• ndarray.real Real part of ndarray elements

• ndarray.imag Imaginary part of ndarray elements

• ndarray.data Buffer containing the actual array elements. Since elements are usually accessed via indexing, this attribute is not often used directly.

Creating NumPy Arrays#

Besides using the underlying ndarray constructor, NumPy arrays can also be created in the following ways.

• numpy.empty

  The numpy.empty method creates an uninitialized array with a specified shape and data type:

  1
  numpy.empty(shape, dtype = float, order = 'C')
  2
  
  3
  # shape  数组形状
  4
  # dtype  数据类型，可选
  5
  # order  有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

  Usage:

  1
  import numpy as np
  2
  x = np.empty([3,2], dtype = int)
  3
  print (x)

• numpy.zeros

  Create an array of the specified size, filled with 0s:

  1
  numpy.zeros(shape, dtype = float, order = 'C')
  2
  
  3
  # shape  数组形状
  4
  # dtype  数据类型，可选
  5
  # order  'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组

  Usage:

  1
  import numpy as np
  2
  
  3
  # 默认为浮点数
  4
  x = np.zeros(5)
  5
  print(x)
  6
  
  7
  # 设置类型为整数
  8
  y = np.zeros((5,), dtype = int)
  9
  print(y)
  10
  
  11
  # 自定义类型
  12
  z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])
  13
  print(z)

• numpy.ones

  Create an array of the specified shape, filled with 1s:

  1
  numpy.ones(shape, dtype = float, order = 'C')
  2
  
  3
  # shape  数组形状
  4
  # dtype  数据类型，可选
  5
  # order    'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组

  Usage:

  1
  import numpy as np
  2
  
  3
  # 默认为浮点数
  4
  x = np.ones(5)
  5
  print(x)
  6
  
  7
  # 自定义类型
  8
  x = np.ones([2,2], dtype = int)
  9
  print(x)

• numpy.zeros_like/ones_like

  numpy.zeros_like creates an array with the same shape as a given array, filled with 0s.

  Both numpy.zeros and numpy.zeros_like are used to create arrays whose elements are all 0.

  The difference is that numpy.zeros directly specifies the shape to create, while numpy.zeros_like creates an array with the same shape as an existing array.

  1
  numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)
  2
  
  3
  # a  给定要创建相同形状的数组
  4
  # dtype  创建的数组的数据类型
  5
  # order  数组在内存中的存储顺序，可选值为 'C'（按行优先）或 'F'（按列优先），默认为 'K'（保留输入数组的存储顺序）
  6
  # subok  是否允许返回子类，如果为 True，则返回一个子类对象，否则返回一个与 a 数组具有相同数据类型和存储顺序的数组
  7
  # shape  创建的数组的形状，如果不指定，则默认为 a 数组的形状。

  Usage:

  1
  import numpy as np
  2
  
  3
  # 创建一个 3x3 的二维数组
  4
  arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
  5
  
  6
  # 创建一个与 arr 形状相同的，所有元素都为 0 的数组
  7
  zeros_arr = np.zeros_like(arr)
  8
  print(zeros_arr)

Array Slicing and Indexing#

1
import numpy as np
2

3
a = np.arange(10)
4
s = slice(2,7,2)   # 从索引 2 开始到索引 7 停止，间隔为2
5
print (a[s])
6

7
# 也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作
8
a = np.arange(10)
9
b = a[2:7:2]   # 从索引 2 开始到索引 7 停止，间隔为 2
10
print(b)
11

12
a = np.arange(10)  # [0 1 2 3 4 5 6 7 8 9]
13
b = a[5]
14
print(b)
15

16
print(a[2:])
17

18
print(a[2:5])
19

20
# 多维
21
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
22
print(a)
23
# 从某个索引处开始切割
24
print('从数组索引 a[1:] 处开始切割')
25
print(a[1:])
26

27
# 省略号
28
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
29
print (a[...,1])   # 第2列元素
30
print (a[1,...])   # 第2行元素
31
print (a[...,1:])  # 第2列及剩下的所有元素

Advanced Indexing#

NumPy provides more indexing methods than ordinary Python sequences.

In addition to integer and slice indexing, arrays can also be indexed with integer arrays, boolean indexing, and fancy indexing.

Advanced indexing in NumPy refers to using integer arrays, boolean arrays, or other sequences to access array elements. Compared with basic indexing, advanced indexing can access arbitrary elements and is useful for more complex operations and modifications.

1
import numpy as np
2

3
# 获取数组中 (0,0)，(1,1) 和 (2,0) 位置处的元素
4
x = np.array([[1,  2],  [3,  4],  [5,  6]])
5
y = x[[0,1,2],  [0,1,0]]
6
print (y)
7

8
# 获取了 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]
9
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])
10
print ('我们的数组是：' )
11
print (x)
12
print ('\\n')
13
rows = np.array([[0,0],[3,3]])
14
cols = np.array([[0,2],[0,2]])
15
y = x[rows,cols]
16
print  ('这个数组的四个角元素是：')
17
print (y)
18

19
# 可以借助切片 : 或 … 与索引数组组合
20
a = np.array([[1,2,3], [4,5,6],[7,8,9]])
21
b = a[1:3, 1:3]
22
c = a[1:3,[1,2]]
23
d = a[...,1:]
24
print(b)
25
print(c)
26
print(d)

1
import numpy as np
2

3
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])
4
print ('我们的数组是：')
5
print (x)
6
print ('\\n')
7
# 现在我们会打印出大于 5 的元素
8
print  ('大于 5 的元素是：')
9
print (x[x >  5])
10

11
a = np.array([np.nan,  1,2,np.nan,3,4,5])
12
print (a[~np.isnan(a)])
13

14
a = np.array([1,  2+6j,  5,  3.5+5j])
15
print (a[np.iscomplex(a)])

Broadcasting#

Broadcasting is NumPy’s way of performing numeric computations on arrays of different shapes. Arithmetic operations on arrays are usually performed element-wise.

If two arrays a and b have the same shape, i.e. a.shape == b.shape, then a*b multiplies corresponding elements. This requires the same number of dimensions and the same length in each dimension.

When the shapes of two arrays in an operation are different, NumPy automatically triggers broadcasting. Adding a 4x3 2D array and a length-3 1D array is equivalent to repeating array b four times along a new dimension and then performing the operation:

1
import numpy as np
2

3
a = np.array([[ 0, 0, 0],
4
           [10,10,10],
5
           [20,20,20],
6
           [30,30,30]])
7
b = np.array([0,1,2])
8
print(a + b)
9

10
bb = np.tile(b, (4, 1))  # 重复 b 的各个维度
11
print(a + bb)

Broadcasting rules:

1. Align all input arrays to the array with the most dimensions; prepend 1s to shapes with fewer dimensions.
2. The output shape takes the maximum size along each dimension of the input shapes.
3. For each dimension, an input array can participate if its length matches the output dimension or its length is 1; otherwise an error occurs.
4. When an input array has length 1 on a dimension, the first value along that dimension is reused during computation.

If the conditions are not satisfied, a ValueError: frames are not aligned exception is raised.

Iterating Arrays#

The NumPy iterator object numpy.nditer provides a flexible way to access elements of one or more arrays.

The most basic task of an iterator is to access array elements.

1
import numpy as np
2

3
a = np.arange(6).reshape(2,3)
4
print ('原始数组是：')
5
print (a,'\\n')
6
print ('迭代输出元素：')
7
for x in np.nditer(a):
8
    print (x, end=", " )
9
print ('\\n')
10

11
for x in np.nditer(a.T):
12
    print (x, end=", " )
13
print ('\\n')
14

15
for x in np.nditer(a.T.copy(order='C')):
16
    print (x, end=", " )
17
print ('\\n')

From the example above, we can see that a and a.T are traversed in the same order, which means their storage order in memory is also the same. However, the traversal result of a.T.copy(order = 'C') is different because its storage layout differs from the first two. By default, nditer uses K-order, i.e., an order as close as possible to the array’s actual memory layout.

1
import numpy as np
2

3
a = np.arange(0,60,5)
4
a = a.reshape(3,4)
5
print ('原始数组是：')
6
print (a)
7
print ('\\n')
8
print ('原始数组的转置是：')
9
b = a.T
10
print (b)
11
print ('\\n')
12
print ('以 C 风格顺序排序：')
13
c = b.copy(order='C')
14
print (c)
15
for x in np.nditer(c):
16
    print (x, end=", " )
17
print  ('\\n')
18
print  ('以 F 风格顺序排序：')
19
c = b.copy(order='F')
20
print (c)
21
for x in np.nditer(c):
22
    print (x, end=", " )
23
print  ('\\n')
24
# 可以通过显式设置，来强制 nditer 对象使用某种顺序：
25
print ('以 C 风格顺序排序：')
26
for x in np.nditer(a, order =  'C'):
27
    print (x, end=", " )
28
print ('\\n')
29
print ('以 F 风格顺序排序：')
30
for x in np.nditer(a, order =  'F'):
31
    print (x, end=", " )
32
``
33

34

35
### 修改数组元素
36

37
nditer对象有另一个可选参数op_flags。默认情况下，nditer将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值的修改，必须指定readwrite或者writeonly的模式。
38

39

40
```python
41
import numpy as np
42

43
a = np.arange(0,60,5)
44
a = a.reshape(3,4)
45
print ('Original array:')
46
print (a)
47
print ('\\n')
48
for x in np.nditer(a, op_flags=['readwrite']):
49
    x[...]=2*x
50
print ('Modified array:')
51
print (a)

1
import numpy as np
2
a = np.arange(0,60,5)
3
a = a.reshape(3,4)
4
print ('Original array:')
5
print (a)
6
print ('\\n')
7
print ('Modified array:')
8
for x in np.nditer(a, flags =  ['external_loop'], order =  'F'):
9
   print (x, end=", " )

1
import numpy as np
2

3
a = np.arange(0,60,5)
4
a = a.reshape(3,4)
5
print  ('The first array is:')
6
print (a)
7
print  ('\\n')
8
print ('The second array is:')
9
b = np.array([1,  2,  3,  4], dtype =  int)
10
print (b)
11
print ('\\n')
12
print ('Modified array is:')
13
for x,y in np.nditer([a,b]):
14
    print ("%d:%d"  %  (x,y), end=", " )

数组操作#