基础知识

NumPy 的主要对象是同类的多维数组。它是一个元素表（通常为数字），所有相同的类型，由一元组非负整数编制索引。在 NumPy 维度中称为坐标轴。

例如，[1, 2, 1] 在 3D 空间中点坐标有一个轴。该轴有 3 个元素，因此我们说它的长度为 3。在下面的示例中，数组有 2 个轴。第一个轴的长度为 2，第二个轴的长度为 3。

[[ 1., 0., 0.],

[ 0., 1., 2.]]

NumPy 的数组类称为ndarray 。array也被称为别名。请注意，numpy.array与标准 Python 库类array.array 不同，该类只处理一维数组，并且提供的功能较少。ndarray对象的更重要的属性是：

ndarray.ndim：数组的轴（尺寸）数。ndarray.shape: 数组的尺寸。这是一个整数元组，指示每个维度中数组的大小。对于包含n 行和 m 列的矩阵，将为 。因此，元组的长度是轴的数量。ndarray.size: 数组的元素总数。它等于.shape的乘积。ndarray.dtype: 描述数组中元素类型的对象。可以使用标准 Python 类型创建或指定 dtype。此外，NumPy 还提供自己的类型。numpy. int32 ， numpy. int16 和 numpy. float64 是一些示例。ndarray.itemsize: 数组的每个元素的大小（以字节为单位）。例如，float64 类型元素数组为 8（+64/8），而 complex32 类型为 4（+32/8）。它等效于 ndarray.dtype.itemsizendarray.data: 包含数组的实际元素的缓冲区。通常，我们不需要使用此属性，因为我们将使用索引工具访问数组中的元素。

示例

>>> import numpy as np

>>> a = np.arange(15).reshape(3, 5)

>>> a

array([[ 0, 1, 2, 3, 4],

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

[10, 11, 12, 13, 14]])

>>> a.shape

(3, 5)

>>> a.ndim

2

>>> a.dtype.name

'int64'

>>> a.itemsize

8

>>> a.size

15

>>> type(a)

>>> b = np.array([6, 7, 8])

>>> b

array([6, 7, 8])

>>> type(b)

数组创建

创建数组的方法有多种。例如，您可以使用array 函数从常规 Python 列表或元组创建数组。生成的数组的类型从序列中元素的类型推断出来。

>>> import numpy as np

>>> a = np.array([2,3,4])

>>> a

array([2, 3, 4])

>>> a.dtype

dtype('int64')

>>> b = np.array([1.2, 3.5, 5.1])

>>> b.dtype

dtype('float64')

一个常见的错误是使用多个参数调用数组，而不是提供单个序列作为参数。

>>> a = np.array(1,2,3,4) # WRONG

Traceback (most recent call last):

...

TypeError: array() takes from 1 to 2 positional arguments but 4 were given

>>> a = np.array([1,2,3,4]) # RIGHT

array将序列序列转换为二维数组，将序列序列转换为三维数组，等等。

>>> b = np.array([(1.5,2,3), (4,5,6)])

>>> b

array([[1.5, 2. , 3. ],

[4. , 5. , 6. ]])

也可以在创建时显式指定数组的类型：

>>> c = np.array( [ [1,2], [3,4] ], dtype=complex )

>>> c

array([[1.+0.j, 2.+0.j],

[3.+0.j, 4.+0.j]])

通常，数组的元素最初是未知的，但其大小是已知的。因此，NumPy 提供了多个函数来创建具有初始占位符内容的数组。这些最小化了增加阵列的必要性，这是一个昂贵的操作。

zeros函数创建一个满零的数组，ones函数创建一个满1的数组，empty函数创建一个数组，其初始内容是随机的，取决于内存的状态。默认情况下，创建的数组的 dtype 为float64 。

>>> np.zeros((3, 4))

array([[0., 0., 0., 0.],

[0., 0., 0., 0.],

[0., 0., 0., 0.]])

>>> np.ones( (2,3,4), dtype=np.int16 ) # dtype can also be specified

array([[[1, 1, 1, 1],

[1, 1, 1, 1],

[1, 1, 1, 1]],

[[1, 1, 1, 1],

[1, 1, 1, 1],

[1, 1, 1, 1]]], dtype=int16)

>>> np.empty( (2,3) ) # uninitialized

array([[ 3.73603959e-262, 6.02658058e-154, 6.55490914e-260], # may vary

[ 5.30498948e-313, 3.14673309e-307, 1.00000000e+000]])

要创建数字序列，NumPy 提供类似于 Python 内置 的函数，但返回数组。arange``range

