numpy学习指南

自动摘要: numpy.linalg.norm linalg.norm(x,ord=None,axis=None,keepdims=False)矩阵或向量范数。 根据ord参数的值，这个函数可以 ……..

numpy.linalg.norm

linalg.norm(x, ord=None, axis=None, keepdims=False)矩阵或向量范数。

根据 ord 参数的值，这个函数可以返回八个不同的矩阵范数中的一个，或者无限多个向量范数中的一个(如下所述)。

参数：

• x ：array_like

  • 输入数组。如果坐标轴为“无”，则 x 必须为1-D 或2-D，除非 ord 为“无”。如果两个坐标轴和 ord 都为无，则返回 x.ravel 的2-范数。

• ord ： {non-zero int, inf, -inf, ‘fro’, ‘nuc’}, optional

  • 标准的norm(见附注下的表格)。Inf 表示 numpy 的 inf 对象，默认值为 Nothing

• axis ： {None, int, 2-tuple of ints}, optional.

  • 如果坐标轴是一个整数，它指定计算向量范数的 x 轴。如果轴是一个2元组，它指定持有2-D 矩阵的轴，并计算这些矩阵的矩阵范数。如果坐标轴为无，则返回向量范数(当 x 为1-D 时)或矩阵范数(当 x 为2-D 时)。默认值为 Nothing。

• keep ： dimsbool, optional

  • 如果设置为 True，则在结果中以尺寸为1的维度保留规范化的轴。使用这个选项，结果将正确地广播到原始的 x。

返回值：

• n：float or ndarray
  • 矩阵或向量的范数。

另请参阅：

• scipy.linalg.norm SciPy 中的类似功能

注意：对于 ord < 1的值，严格地说，结果不是数学上的“范数”，但是它仍然可以用于各种数值计算。

可以计算出以下准则:

ord	矩阵范数	向量范数
None	Frobenius norm 弗罗贝尼乌斯范数	2-范数
‘fro’	Frobenius norm 弗罗贝尼乌斯范数	–
‘nuc’	核范数	–
inf	max(sum(abs(x), axis=1))	max(abs(x))
-inf	min(sum(abs(x), axis=1))	min(abs(x))
0	–	sum(x != 0)
1	max(sum(abs(x), axis=0))	同下
-1	min(sum(abs(x), axis=0))	同下
2	2-norm (largest sing. value)	同下
-2	最小奇异值	同下
other	–	sum(abs(x)ord)(1./ord)

Frobenius 范数由[1]给出:
核范数是奇异值的和。Frobenius 和核范数阶都只对矩阵定义，当 x.ndim! = 2时会产生一个 ValueError。

参考文献：[1] G. H. Golub and C. F. Van Loan, Matrix Computations, Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15

示例：

from numpy import linalg as LA
a = np.arange(9) - 4
a
array([-4, -3, -2, ...,  2,  3,  4])

b = a.reshape((3, 3))
b
array([[-4, -3, -2],
       [-1,  0,  1],
       [ 2,  3,  4]])

LA.norm(a)
7.745966692414834

LA.norm(b)
7.745966692414834

LA.norm(b, 'fro')
7.745966692414834

LA.norm(a, np.inf)
4.0

LA.norm(b, np.inf)
9.0

LA.norm(a, -np.inf)
0.0

LA.norm(b, -np.inf)
2.0

LA.norm(a, 1)
20.0

LA.norm(b, 1)
7.0

LA.norm(a, -1)
-4.6566128774142013e-010

LA.norm(b, -1)
6.0

LA.norm(a, 2)
7.745966692414834

LA.norm(b, 2)
7.3484692283495345

LA.norm(a, -2)
0.0

LA.norm(b, -2)
1.8570331885190563e-016 # may vary

LA.norm(a, 3)
5.8480354764257312 # may vary

LA.norm(a, -3)
0.0

使用轴参数计算向量范数:

c = np.array([[ 1, 2, 3],
              [-1, 1, 4]])
LA.norm(c, axis=0)
array([ 1.41421356,  2.23606798,  5.        ])

LA.norm(c, axis=1)
array([ 3.74165739,  4.24264069])

LA.norm(c, ord=1, axis=1)
array([ 6.,  6.])

使用轴参数计算矩阵范数:

m = np.arange(8).reshape(2,2,2)
LA.norm(m, axis=(1,2))
array([  3.74165739,  11.22497216])

LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
(3.7416573867739413, 11.224972160321824)

numpy.argsort

numpy.argsort(a, axis=-1, kind=None, order=None)返回数组排序后的元素原索引值。

使用 kind 关键字指定的算法沿给定轴执行间接排序。它按排序顺序返回沿给定轴的索引数据形状相同的索引数组。

参数：

• a：array_like

  • 要排序的数组

• axis：int or None, optional

  • 要排序的轴。默认值是 -1(最后一个轴)。如果没有，则使用扁平数组。

• kind：{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, optional

  • 排序算法。默认值是“快排”。请注意，“稳定”和“合并排序”都暗中使用 timsort，而且一般来说，实际的实现将随着数据类型的不同而不同。保留“合并排序”选项是为了向后兼容。

• order：str or list of str, optional

  • 当 a 是一个定义了字段的数组时，该参数指定首先比较哪些字段，其次比较哪些字段，等等。可以将单个字段指定为字符串，并且不需要指定所有字段，但仍将按照在 dtype 中出现的顺序使用未指定的字段来断开关系。

返回值：

• index_array：ndarray, int
  • 沿指定轴对 a 进行排序的索引数组。如果 a 是一维的，则[ index _ array ]生成一个经过排序的。更一般地说，np.take _ along _ axis (a，index _ array，ax= axis)总是生成排序后的 a，与维度无关。

另请参阅：

• sort：描述使用的排序算法。
• lexsort：具有多个键的间接稳定排序。
• ndarray.sort：原地排序。
• argpartition：间接部分排序。
• take_along_axis：将 index _ array 从 argsort 应用到数组，就像通过调用 sort 一样。

注意：有关不同排序算法的说明，请参见 sort。从 NumPy 1.4.0开始，argsort 使用包含 nan 值的实数/复数数组。增强的排序顺序以排序形式记录。

示例：一维数组：

x = np.array([3, 1, 2])
np.argsort(x)
array([1, 2, 0])

二维数组：

x = np.array([[0, 3], [2, 2]])
x
array([[0, 3],
       [2, 2]])

ind = np.argsort(x, axis=0)  # sorts along first axis (down)
ind
array([[0, 1],
       [1, 0]])

np.take_along_axis(x, ind, axis=0)  # same as np.sort(x, axis=0)
array([[0, 2],
       [2, 3]])

ind = np.argsort(x, axis=1)  # sorts along last axis (across)
ind
array([[0, 1],
       [0, 1]])

np.take_along_axis(x, ind, axis=1)  # same as np.sort(x, axis=1)
array([[0, 3],
       [2, 2]])

N-维数组中已排序元素的索引:

ind = np.unravel_index(np.argsort(x, axis=None), x.shape)
ind
(array([0, 1, 1, 0]), array([0, 0, 1, 1]))

x[ind]  # same as np.sort(x, axis=None)
array([0, 2, 2, 3])

使用键排序：

x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
x
array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])

np.argsort(x, order=('x','y'))
array([1, 0])

np.argsort(x, order=('y','x'))
array([0, 1])

numpy.ravel

numpy.ravel(a, order=’C’)返回一个连续的平展一维数组。

返回一个包含输入元素的1-D 数组。只有在需要时才复制。

从 NumPy 1.10开始，返回的数组将具有与输入数组相同的类型。(例如，对于掩码数组输入，将返回一个掩码数组)。

参数：

• a：array_like

  • 输入数组。 a 中的元素按顺序指定的顺序读取，并打包为一维数组。

• order：{‘C’, ‘F’, ‘A’, ‘K’}, optional

  • 使用此索引顺序读取 a 的元素。“ C”表示行主序、 C 风格的顺序对元素进行索引，最后一个轴索引变化最快，返回到第一个轴索引变化最慢。‘ F’表示按列主序、 Fortran 风格的顺序对元素进行索引，第一个索引变化最快，最后一个索引变化最慢。请注意，‘ C’和‘ F’选项没有考虑基础数组的内存布局，只是引用了轴索引的顺序。‘ A’表示如果 a 在内存中是 Fortran 连续的，则以类似 Fortran 的索引顺序读取元素，否则以类似 C 的顺序读取元素。“ K”表示按照元素在内存中出现的顺序读取元素，但当步长为负值时则反转数据。默认情况下，使用“ C”索引顺序。

返回值：y：array_like