>>> np.arange( 10, 30, 5 )

array([10, 15, 20, 25])

>>> np.arange( 0, 2, 0.3 ) # it accepts float arguments

array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])

当与浮点参数一起使用时，由于浮点精度有限，通常无法预测获得的元素数。因此，通常最好使用接收的函数作为参数来表示我们想要的元素数，而不是步骤：arange``linspace

>>> from numpy import pi

>>> np.linspace( 0, 2, 9 ) # 9 numbers from 0 to 2

array([0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])

>>> x = np.linspace( 0, 2*pi, 100 ) # useful to evaluate function at lots of points

>>> f = np.sin(x)

另请参阅arrayzeros，zeros_likeonesones_likeempty，empty_likearangelinspacenumpy.random.Generator.randnumpy.random.Generator.randnfromfunctionfromfile

打印阵列

打印数组时，NumPy 以类似于嵌套列表的方式显示它，但具有以下布局：

最后一个轴从左到右打印，倒数第二个从上到下打印，其余部分也从上到下打印，每个切片与下一个切片以空行分隔。

然后，一维数组打印为行，标的作为矩阵，三维数组作为矩阵列表。

>>> a = np.arange(6) # 1d array

>>> print(a)

[0 1 2 3 4 5]

>>>

>>> b = np.arange(12).reshape(4,3) # 2d array

>>> print(b)

[[ 0 1 2]

[ 3 4 5]

[ 6 7 8]

[ 9 10 11]]

>>>

>>> c = np.arange(24).reshape(2,3,4) # 3d array

>>> print(c)

[[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

[[12 13 14 15]

[16 17 18 19]

[20 21 22 23]]]

请参阅下文，获取 有关 的更多详细信息。reshape

如果数组太大而无法打印，NumPy 会自动跳过数组的中心部分，只打印角：

>>> print(np.arange(10000))

[ 0 1 2 ... 9997 9998 9999]

>>>

>>> print(np.arange(10000).reshape(100,100))

[[ 0 1 2 ... 97 98 99]

[ 100 101 102 ... 197 198 199]

[ 200 201 202 ... 297 298 299]

...

[9700 9701 9702 ... 9797 9798 9799]

[9800 9801 9802 ... 9897 9898 9899]

[9900 9901 9902 ... 9997 9998 9999]]

若要禁用此行为并强制 NumPy 打印整个阵列，可以使用 更改打印选项。set_printoptions

>>> np.set_printoptions(threshold=sys.maxsize) # sys module should be imported

基本操作

数组上的算术运算符应用元素。将创建一个新数组，并填充结果。

>>> 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])

与许多矩阵语言不同，产品运算符在 NumPy 数组中按元素运行。矩阵产品可以使用运算符（在 python >=3.5）或函数或方法执行：* @ dot

>>> A = np.array( [[1,1],

... [0,1]] )

>>> B = np.array( [[2,0],

... [3,4]] )

>>> A * B # elementwise product

array([[2, 0],

[0, 4]])

>>> A @ B # matrix product

array([[5, 4],

[3, 4]])

>>> A.dot(B) # another matrix product

array([[5, 4],

[3, 4]])

某些操作（如 和 ）就地修改现有数组，而不是创建新数组。+= *=

>>> rg = np.random.default_rng(1) # create instance of default random number generator

>>> a = np.ones((2,3), dtype=int)

>>> b = rg.random((2,3))

>>> a *= 3

>>> a

array([[3, 3, 3],

[3, 3, 3]])

>>> b += a

>>> b

array([[3.51182162, 3.9504637 , 3.14415961],

[3.94864945, 3.31183145, 3.42332645]])

>>> a += b # b is not automatically converted to integer type

Traceback (most recent call last):

...

numpy.core._exceptions.UFuncTypeError: Cannot cast ufunc 'add' output from dtype('float64') to dtype('int64') with casting rule 'same_kind'

当使用不同类型的数组时，生成的数组的类型对应于更常规或更精确的数组（一种称为向上转换的行为）。

>>> a = np.ones(3, dtype=np.int32)

>>> b = np.linspace(0,pi,3)

>>> b.dtype.name

'float64'

>>> c = a+b

>>> c

array([1. , 2.57079633, 4.14159265])

>>> c.dtype.name

'float64'

>>> d = np.exp(c*1j)

>>> d

array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,

-0.54030231-0.84147098j])

>>> d.dtype.name

'complex128'

许多一元操作（如计算数组中所有元素的总和）都作为类的方法实现。ndarray