• Y 是一个子类型与 a 相同的数组，带有形状(a.size, )。请注意，矩阵是特殊情况下的向下兼容，如果 a 是一个矩阵，那么 y 是一个一维 ndarray。

另请参阅：

• ndarray.flat：数组上的1-D 迭代器；
• ndarray.flatten：数组元素的1-D 数组副本按行主序排列；
• ndarray.reshape：更改数组的形状而不更改其数据。

注意：

• 在行主序、 C 样式的顺序中，在两个维度中，行索引变化最慢，列索引变化最快。这可以推广到多个维度，其中行-主要顺序意味着沿着第一个轴的索引变化最慢，而沿着最后一个轴的索引变化最快。对于列主序，Fortran 样式的索引排序，则相反。

• 当在尽可能多的情况下需要一个视图时，arr.reform (-1) 可能更可取。

示例：它相当于重塑reshape(-1, order=order)。

x = np.array([[1, 2, 3], [4, 5, 6]])
np.ravel(x)
array([1, 2, 3, 4, 5, 6])

x.reshape(-1)
array([1, 2, 3, 4, 5, 6])

np.ravel(x, order='F')
array([1, 4, 2, 5, 3, 6])

当顺序为“ A”时，它将保留数组的“ C”或“ F”顺序:

np.ravel(x.T)
array([1, 4, 2, 5, 3, 6])

np.ravel(x.T, order='A')
array([1, 2, 3, 4, 5, 6])

当顺序是“ K”时，它将保留既不是“ C”也不是“ F”的顺序，但不会反转轴:

a = np.arange(3)[::-1]; 
a
array([2, 1, 0])

a.ravel(order='C')
array([2, 1, 0])

a.ravel(order='K')
array([2, 1, 0])

a = np.arange(12).reshape(2,3,2).swapaxes(1,2); 
a
array([[[ 0,  2,  4],
        [ 1,  3,  5]],
       [[ 6,  8, 10],
        [ 7,  9, 11]]])


a.ravel(order='C')
array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])


a.ravel(order='K')
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

numpy.argwhere

numpy.argwhere(a)返回非0的数组元素的索引，其中a是要索引数组的条件。

参数：

• a：array_like
  • 输入数据

返回值：

• index_array：(N, a.ndim) ndarray
  • 非零元素的索引。索引按元素分组。这个数组将有一个形状(N，a.ndim) ，其中 N 是非零项的数目。

另请参阅：

• where**, **nonzero

注意：

• Argwhere (a)与 np.transose (np.nonzero (a))几乎相同，但会为 0D 数组生成正确形状的结果。
• Argwhere 的输出不适合为数组建立索引。对此可以使用nonzero(a)代替。

示例：

x = np.arange(6).reshape(2,3)
x
array([[0, 1, 2],
       [3, 4, 5]])

np.argwhere(x>1)
array([[0, 2],
       [1, 0],
       [1, 1],
       [1, 2]])

numpy.where

numpy.where(condition, [x, y, ]/)根据条件返回从 x 或 y 中选择的元素。（是三元表达式 x if condition else y 的矢量化版本）

注意：当只提供条件时，此函数是np.asarray(condition).nonzero()，直接使用 nonzero。本文档的其余部分只提供了三个参数所涉及的内容。

参数：

• condition：array_like, bool

  • 如果为 True，则产生 x，否则产生 y。

• x, y：array_like

  • 要从中选择的值。x，y和条件需要可以播放到某种形状。

返回值：

• out：ndarray
  • 如果同时指定了x和y，则输出数组包含x的元素，其中condition为True，其他元素来自y。如果只给出条件，则返回元组condition.nanzero()，条件为True的索引。

另请参阅：

• choose
• nonzero
  • 省略 x 和 y 时调用的函数

注意：如果所有数组都是1-D，其中等效于:

[xv if c else yv
 for c, xv, yv in zip(condition, x, y)]

示例：

a = np.arange(10)
a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.where(a < 5, a, 10*a)
array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])

这也可以用于多维数组:

np.where([[True, False], [True, True]],
         [[1, 2], [3, 4]],
         [[9, 8], [7, 6]])
array([[1, 8],
       [3, 4]])

x、 y 和条件一起广播:

x, y = np.ogrid[:3, :4]
np.where(x < y, x, 10 + y)  # both x and 10+y are broadcast
array([[10,  0,  0,  0],
       [10, 11,  1,  1],
       [10, 11, 12,  2]])

a = np.array([[0, 1, 2],
              [0, 2, 4],
              [0, 3, 6]])
np.where(a < 4, a, -1)  # -1 is broadcast
array([[ 0,  1,  2],
       [ 0,  2, -1],
       [ 0,  3, -1]])

numpy.nonzero

numpy.nonzero(a)返回非零元素的索引。

返回一个数组元组，a中每个元组对应一个维度，该维度包含该维度中非零元素的索引。a 中的值始终在行主序中进行测试并返回C-style顺序。

若要按元素而不是维度对索引进行分组，请使用 argwhere，它为每个非零元素返回一行。

参数：

• a：array_like
  • 输入数组

返回值：

• tuple_of_arrays：tuple
  • 非零元素的索引（如二维：两个矩阵， 包含了相应维度上非零元素所在的行标号，与列标标号。）。

另请参阅:

• flatnonzero
  • 返回输入数组展平后的非零索引。
• ndarray.nonzero
  • 等效 ndarray 方法。
• count_nonzero
  • 计算输入数组中非零元素的数量。

注意：虽然可以用[ nonzero (a)]获得非零值，但建议使用 x [ x.astype (bool)]或 x [ x！= 0] ，它将正确处理0-d 数组。

示例：

x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
x
array([[3, 0, 0],
       [0, 4, 0],
       [5, 6, 0]])

np.nonzero(x)
(array([0, 1, 2, 2]), array([0, 1, 0, 1]))

x[np.nonzero(x)]
array([3, 4, 5, 6])

np.transpose(np.nonzero(x))
array([[0, 0],
       [1, 1],
       [2, 0],
       [2, 1]])

非零的一个常见用法是查找数组的索引，其中条件为 True。给定一个数组 a，条件 a > 3是一个布尔数组，因为 False 被解释为0，np.nonzero (a > 3)生成条件为 true 的 a 的索引。

a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
a > 3
array([[False, False, False],
       [ True,  True,  True],
       [ True,  True,  True]])

np.nonzero(a > 3)
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))

使用这个结果来索引 a 相当于直接使用掩码:

a[np.nonzero(a > 3)]
array([4, 5, 6, 7, 8, 9])

a[a > 3]  #喜欢这个写法
array([4, 5, 6, 7, 8, 9])

也可以将 nonzero 作为数组的方法调用。

(a > 3).nonzero()
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))

numpy.unique

numpy.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None, *, equal_nan=True)对于一维数组或者列表，unique函数去除其中重复的元素，并按元素由大到小返回一个新的无元素重复的元组或者列表。

返回一个数组中已排序的唯一元素。除了唯一元素外，还有三个可选输出:

• 给出唯一值的输入数组的索引;
• 重建输入数组的唯一数组的索引;
• 每个唯一值出现在输入数组中的次数。

参数：

• a：rarray_like

  • 输入数组。除非指定了轴，否则如果它不是1-D，它将展平。

• return_index：bool, optional

  • 如果为 True，还将返回 ar 的索引(如果提供，则沿指定的轴，或在展平数组中) ，从而生成唯一数组。

• return_inverse：bool, optional

  • 如果为 True，还返回可用于重新构造 ar 的唯一数组的索引(如果提供了指定的轴)。

• return_counts：bool, optional

  • 如果为 True，也返回每个唯一项在 ar 中出现的次数。

• axis：int or None, optional

  • 要操作的轴。如果为None，ar将被展平。如果是一个整数，给定轴索引的子数组将被展平，并被视为具有给定轴维数的一维数组的元素，更多细节参见注释。如果使用坐标轴 kwarg，则不支持包含对象的对象数组或结构化数组。默认值为 None。

• equal_nan：bool, optional

  • 如果为 True，则将返回数组中的多个 NaN 值折叠为一个。

返回值：

• unique：ndarray

  • 排序的唯一值。

• unique_indices：ndarray, optional

  • 原始数组中唯一值的第一个匹配项的索引。只有当 return _ index 为 True 时才提供。

• unique_inverse：ndarray, optional

  • 用于从唯一数组重建原始数组的索引。只有 return _ verse 为 True 时才提供。

• unique_counts：ndarray, optional

  • 每个唯一值在原始数组中出现的次数。只有 return _ count 为 True 时才提供。

另请参阅：

• numpy.lib.arraysetops

  • 模块中包含许多其他函数，用于对数组执行集合操作。