>>> a = rg.random((2,3))

>>> a

array([[0.82770259, 0.40919914, 0.54959369],

[0.02755911, 0.75351311, 0.53814331]])

>>> a.sum()

3.1057109529998157

>>> a.min()

0.027559113243068367

>>> a.max()

0.8277025938204418

默认情况下，这些操作应用于数组，就像它是数字列表一样，无论其形状如何。但是，通过指定参数，可以沿数组的指定轴应用操作：axis

>>> 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) # sum of each column

array([12, 15, 18, 21])

>>>

>>> b.min(axis=1) # min of each row

array([0, 4, 8])

>>>

>>> b.cumsum(axis=1) # cumulative sum along each row

array([[ 0, 1, 3, 6],

[ 4, 9, 15, 22],

[ 8, 17, 27, 38]])

通用功能

NumPy 提供熟悉的数学函数，如 sin、cos 和 exp。在 NumPy 中，这些称为”通用函数”（）。在 NumPy 中，这些函数在数组上按元素操作，生成数组作为输出。ufunc

>>> B = np.arange(3)

>>> B

array([0, 1, 2])

>>> np.exp(B)

array([1. , 2.71828183, 7.3890561 ])

>>> np.sqrt(B)

array([0. , 1. , 1.41421356])

>>> C = np.array([2., -1., 4.])

>>> np.add(B, C)

array([2., 0., 6.])

另请参阅

所有， 任何， apply_along_axis， argmax， argmin， argsort，平均，宾计数， ceil，剪辑， conj， Corrcoef， cov，交叉，暨， 暨，差异，点，地板，内，反转， lexsort，最大，最大，平均，中位数，最小，最小， 非零， 外部， prod， re，圆，排序，和， sum， trace， 转置， var ，vdot，矢量化，

索引、切片和索引

一维数组可以进行索引、切片和重复，就像列表和其他Python 序列一样。

>>> a = np.arange(10)**3

>>> a

array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])

>>> a[2]

8

>>> a[2:5]

array([ 8, 27, 64])

# equivalent to a[0:6:2] = 1000;

# from start to position 6, exclusive, set every 2nd element to 1000

>>> a[:6:2] = 1000

>>> a

array([1000, 1, 1000, 27, 1000, 125, 216, 343, 512, 729])

>>> a[ : :-1] # reversed a

array([ 729, 512, 343, 216, 125, 1000, 27, 1000, 1, 1000])

>>> for i in a:

... print(i**(1/3.))

...

9.999999999999998

1.0

9.999999999999998

3.0

9.999999999999998

4.999999999999999

5.999999999999999

6.999999999999999

7.999999999999999

8.999999999999998

多维数组可以每个轴有一个索引。这些索引以用逗号分隔的元组给出：

>>> def f(x,y):

... return 10*x+y

...

>>> b = np.fromfunction(f,(5,4),dtype=int)

>>> 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] # each row in the second column of b

array([ 1, 11, 21, 31, 41])

>>> b[ : ,1] # equivalent to the previous example

array([ 1, 11, 21, 31, 41])

>>> b[1:3, : ] # each column in the second and third row of b

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

[20, 21, 22, 23]])

当提供的索引少于轴数时，缺少的索引将被视为完整切片:

>>> b[-1] # the last row. Equivalent to b[-1,:]

array([40, 41, 42, 43])

括号内的表达式被视为后跟任意多个实例来表示剩余的轴。NumPy还允许您使用点来表示。b[i]i:b[i,...]dots() 表示生成完整索引元组所需的多冒号。例如，如果是具有 5 个轴的数组，则...x

x[1,2,...]等效于x[1,2,:,:,:]x[...,3]和 x[:,:,:,:,3]x[4,...,5,:]和x[4,:,:,5,:]

>>> c = np.array( [[[ 0, 1, 2], # a 3D array (two stacked 2D arrays)

... [ 10, 12, 13]],

... [[100,101,102],

... [110,112,113]]])

>>> c.shape

(2, 2, 3)

>>> c[1,...] # same as c[1,:,:] or c[1]

array([[100, 101, 102],

[110, 112, 113]])

>>> c[...,2] # same as c[:,:,2]

array([[ 2, 13],

[102, 113]])

迭代多维数组是在第一个轴上完成的：

>>> 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]

但是，如果想对数组中的每个元素执行操作，可以使用属性，该属性是数组中所有元素的迭代器：flat

>>> 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

另请参阅索引新轴 、指数

本文章首发在 LearnKu.com 网站上。