• repeat

  • 重复数组的元素。

注意：当指定一个轴时，按轴索引的子数组将被排序。这是通过将指定的轴作为数组的第一维(将轴移动到第一维以保持其他轴的顺序) ，然后按 C 顺序展平子数组来完成的。然后将扁平化的子数组视为一个结构化类型，每个元素都有一个标签，这样我们就得到了一个结构化类型的1-D 数组，可以像处理其他任何1-D 数组一样处理这个数组。其结果是从第一个元素开始按照字典顺序对平坦子阵进行排序。

示例：

np.unique([1, 1, 2, 2, 3, 3])
array([1, 2, 3])

a = np.array([[1, 1], [2, 3]])
np.unique(a)
array([1, 2, 3])

回2D 数组的唯一行：

a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
np.unique(a, axis=0)
array([[1, 0, 0], [2, 3, 4]])

返回给出唯一值的原始数组的索引:

a = np.array(['a', 'b', 'b', 'c', 'a'])
u, indices = np.unique(a, return_index=True)
u
array(['a', 'b', 'c'], dtype='<U1')

indices
array([0, 1, 3])

a[indices]
array(['a', 'b', 'c'], dtype='<U1')

根据唯一值和逆值重新构造输入数组:

a = np.array([1, 2, 6, 4, 2, 3, 2])
u, indices = np.unique(a, return_inverse=True)
u
array([1, 2, 3, 4, 6])

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

u[indices]
array([1, 2, 6, 4, 2, 3, 2])

根据唯一值和计数重新构造输入值:

a = np.array([1, 2, 6, 4, 2, 3, 2])
values, counts = np.unique(a, return_counts=True)
values
array([1, 2, 3, 4, 6])

counts
array([1, 3, 1, 1, 1])

np.repeat(values, counts)
array([1, 2, 2, 2, 3, 4, 6])    # 原始顺序未保留

numpy.delete

numpy.delete(arr, obj, axis=None)返回一个删除后的新数组，其中子数组沿删除的轴方向排列。对于一维数组，返回 arr [ obj ]没有返回的条目。

参数：

• arr：array_like

  • 输入数组；

• obj：slice, int or array of ints

  • 指示要沿指定轴移除的子数组的索引（指定要通过的整数,切片或者列表（数组）删除的行号/列号）；

• axis：int, optional

  • 要删除由 obj 定义的子数组的轴。如果坐标轴为 None，则arr先按行展平，然后按照obj，删除第obj-1(从0开始)位置的数，返回一个行矩阵。

返回值：

• out：ndarray
  • 删除了 obj 指定的元素的 arr 的副本。注意，删除不会就地发生。如果坐标轴为None，则 out 为展平数组。

另请参阅：

• insert
  • 将元素插入数组。
• append
  • 在数组末尾追加元素。

注意：通常最好使用布尔掩码，例如:

arr = np.arange(12) + 1
mask = np.ones(len(arr), dtype=bool)
mask[[0,2,4]] = False
result = arr[mask,...]

等效于 np.delete (arr，[0,2,4] ，ax= 0) ，但允许进一步使用掩码。

示例：

arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
arr
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

np.delete(arr, 1, 0)
array([[ 1,  2,  3,  4],
       [ 9, 10, 11, 12]])

np.delete(arr, np.s_[::2], 1)
array([[ 2,  4],
       [ 6,  8],
       [10, 12]])

np.delete(arr, [1,3,5], None)
array([ 1,  3,  5,  7,  8,  9, 10, 11, 12])

numpy.vstack

numpy.vstack(tup, *, dtype=None, casting=’same_kind’)

按顺序垂直堆栈数组(按行排列)。

这相当于将形状为(N,)的一维列阵改成形状为(1，N)后沿着竖直方向堆叠。重建阵列除以vsplit。

这个函数对于最多3维的数组最有意义。例如，对于具有高度(第一轴)、宽度(第二轴)和 r/g/b 通道(第三轴)的像素数据。函数级联、堆栈和块提供了更通用的堆栈和级联操作。

Row _ stack 是 vstack 的别名，它们是相同的函数。

参数：

• tup：ndarrays序列

  • 数组必须沿着第一个轴线以外的所有轴线具有相同的形状。1-D 数组必须具有相同的长度。

• dtype：str or dtype

  • 如果提供，目标数组将具有此 dtype。不能与 out 一起提供。

• .. versionadded:: 1.24

• casting：{‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, 可选择的

  • 控制可能发生的数据类型转换。默认为“ same _ kind”。

• .. versionadded:: 1.24

Returns：

• stacked：ndarray
  • 通过叠加给定的数组形成的数组，将至少是2-D 的。

示例：

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

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

numpy.ones

numpy.ones(shape, dtype=None, order=’C’, *, like=None)

返回一个给定形状和类型的新数组，数组元素全为1.

参数：

• shape：int 或 整数序列

  • 新数组的形状,例如,(2,3)或2。

• dtype：data-type, 可选

  • 数组所需的数据类型，例如 numpy.int8。默认值是 numpy.float64。

• order：{‘C’, ‘F’}, 可选, 默认: C

  • 是否在内存中按行主序 (C- 风格)或列主序 (Fortran- 风格)顺序存储多维数据。

• like：array_like, 可选

  • 引用对象允许创建非 NumPy 数组的数组。如果以类似方式传入的类数组支持 _ _ array _ function _ _ protocol，则结果将由其定义。在这种情况下，它确保创建与通过此参数传入的数组对象兼容的数组对象。

Returns:

• out：ndarray
  • 具有给定形状、 dtype 和顺序的数组，元素值全为1。

示例：

np.ones(5)
array([1., 1., 1., 1., 1.])

np.ones((5,), dtype=int)
array([1, 1, 1, 1, 1])

np.ones((2, 1))
array([[1.],
       [1.]])

s = (2,2)
np.ones(s)
array([[1.,  1.],
       [1.,  1.]])

numpy.zeros

numpy.zeros(shape, dtype=float, order=’C’, *, like=None)返回一个给定形状和类型的新数组，该数组由零填充

参数：

• shape：int or 整数tuple

  • 新数组的形状，例如(2,3)或2。

• dtype：data-type, 可选

  • 数组所需的数据类型，例如 numpy.int8。默认值是 numpy.float64。

• order{‘C’, ‘F’}, optional, default: ‘C’

  • 是否在内存中按行主序 (C- 风格)或列主序 (Fortran- 风格)顺序存储多维数据。

• like：array_like, 可选

  • 引用对象以允许创建非 NumPy 数组的数组。如果以类似方式传入的类数组支持 _ _ array _ function _ _ protocol，则结果将由其定义。在这种情况下，它确保创建与通过此参数传入的数组对象兼容的数组对象。

返回值：

• out：ndarray
  • 具有给定形状、 dtype 和顺序的零数组。

示例：

np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])

np.zeros((5,), dtype=int)
array([0, 0, 0, 0, 0])

np.zeros((2, 1))
array([[ 0.],
       [ 0.]])

s = (2,2)
np.zeros(s)
array([[ 0.,  0.],
       [ 0.,  0.]])

np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
array([(0, 0), (0, 0)],
      dtype=[('x', '<i4'), ('y', '<i4')])

numpy.linalg.inv

linalg.inv(a)计算矩阵的(乘法)逆

给定一个方阵 a，返回矩阵 ainv 满足 dot(a, ainv) = dot(ainv, a) = eye(a.shape[0])。

参数：

• a：(…, M, M) array_like
  • 矩阵的逆

返回值：

• ainv：(…, M, M) ndarray or matrix
  • 矩阵 a 的逆(乘法)。

Raises: LinAlgError如果 a 不是正方形或反转失败。

示例：

from numpy.linalg import inv
a = np.array([[1., 2.], [3., 4.]])
ainv = inv(a)
np.allclose(np.dot(a, ainv), np.eye(2))
True
np.allclose(np.dot(ainv, a), np.eye(2))
True

如果a是一个矩阵，则返回值是一个矩阵：

ainv = inv(np.matrix(a))
ainv
matrix([[-2. ,  1. ],
        [ 1.5, -0.5]])

几个矩阵的逆可以一次计算出来:

a = np.array([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]])
inv(a)
array([[[-2.  ,  1.  ],
        [ 1.5 , -0.5 ]],
       [[-1.25,  0.75],
        [ 0.75, -0.25]]])

numpy.dot

numpy.dot(a, b, out=None)两个数组的点积，其中：

• 如果 a 和 b 都是一维数组，则它是向量的内积(无复共轭)。
• 如果 a 和 b 都是2-d 数组，那么它是矩阵乘法的，但是最好使用 matmul 或者 a@b。
• 如果 a 或 b 是0-D (标量) ，那么它等价于乘法，最好使用 numpy.multi(a，b)或 a * b。
• 如果 a 是 N-D 数组，b 是1-D 数组，它是 a 和 b 最后一个轴的和乘积。
• 如果 a 是 N-D 数组，b 是 M-D 数组(其中 M > = 2) ，它是 a 的最后一个轴和 b 的倒数第二个轴的和乘积:

  dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])

参数：

• a：array_like

  • First argument.

• b：array_like

  • Second argument.

• out：ndarray, 可选

  • 输出参数。如果不使用它，它必须具有返回的确切类型。特别是，它必须具有正确的类型，必须是C-contiguous，并且它的 dtype 必须是要为 dot(a，b)返回的 dtype。这是一个表演特色。因此，如果不满足这些条件，将引发异常，而不是尝试灵活处理。

返回值：

• output：ndarray
  • 返回 a 和 b 的点乘。如果 a 和 b 都是标量或者都是1-D 数组，则返回标量; 否则返回数组。如果给出 out，则返回它。

Raises: ValueError

• 如果 a 的最后一个维度与 b 的倒数第二个维度的大小不同。

示例：

np.dot(3, 4)
12

这两个参数都不是复共轭的：

np.dot([2j, 3j], [2j, 3j])
(-13+0j)

于2-D 阵列，它是矩阵乘积:

a = [[1, 0], [0, 1]]
b = [[4, 1], [2, 2]]
np.dot(a, b)
array([[4, 1],
       [2, 2]])

a = np.arange(3*4*5*6).reshape((3,4,5,6))
b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))
np.dot(a, b)[2,3,2,1,2,2]
499128

sum(a[2,3,2,:] * b[1,2,:,2])
499128

numpy.eye

numpy.eye(N, M=None, k=0, dtype=<class ‘float’>, order=’C’, *, like=None)返回一个2-D 数组，其中对角线上为1，其他地方为0。

参数：

• N：int

  • 输出中的行数。

• M：int, 可选

  • 输出中的列数。如果没有，则默认为 N。

• k：int, 可选

  • 对角线索引: 0(默认值)表示主对角线，正值表示上对角线，负值表示下对角线。

• dtype：data-type, 可选

  • 返回数组的数据类型。

• order{‘C’, ‘F’}, 可选

  • 输出应该以行-主序(C-风格)或列-主序(Fortran-风格)的顺序存储在内存中。

• like：array_like, 可选

  • 引用对象以允许创建非 NumPy 数组的数组。如果以类似方式传入的类数组支持 _ _ array _ function _ _ protocol，则结果将由其定义。在这种情况下，它确保创建与通过此参数传入的数组对象兼容的数组对象。

返回值：

• I：ndarray of shape (N,M)
  • 一个数组，其中所有元素都等于零，除了 k-th 对角线，其值等于1。

示例：

np.eye(2, dtype=int)
array([[1, 0],
       [0, 1]])

np.eye(3, k=1)
array([[0.,  1.,  0.],
       [0.,  0.,  1.],
       [0.,  0.,  0.]])

numpy.linalg.norm

linalg.norm(x, ord=None, axis=None, keepdims=False)矩阵或向量范数。

根据 ord 参数的值，这个函数可以返回八个不同的矩阵范数中的一个，或者无限多个向量范数中的一个(如下所述)。

参数：

• x：array_like

  • 输入数组。如果坐标轴为“无”，则 x 必须为1-D 或2-D，除非 ord 为“无”。如果两个坐标轴和 ord 都为无，则返回 x.ravel 的2-范数。

• ord：{non-zero int, inf, -inf, ‘fro’, ‘nuc’}, optional

  • Inf 表示 numpy 的 inf 对象，默认值为 Nothing。

• axis：{None, int, 2-tuple of ints}, optional

  • 如果坐标轴是一个整数，它指定计算向量范数的 x 轴。如果轴是2-元组，它指定持有2-D 矩阵的轴，并计算这些矩阵的矩阵范数。如果坐标轴为无，则返回向量范数(当 x 为1-D 时)或矩阵范数(当 x 为2-D 时)。默认值为 Nothing。

• keepdims：bool, optional

  • 如果设置为 True，则在结果中以尺寸为1的维度保留规范化的轴。使用这个选项，结果将正确地广播到原始的 x。

返回值：

• n：float or ndarray
  • 矩阵或向量的范数。

注意：对于 ord < 1的值，严格地说，结果不是数学上的“范数”，但是它仍然可以用于各种数值计算。

可以计算以下规范：

ord	norm for matrices	norm for vectors
None	Frobenius norm	2-norm
‘fro’	Frobenius norm	–
‘nuc’	nuclear norm	–
inf	max(sum(abs(x), axis=1))	max(abs(x))
-inf	min(sum(abs(x), axis=1))	min(abs(x))
0	–	sum(x != 0)
1	max(sum(abs(x), axis=0))	as below
-1	min(sum(abs(x), axis=0))	as below
2	2-norm (largest sing. value)	as below
-2	smallest singular value	as below
other	–	sum(abs(x)ord)(1./ord)

Frobenius 范数由[1]给出:
核范数是奇异值的和。Frobenius 和核范数阶都只对矩阵定义，当 x.ndim! = 2时会产生一个 ValueError。

参考文献：[1] G. H. Golub and C. F. Van Loan, Matrix Computations, Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15

示例：

from numpy import linalg as LA
a = np.arange(9) - 4
a
array([-4, -3, -2, ...,  2,  3,  4])

b = a.reshape((3, 3))
b
array([[-4, -3, -2],
       [-1,  0,  1],
       [ 2,  3,  4]])

LA.norm(a)
7.745966692414834
LA.norm(b)
7.745966692414834
LA.norm(b, 'fro')
7.745966692414834
LA.norm(a, np.inf)
4.0
LA.norm(b, np.inf)
9.0
LA.norm(a, -np.inf)
0.0
LA.norm(b, -np.inf)
2.0

LA.norm(a, 1)
20.0
LA.norm(b, 1)
7.0
LA.norm(a, -1)
-4.6566128774142013e-010
LA.norm(b, -1)
6.0
LA.norm(a, 2)
7.745966692414834
LA.norm(b, 2)
7.3484692283495345

LA.norm(a, -2)
0.0
LA.norm(b, -2)
1.8570331885190563e-016 # may vary
LA.norm(a, 3)
5.8480354764257312 # may vary
LA.norm(a, -3)
0.0

使用轴参数计算向量范数:

c = np.array([[ 1, 2, 3],
              [-1, 1, 4]])
LA.norm(c, axis=0)
array([ 1.41421356,  2.23606798,  5.        ])
LA.norm(c, axis=1)
array([ 3.74165739,  4.24264069])
LA.norm(c, ord=1, axis=1)
array([ 6.,  6.])

使用轴参数计算矩阵范数:

m = np.arange(8).reshape(2,2,2)
LA.norm(m, axis=(1,2))
array([  3.74165739,  11.22497216])
LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
(3.7416573867739413, 11.224972160321824)

numpy.shape

numpy.shape(a)返回数组的形状。

Parameters:

• a：array_like
  • 输入数组。

Returns:

• shape：tuple of ints
  • shape tuple的元素给出了相应数组维度的长度。

Examples：

np.shape(np.eye(3))
(3, 3)
np.shape([[1, 3]])
(1, 2)
np.shape([0])
(1,)
np.shape(0)
()

a = np.array([(1, 2), (3, 4), (5, 6)],
             dtype=[('x', 'i4'), ('y', 'i4')])
np.shape(a)
(3,)
a.shape
(3,)

numpy.hstack

numpy.hstack(tup, *, dtype=None, casting=’same_kind’)按顺序水平堆栈数组(以列为单位)。

这相当于沿着第二个轴连接，除了沿着第一个轴连接的1-D 数组。重新生成除以 hsplit 的数组。

这个函数对于最多3维的数组最有意义。例如，对于具有高度(第一轴)、宽度(第二轴)和 r/g/b 通道(第三轴)的像素数据。函数级联、堆栈和块提供了更通用的堆栈和级联操作。

Parameters:

• tup：sequence of ndarrays

  • 除了第二个轴之外，所有数组的形状都必须相同，除了可以是任意长度的1-D 数组。

• dtype：str or dtype

  • 如果提供，目标数组将具有此 dtype。不能与 out 一起提供。
  • .. versionadded:: 1.24

• casting：{‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional

  • 控制可能发生的数据类型转换。默认为“ same _ kind”。
  • .. versionadded:: 1.24

Returns:

• stacked：ndarray
  • 通过给定数组堆叠形成的数组。

Examples：

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

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