NumPy-1-26-中文文档-十一-

NumPy 1.26 中文文档（十一）

原文：numpy.org/doc/

numpy.fromstring

原文：numpy.org/doc/1.26/reference/generated/numpy.fromstring.html

numpy.fromstring(string, dtype=float, count=-1, *, sep, like=None)

从字符串中的文本数据初始化的新 1-D 数组。

参数：

stringstr

包含数据的字符串。

dtype数据类型，可选项

数组的数据类型；默认值：float。对于二进制输入数据，数据必须完全符合此格式。大多数内置的数值类型都受支持，扩展类型可能也受支持。

1.18.0 版的新功能：复杂的数据类型。

countint, 可选项

从数据中读取此数量的dtype元素。如果这是负数（默认值），则计数将根据数据的长度确定。

sepstr, 可选项

分隔数据中数字的字符串；元素之间的额外空白也将被忽略。

自 1.14 版本起已废弃：传递sep=''，即默认值，已被弃用，因为它会触发此函数的过时二进制模式。此模式将string解释为二进制字节，而不是包含十进制数字的 ASCII 文本，在这种情况下更好拼写为frombuffer(string, dtype, count)。如果string包含 unicode 文本，fromstring的二进制模式确实会先使用 utf-8 将其编码为字节，这不会产生理智的结果。

likearray_like, 可选项

引用对象，允许创建不是 NumPy 数组的数组。如果传入作为like支持__array_function__协议的类似数组，结果将由其定义。在这种情况下，它确保创建与通过此参数传入的兼容的数组对象。

1.20.0 版的新功能。

返回：

arrndarray

构建的数组。

引发：

ValueError

如果字符串不是满足请求的dtype和count的正确尺寸。

参见

frombuffer, fromfile, fromiter

示例

>>> np.fromstring('1 2', dtype=int, sep=' ')
array([1, 2])
>>> np.fromstring('1, 2', dtype=int, sep=',')
array([1, 2]) 

numpy.ndarray.tofile

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.tofile.html

方法

ndarray.tofile(fid, sep='', format='%s')

将数组写入文件作为文本或二进制（默认）。

数据始终以“C”顺序写入，而与 a 的顺序无关。通过此方法生成的数据可以使用 fromfile() 函数恢复。

参数：

fidfile 或 str 或 Path

一个打开的文件对象，或包含文件名的字符串。

在版本 1.17.0 中更改：现在接受 pathlib.Path 对象。

sepstr

用于文本输出的数组项之间的分隔符。如果是“”（空），则写入二进制文件，相当于 file.write(a.tobytes())。

formatstr

用于文本文件输出的格式字符串。数组中的每个条目都通过首先将其转换为最接近的 Python 类型，然后使用“format” % item 来格式化为文本。

注释

这是一个用于快速存储数组数据的便利函数。有关字节序和精度的信息将丢失，因此该方法不适合用于旨在存档数据或在具有不同字节序的机器之间传输数据的文件。通过将数据输出为文本文件，可以克服其中一些问题，但会以速度和文件大小为代价。

当 fid 是文件对象时，数组内容将直接写入文件，绕过文件对象的 write 方法。因此，无法将 tofile 用于支持压缩的文件对象（例如 GzipFile）或不支持 fileno() 的文件样对象（例如 BytesIO）。

numpy.ndarray.tolist

原文：numpy.org/doc/1.26/reference/generated/numpy.ndarray.tolist.html

方法

ndarray.tolist()

将数组作为a.ndim级深度嵌套的 Python 标量列表返回。

将数组数据作为（嵌套的）Python 列表的副本返回。数据项将转换为最接近的兼容内置 Python 类型，通过item函数。

如果a.ndim为 0，则由于嵌套列表的深度为 0，它根本不会是一个列表，而是一个简单的 Python 标量。

参数：

none

返回：

y对象，或对象列表，或对象列表的列表，或…

可能嵌套的数组元素列表。

注意

可能通过a = np.array(a.tolist())重新创建数组，尽管这有时可能会丢失精度。

示例

对于一维数组，a.tolist()几乎与list(a)相同，只是tolist将 numpy 标量更改为 Python 标量：

>>> a = np.uint32([1, 2])
>>> a_list = list(a)
>>> a_list
[1, 2]
>>> type(a_list[0])
<class 'numpy.uint32'>
>>> a_tolist = a.tolist()
>>> a_tolist
[1, 2]
>>> type(a_tolist[0])
<class 'int'> 

另外，对于二维数组，tolist会递归应用：

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

这种递归的基本情况是 0 维数组：

>>> a = np.array(1)
>>> list(a)
Traceback (most recent call last):
  ...
TypeError: iteration over a 0-d array
>>> a.tolist()
1 

numpy.array2string

原文：numpy.org/doc/1.26/reference/generated/numpy.array2string.html

numpy.array2string(a, max_line_width=None, precision=None, suppress_small=None, separator=' ', prefix='', style=<no value>, formatter=None, threshold=None, edgeitems=None, sign=None, floatmode=None, suffix='', *, legacy=None)

返回数组的字符串表示。

参数：

andarray

输入数组。

max_line_widthint，可选

如果文本超过max_line_width就插入换行符。默认为numpy.get_printoptions()['linewidth']。

precisionint 或 None，可选

浮点精度。默认为numpy.get_printoptions()['precision']。

suppress_smallbool，可选

将接近零的数字表示为零；默认为 False。接近的定义取决于精度：例如，如果精度为 8，小于 5e-9（绝对值）的数字将表示为零。默认为numpy.get_printoptions()['suppress']。

separatorstr，可选

在元素之间插入。

prefixstr，可选

suffixstr，可选

前缀和后缀字符串的长度分别用于对齐和换行输出。数组通常打印为：

prefix + array2string(a) + suffix 

输出左边填充了前缀字符串的长度，并且在列max_line_width - len(suffix)处强制换行。应注意前缀和后缀字符串的内容不包括在输出中。

style_NoValue，可选

没有效果，不要使用。

自版本 1.14.0 起废弃。

formatter可调用的字典，可选

如果不是 None，则键应指示相应格式化函数适用于哪些类型。可调用函数应返回字符串。通过默认格式化程序处理未指定（通过相应键）的类型。可以设置格式化程序的独立类型包括：

• ‘bool’

• ‘int’

• ‘timedelta’：一个numpy.timedelta64

• ‘datetime’：一个numpy.datetime64

• ‘float’

• ‘longfloat’：128 位浮点数

• ‘complexfloat’

• ‘longcomplexfloat’：由两个 128 位浮点数组成

• ‘void’：类型numpy.void

• ‘numpystr’：类型numpy.bytes_和numpy.str_

可以用来一次设置一组类型的其他键有：

• ‘all’：设置所有类型

• ‘int_kind’：设置为‘int’

• ‘float_kind’：设置为‘float’和‘longfloat’

• ‘complex_kind’：设置为‘complexfloat’和‘longcomplexfloat’

• ‘str_kind’：设置为‘numpystr’

thresholdint，可选

数组元素的总数，触发摘要而不是完整 repr。默认为numpy.get_printoptions()['threshold']。

edgeitemsint，可选

每个维度初始和结尾的摘要中的数组项数。默认为numpy.get_printoptions()['edgeitems']。

signstring，可以是‘-’，‘+’或‘ ’，可选

控制浮点类型的符号打印。如果为‘+’，则始终打印正值的符号。如果为‘ ’，则始终在正值的符号位置打印一个空格（空白字符）。如果为‘-’，则省略正值的符号字符。默认为numpy.get_printoptions()['sign']。

floatmode字符串，可选

控制浮点类型的precision选项的解释。默认为numpy.get_printoptions()['floatmode']。可以采用以下值：

• ‘fixed’: 总是精确打印precision个小数位数，即使这将打印多或少位数比唯一指定值所需的位数。

• ‘unique’: 打印表示每个值独特性所需的最小小数位数。不同元素可能具有不同数量的数字。precision选项的值被忽略。

• ‘maxprec’: 最多打印precision个小数位数，但是如果元素可以用更少的位数唯一表示，则只对其使用少量位数。

• ‘maxprec_equal’: 最多打印precision个小数位数，但是如果数组中的每个元素可以用更少的位数唯一表示，则对所有元素都使用该数量的位数。

legacy字符串或False，可选

如果设置为字符串‘1.13’，则启用 1.13 版遗留打印模式。通过在浮点数的符号位置包括一个空格以及处理 0d 数组的不同行为，来近似 numpy 1.13 版的打印输出。如果设置为False，则禁用遗留模式。无法识别的字符串将因前向兼容性而受到警告而被忽略。

在 1.14.0 版中新增。

返回：

array_strstr

数组的字符串表示。

引发：

TypeError

如果formatter中的可调用对象不返回字符串。

另请参阅

array_str, array_repr, set_printoptions, get_printoptions

注意

如果为某种类型指定了格式化程序，则该类型的precision关键字将被忽略。

这是一个非常灵活的函数；array_repr 和 array_str 在内部使用 array2string，因此具有相同名称的关键字在这三个函数中应该以相同的方式工作。

示例

>>> x = np.array([1e-16,1,2,3])
>>> np.array2string(x, precision=2, separator=',',
...                       suppress_small=True)
'[0.,1.,2.,3.]' 

>>> x  = np.arange(3.)
>>> np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x})
'[0.00 1.00 2.00]' 

>>> x  = np.arange(3)
>>> np.array2string(x, formatter={'int':lambda x: hex(x)})
'[0x0 0x1 0x2]' 

numpy.array_repr

原文：numpy.org/doc/1.26/reference/generated/numpy.array_repr.html

numpy.array_repr(arr, max_line_width=None, precision=None, suppress_small=None)

返回数组的字符串表示。

参数：

arrndarray

输入数组。

max_line_widthint，可选

如果文本超过max_line_width，则插入换行符。默认为numpy.get_printoptions()['linewidth']。

precisionint，可选

浮点数精度。默认为numpy.get_printoptions()['precision']。

suppress_smallbool，可选

将“非常接近”零的数字表示为零；默认值为 False。非常接近由精度定义：例如，如果精度为 8，则绝对值小于 5e-9 的数字将表示为零。默认为numpy.get_printoptions()['suppress']。

返回：

stringstr

数组的字符串表示。

另请参阅

array_str, array2string, set_printoptions

示例

>>> np.array_repr(np.array([1,2]))
'array([1, 2])'
>>> np.array_repr(np.ma.array([0.]))
'MaskedArray([0.])'
>>> np.array_repr(np.array([], np.int32))
'array([], dtype=int32)' 

>>> x = np.array([1e-6, 4e-7, 2, 3])
>>> np.array_repr(x, precision=6, suppress_small=True)
'array([0.000001,  0\.      ,  2\.      ,  3\.      ])' 

numpy.array_str

原文：numpy.org/doc/1.26/reference/generated/numpy.array_str.html

numpy.array_str(a, max_line_width=None, precision=None, suppress_small=None)

返回数组中数据的字符串表示。

数组中的数据以单个字符串返回。此函数类似于array_repr，不同之处在于array_repr还返回有关数组类型和数据类型的信息。

参数：

andarray

输入数组。

max_line_widthint, 可选

如果文本长度超过max_line_width，则插入换行符。默认为numpy.get_printoptions()['linewidth']。

precisionint, 可选

浮点数精度。默认为numpy.get_printoptions()['precision']。

suppress_smallbool, 可选

将“接近”零的数字表示为零；默认为 False。非常接近根据精度定义：例如，如果精度为 8，则绝对值较小（绝对值）的数字小于 5e-9 将表示为零。默认为numpy.get_printoptions()['suppress']。

参见

array2string, array_repr, set_printoptions

示例

>>> np.array_str(np.arange(3))
'[0 1 2]' 

numpy.format_float_positional

原文：numpy.org/doc/1.26/reference/generated/numpy.format_float_positional.html

numpy.format_float_positional(x, precision=None, unique=True, fractional=True, trim='k', sign=False, pad_left=None, pad_right=None, min_digits=None)

将浮点标量格式化为十进制字符串的位置表示。

提供对四舍五入、修剪和填充的控制。使用并假设 IEEE 无偏舍入。使用“Dragon4”算法。

参数：

x：Python 浮点数或 numpy 浮点标量

要格式化的值。

precision：非负整数或 None，可选

要打印的最大数字。如果unique是True，则可能为 None，但如果 unique 为False，则必须为整数。

unique：布尔值，可选

如果True，则使用一种数字生成策略，该策略给出了从同类型的其他值中唯一识别该浮点数的最短表示形式，通过审慎舍入。如果给出precision比必要少的数字，可以打印更少，或者如果给出min_digits更多可以打印，这种情况下最后一个数字将以无偏舍入进行四舍五入。如果False，则生成的数字就像打印无限精度值并在打印precision位后停下，使用无偏舍入对剩余值进行四舍五入

fractional：布尔值，可选

如果True，precision和min_digits的截止时间指的是小数点后的总位数，包括前导零。如果False，precision和min_digits指的是小数点之前或之后的总有效数字，忽略前导零。

trim：‘k’、‘.’、‘0’、‘-’之一，可选

控制后处理修剪末尾数字的方式，如下：

• ‘k’：保留末尾的零，保留小数点（无修剪）

• ‘.’：修剪所有末尾的零，保留小数点

• ‘0’：修剪小数点前的所有零，如果缺少零，则插入零。

• ‘-’：去除末尾的零和任何末尾的小数点

sign：布尔值，可选

是否显示正值的符号。

pad_left：非负整数，可选

用空格填充字符串的左侧，直到小数点左侧至少有这么多的字符。

pad_right：非负整数，可选

用空格填充字符串的右侧，直到小数点右侧至少有这么多的字符。

min_digits：非负整数或 None，可选

要打印的最小数字。仅在unique=True时才有效，此时可能会打印额外的数字，超出必要的数字，对最后一个附加的数字四舍五入。

–版本添加：1.21.0

返回：

rep：字符串

浮点值的字符串表示

另请参见

format_float_scientific

示例

>>> np.format_float_positional(np.float32(np.pi))
'3.1415927'
>>> np.format_float_positional(np.float16(np.pi))
'3.14'
>>> np.format_float_positional(np.float16(0.3))
'0.3'
>>> np.format_float_positional(np.float16(0.3), unique=False, precision=10)
'0.3000488281' 

numpy.memmap

原文：numpy.org/doc/1.26/reference/generated/numpy.memmap.html

class numpy.memmap(filename, dtype=<class 'numpy.ubyte'>, mode='r+', offset=0, shape=None, order='C')

创建一个内存映射到存储在磁盘上的二进制文件中的数组。

内存映射文件用于访问磁盘上大文件的小段，而无需将整个文件读入内存。NumPy 的 memmap 是类似数组的对象。这与 Python 的mmap模块不同，后者使用类似文件的对象。

这个 ndarray 的子类与一些操作有一些不愉快的交互，因为它不能完全适合作为一个子类。使用这个子类的一个替代方法是自己创建mmap对象，然后直接使用ndarray.__new__创建一个 ndarray，将创建的对象传递给它的‘buffer=’参数。

这个类可能在某个时候被转变为一个工厂函数，返回一个对 mmap 缓冲区的视图。

刷新 memmap 实例以将更改写入文件。当前没有 API 来关闭底层的mmap。确保资源实际上被关闭是棘手的，因为它可能在不同的 memmap 实例之间共享。

参数:

filenamestr、类文件对象或 pathlib.Path 实例

用作数组数据缓冲区的文件名或文件对象。

dtype数据类型，可选

用于解释文件内容的数据类型。默认是uint8。

mode，可选

文件以这种模式打开：

‘r’	只读打开现有文件。
‘r+’	打开现有文件以供读取和写入。
‘w+’	为读写创建或覆盖现有文件。如果mode == 'w+'，则必须指定shape。
‘c’	写时复制：赋值将影响内存中的数据，但更改不会保存到磁盘。磁盘上的文件是只读的。

默认是‘r+’。

offset整数，可选

在文件中，数组数据从这个偏移开始。由于offset以字节为单位，所以通常应该是dtype的字节大小的倍数。当mode != 'r'时，甚至在文件末端之后的正偏移也是有效的；文件将被扩展以容纳额外的数据。默认情况下，memmap会从文件的开头开始，即使filename是一个文件指针fp并且fp.tell() != 0也是如此。

shape元组，可选

数组的期望形状。如果mode == 'r'并且offset之后剩余的字节数不是dtype的字节大小的倍数，您必须指定shape。默认情况下，返回的数组将是 1-D，元素数量由文件大小和数据类型确定。

order，可选

指定 ndarray 内存布局的顺序: 行主序，C 风格或列主序，Fortran 风格。只有在形状大于 1-D 时才会生效。默认顺序是'C'。

另请参阅

lib.format.open_memmap

创建或加载内存映射的.npy文件。

注释

内存映射对象可以在任何接受 ndarray 的地方使用。给定内存映射fp，isinstance(fp, numpy.ndarray) 返回True。

32 位系统上内存映射文件的大小不能超过 2GB。

当内存映射导致文件在文件系统中创建或扩展到当前大小之外时，新部分的内容是未指定的。在具有 POSIX 文件系统语义的系统上，扩展部分将填充为零字节。

示例

>>> data = np.arange(12, dtype='float32')
>>> data.resize((3,4)) 

此示例使用临时文件，以便 doctest 不会将文件写入您的目录。您可以使用“常规”文件名。

>>> from tempfile import mkdtemp
>>> import os.path as path
>>> filename = path.join(mkdtemp(), 'newfile.dat') 

创建一个 dtype 和形状与我们的数据相匹配的内存映射:

>>> fp = np.memmap(filename, dtype='float32', mode='w+', shape=(3,4))
>>> fp
memmap([[0., 0., 0., 0.],
 [0., 0., 0., 0.],
 [0., 0., 0., 0.]], dtype=float32) 

将数据写入内存映射数组:

>>> fp[:] = data[:]
>>> fp
memmap([[  0.,   1.,   2.,   3.],
 [  4.,   5.,   6.,   7.],
 [  8.,   9.,  10.,  11.]], dtype=float32) 

>>> fp.filename == path.abspath(filename)
True 

将内存中的更改刷新到磁盘，以便读取。

>>> fp.flush() 

加载内存映射并验证数据已存储:

>>> newfp = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
>>> newfp
memmap([[  0.,   1.,   2.,   3.],
 [  4.,   5.,   6.,   7.],
 [  8.,   9.,  10.,  11.]], dtype=float32) 

只读内存映射:

>>> fpr = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
>>> fpr.flags.writeable
False 

写时复制的内存映射:

>>> fpc = np.memmap(filename, dtype='float32', mode='c', shape=(3,4))
>>> fpc.flags.writeable
True 

可以对写时复制数组进行赋值，但值只会写入数组的内存副本，不会写入磁盘：

>>> fpc
memmap([[  0.,   1.,   2.,   3.],
 [  4.,   5.,   6.,   7.],
 [  8.,   9.,  10.,  11.]], dtype=float32)
>>> fpc[0,:] = 0
>>> fpc
memmap([[  0.,   0.,   0.,   0.],
 [  4.,   5.,   6.,   7.],
 [  8.,   9.,  10.,  11.]], dtype=float32) 

磁盘上的文件不变:

>>> fpr
memmap([[  0.,   1.,   2.,   3.],
 [  4.,   5.,   6.,   7.],
 [  8.,   9.,  10.,  11.]], dtype=float32) 

内存映射的偏移量:

>>> fpo = np.memmap(filename, dtype='float32', mode='r', offset=16)
>>> fpo
memmap([  4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.], dtype=float32) 

属性：

filenamestr 或 pathlib.Path 实例

映射文件的路径。

offset整数

文件中的偏移位置。

mode字符串

文件模式。

方法

flush()	将数组中的任何更改写入磁盘上的文件。

numpy.lib.format.open_memmap

原文：numpy.org/doc/1.26/reference/generated/numpy.lib.format.open_memmap.html

lib.format.open_memmap(filename, mode='r+', dtype=None, shape=None, fortran_order=False, version=None, *, max_header_size=10000)

打开一个.npy 文件作为内存映射的数组。

可用于读取现有文件或创建新文件。

参数：

filename字符串或类似路径的对象

磁盘上的文件名。这可能不是类似文件的对象。

mode字符串，可选

打开文件的模式；默认值为‘r+’。除了标准文件模式外，‘c’也可表示“写时复制”。有关可用模式字符串，请参见memmap。

dtype数据类型，可选

如果我们在“写”模式下创建新文件，此为数组的数据类型，如果不是，则忽略dtype。默认值为 None，导致数据类型为float64。

形状整数的元组

如果我们在“写”模式下创建新文件，则为数组的形状，此时此参数是必需的。否则，此参数将被忽略，因此是可选的。

fortran_order布尔值，可选

如果我们在“写”模式下创建新文件，则数组应该是 Fortran 连续的（True）还是 C 连续的（False，默认）。

version整数的元组（主要，次要）或 None

如果模式是“写”模式，那么这是用于创建文件的文件格式的版本。None 表示使用能够存储数据的最旧支持的版本。默认值：None

max_header_size整数，可选

头部的最大允许大小。大头部可能不安全，因此需要显式传递一个更大的值。有关详情，请参见ast.literal_eval。

返回：

marray内存映射

内存映射数组。

引发：

ValueError

如果数据或模式无效。

OSError

如果未找到文件或无法正确打开文件。

另见

numpy.memmap

numpy.set_printoptions

原文：numpy.org/doc/1.26/reference/generated/numpy.set_printoptions.html

numpy.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, suppress=None, nanstr=None, infstr=None, formatter=None, sign=None, floatmode=None, *, legacy=None)

设置打印选项。

这些选项决定了浮点数、数组和其他 NumPy 对象的显示方式。

参数：

精度整数或 None，可选

浮点数输出精度的位数（默认 8）。如果 floatmode 不是 fixed，则可以为 None，以打印出足够唯一指定数值所需的位数。

阈值整数，可选

触发摘要显示而不是完整表示的数组元素的总数（默认 1000）。要始终使用完整表示而不用摘要，传递 sys.maxsize。

edgeitems整数，可选

每个维度的开始和结束处汇总的数组项数（默认 3）。

linewidth整数，可选

每行字符数，用于插入换行符（默认 75）。

suppress布尔值，可选

如果为 True，则总是使用固定点表示法打印浮点数，此时在当前精度下等于零的数将打印为零。如果为 False，则当最小数的绝对值 < 1e-4 或最大绝对值与最小绝对值的比率 > 1e3 时，使用科学计数法。默认值为 False。

nanstr字符串，可选

浮点数的非数字的字符串表示（默认 nan）。

infstr字符串，可选

浮点数无穷的字符串表示（默认 inf）。

符号字符串，‘-’、‘+’或‘’，可选

控制浮点类型的符号打印。如果为‘+’，总是打印正值的符号。如果为‘ ’，总是在正值的符号位置打印一个空格（空白字符）。如果为‘-’，省略正值的符号字符（默认‘-’）

格式化器可调用的字典，可选

如果不为 None，则键应指示相应格式化函数适用于的类型。可调用对象应返回一个字符串。未通过指定（由其相应键）的类型由默认格式化器处理。可以设置格式化器的个别类型是：

• ‘bool’

• ‘int’

• ‘timedelta’：numpy.timedelta64

• ‘datetime’：numpy.datetime64

• ‘float’

• ‘longfloat’：128 位浮点数

• ‘complexfloat’

• ‘longcomplexfloat’：由两个 128 位浮点数组成

• ‘numpystr’：类型numpy.bytes_和numpy.str_

• ‘object’：np.object_ 数组

可用的其他键可以用于一次设置一组类型：

• ‘all’：设置所有类型

• ‘int_kind’：设置‘int’

• ‘float_kind’：设置‘float’和‘longfloat’

• ‘complex_kind’：设置‘complexfloat’和‘longcomplexfloat’

• ‘str_kind’：设置‘numpystr’

floatmode字符串，可选

控制浮点类型的precision选项的解释。可以取以下值（默认值为 maxprec_equal）：

• ‘fixed’: 总是精确打印precision个小数位，

  即使有可能打印的位数多或少于唯一指定该值所需的位数。

• ‘unique’: 只打印为了指定值所需的最少小数位数

  以唯一方式表示每个值。不同的元素可以有不同数量的位数。忽略precision选项的值。

• ‘maxprec’: 最多打印precision个小数位，但如果

  一个元素如果只需较少的数字就能唯一表示，则只打印对应数量的数字。

• ‘maxprec_equal’: 最多打印precision个小数位，

  但如果数组中的每个元素都可以用较少的相等数字唯一表示，则所有元素都使用同样数量的数字。

legacy字符串或False，可选

如果设为字符串‘1.13’则启用 1.13 版的旧版打印模式。这样可以通过在浮点数的符号位置包含一个空格以及对 0 维数组有不同的行为来近似 numpy 1.13 版本的打印输出。这也启用了 1.21 版的旧版打印模式（下面有描述）。

如果设为字符串‘1.21’则启用 1.21 版的旧版打印模式。这样可以通过不在逗号后面和冒号后面插入空格来近似 numpy 1.21 版本对复杂结构数据类型的打印输出。

如果设为False，则禁用旧版模式。

无法识别的字符串将被忽略，并给出警告以保持向前兼容性。

新版本为 1.14.0。

从 1.22.0 版本开始发生变化。

另请参见

get_printoptions, printoptions, set_string_function, array2string

注意

formatter总是通过调用set_printoptions来重设的。

使用printoptions作为上下文管理器临时设定值。

示例

浮点数精度可以设定：

>>> np.set_printoptions(precision=4)
>>> np.array([1.123456789])
[1.1235] 

可以概要显示长数组：

>>> np.set_printoptions(threshold=5)
>>> np.arange(10)
array([0, 1, 2, ..., 7, 8, 9]) 

可以抑制小结果：

>>> eps = np.finfo(float).eps
>>> x = np.arange(4.)
>>> x**2 - (x + eps)**2
array([-4.9304e-32, -4.4409e-16,  0.0000e+00,  0.0000e+00])
>>> np.set_printoptions(suppress=True)
>>> x**2 - (x + eps)**2
array([-0., -0.,  0.,  0.]) 

可以使用自定义格式化程序来显示所需的数组元素：

>>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)})
>>> x = np.arange(3)
>>> x
array([int: 0, int: -1, int: -2])
>>> np.set_printoptions()  # formatter gets reset
>>> x
array([0, 1, 2]) 

若要恢复默认选项，可以使用：

>>> np.set_printoptions(edgeitems=3, infstr='inf',
... linewidth=75, nanstr='nan', precision=8,
... suppress=False, threshold=1000, formatter=None) 

也可以使用printoptions作为上下文管理器临时覆盖选项：

>>> with np.printoptions(precision=2, suppress=True, threshold=5):
...     np.linspace(0, 10, 10)
array([ 0\.  ,  1.11,  2.22, ...,  7.78,  8.89, 10\.  ]) 

numpy.get_printoptions

原文：numpy.org/doc/1.26/reference/generated/numpy.get_printoptions.html

numpy.get_printoptions()

返回当前打印选项。

返回：

print_opts字典

具有键的当前打印选项字典

• precision : 整数
• threshold : 整数
• edgeitems : 整数
• linewidth : 整数
• suppress : 布尔值
• nanstr : 字符串
• infstr : 字符串
• formatter : 函数字典
• sign : 字符串

有关这些选项的详细描述，请参见set_printoptions。

另请参阅

set_printoptions, printoptions, set_string_function

numpy.set_string_function

原文：numpy.org/doc/1.26/reference/generated/numpy.set_string_function.html

numpy.set_string_function(f, repr=True)

设置在美观打印数组时使用的 Python 函数。

参数:

f 函数或 None

用于美观打印数组的函数。该函数应该期望一个单一的数组参数，并返回数组表示的字符串。如果为 None，则该函数将重置为默认的 NumPy 函数以打印数组。

repr 布尔值，可选

如果为 True（默认值），则设置用于美观打印（__repr__）的函数，如果为 False，则设置返回默认字符串表示（__str__）的函数。

另请参阅

set_printoptions, get_printoptions

示例

>>> def pprint(arr):
...     return 'HA! - What are you going to do now?'
...
>>> np.set_string_function(pprint)
>>> a = np.arange(10)
>>> a
HA! - What are you going to do now?
>>> _ = a
>>> # [0 1 2 3 4 5 6 7 8 9] 

我们可以将函数重置为默认值：

>>> np.set_string_function(None)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 

repr 影响美观打印或正常字符串表示。请注意，通过设置 __str__ 仍然会影响 __repr__，因为返回的字符串中每个数组元素的宽度变为 __str__() 结果的长度。

>>> x = np.arange(4)
>>> np.set_string_function(lambda x:'random', repr=False)
>>> x.__str__()
'random'
>>> x.__repr__()
'array([0, 1, 2, 3])' 

numpy.printoptions

原文：numpy.org/doc/1.26/reference/generated/numpy.printoptions.html

numpy.printoptions(*args, **kwargs)

用于设置打印选项的上下文管理器。

在with块的范围内设置打印选项，并在结束时恢复旧选项。有关可用选项的完整描述，请参阅set_printoptions。

另请参阅

set_printoptions，get_printoptions

示例

>>> from numpy.testing import assert_equal
>>> with np.printoptions(precision=2):
...     np.array([2.0]) / 3
array([0.67]) 

with语句的as子句提供当前的打印选项：

>>> with np.printoptions(precision=2) as opts:
...      assert_equal(opts, np.get_printoptions()) 

numpy.binary_repr

原文：numpy.org/doc/1.26/reference/generated/numpy.binary_repr.html

numpy.binary_repr(num, width=None)

将输入数字的二进制表示作为字符串返回。

对于负数，如果未给定 width，则在前面添加负号。如果给定了 width，则返回该数字的二进制补码，相对于该宽度。

在二进制补码系统中，负数由绝对值的补码表示。这是计算机上表示带符号整数的最常见方法[1]。 N 位二进制补码系统可以表示范围在(-2^{N-1})到( +2^{N-1}-1)中的每个整数。

参数：

numint

只能使用整数十进制数。

widthint，可选

如果 num 为正数，则返回的字符串的长度，或者如果 num 为负数，则返回的二进制补码的长度，条件是 width 至少为表示 num 所需的指定形式的位数。

如果 width 值不够，它将被忽略，并且 num 将以二进制（num > 0）或二进制补码（num < 0）的形式返回，其宽度等于表示以指定形式表示该数字所需的最小位数。此行为已不推荐使用，以后将会报错。

自版本 1.12.0 起已弃用。

返回：

binstr

num 的二进制表示或 num 的二进制补码。

亦参见

base_repr

返回给定基数系统中数字的字符串表示。

bin

Python 内置的整数二进制表示生成器。

注

binary_repr 等同于使用 base_repr 以基数为 2，但约快 25 倍。

参考

[1]

维基百科，“二进制补码”，zh.wikipedia.org/wiki/二进制补码

示例

>>> np.binary_repr(3)
'11'
>>> np.binary_repr(-3)
'-11'
>>> np.binary_repr(3, width=4)
'0011' 

当输入数字为负数且指定了宽度时，返回二进制补码：

>>> np.binary_repr(-3, width=3)
'101'
>>> np.binary_repr(-3, width=5)
'11101' 

numpy.base_repr

原文：numpy.org/doc/1.26/reference/generated/numpy.base_repr.html

numpy.base_repr(number, base=2, padding=0)

返回给定基数系统中数字的字符串表示。

参数：

numberint

要转换的值。处理正负值。

baseint，可选

将number转换为base数字系统。有效范围为 2-36，默认值为 2。

paddingint，可选

左侧填充的零的数量。默认为 0（无填充）。

返回：

outstr

在base系统中number的字符串表示。

参见

binary_repr

用于基数为 2 的快速版本base_repr。

示例

>>> np.base_repr(5)
'101'
>>> np.base_repr(6, 5)
'11'
>>> np.base_repr(7, base=5, padding=3)
'00012' 

>>> np.base_repr(10, base=16)
'A'
>>> np.base_repr(32, base=16)
'20' 

numpy.DataSource

原文：numpy.org/doc/1.26/reference/generated/numpy.DataSource.html

class numpy.DataSource(destpath='.')

通用数据源文件（文件，http，ftp，…）。

数据源可以是本地文件或远程文件/URL。文件也可以是压缩或未压缩的。DataSource 隐藏了一些下载文件的底层细节，允许您简单地传入有效的文件路径（或 URL）并获取文件对象。

参数：

destpathstr 或 None，可选

源文件下载到的目录路径以供使用。如果destpath为 None，则将创建一个临时目录。默认路径为当前目录。

注意

URL 需要使用方案字符串（http://）才能正常使用，否则它们将失败：

>>> repos = np.DataSource()
>>> repos.exists('www.google.com/index.html')
False
>>> repos.exists('http://www.google.com/index.html')
True 

当 DataSource 被删除时，临时目录也会被删除。

示例

>>> ds = np.DataSource('/home/guido')
>>> urlname = 'http://www.google.com/'
>>> gfile = ds.open('http://www.google.com/')
>>> ds.abspath(urlname)
'/home/guido/www.google.com/index.html'

>>> ds = np.DataSource(None)  # use with temporary file
>>> ds.open('/home/guido/foobar.txt')
<open file '/home/guido.foobar.txt', mode 'r' at 0x91d4430>
>>> ds.abspath('/home/guido/foobar.txt')
'/tmp/.../home/guido/foobar.txt' 

方法

abspath(path)	返回 DataSource 目录中文件的绝对路径。
exists(path)	检查路径是否存在。
open(path[, mode, encoding, newline])	打开并返回类似文件的对象。

numpy.lib.format

原文：numpy.org/doc/1.26/reference/generated/numpy.lib.format.html

二进制序列化

NPY 格式

一个简单的格式，用于将 NumPy 数组保存到磁盘，并包含有关它们的完整信息。

.npy 格式是 NumPy 中用于将单个任意 NumPy 数组持久化到磁盘的标准二进制文件格式。该格式存储了重建数组所需的所有形状和数据类型信息，即使在具有不同架构的另一台机器上也能正确重建数组。该格式旨在尽可能简单，同时实现其有限的目标。

.npz 格式是将多个 NumPy 数组持久化到磁盘的标准格式。一个.npz文件是一个 zip 文件，包含多个.npy文件，每个文件对应一个数组。

能力

• 可以表示所有 NumPy 数组，包括嵌套记录数组和对象数组。

• 以其本机二进制形式表示数据。

• 直接支持 Fortran 连续数组。

• 存储了重建数组所需的所有信息，包括在不同架构的机器上的形状和数据类型。支持小端和大端数组，具有小端数字的文件将在任何读取该文件的机器上产生小端数组。类型是根据它们的实际大小描述的。例如，如果一个具有 64 位 C “long int”的机器写出一个带有“long ints”的数组，那么一个具有 32 位 C “long ints”的读取机器将产生一个带有 64 位整数的数组。

• 容易被逆向工程。数据集通常比创建它们的程序存在时间更长。一个称职的开发者应该能够用他们喜欢的编程语言创建一个解决方案，以读取大部分没有太多文档的.npy文件。

• 允许内存映射数据。参见open_memmap。

• 可以从类似文件的流对象而不是实际文件中读取。

• 存储对象数组，即包含任意 Python 对象的数组。具有对象数组的文件不能进行内存映射，但可以读取和写入磁盘。

限制

• numpy.ndarray 的任意子类并不完全保留。子类将被接受用于写入，但只有数组数据将被写出。在读取文件时将创建一个常规的 numpy.ndarray 对象。

警告

由于对结构化数据类型的解释存在限制，具有空名称字段的数据类型将被替换为‘f0’、‘f1’等。这样的数组将无法完全准确地通过格式循环。数据是完整的；只有字段名称会有所不同。我们正在努力解决这个问题。这个修复不需要更改文件格式。具有这种结构的数组仍然可以保存和恢复，并且可以通过使用loadedarray.view(correct_dtype)方法恢复正确的数据类型。

文件扩展名

我们建议使用.npy和.npz扩展名保存此格式的文件。这绝不是必须的；应用程序可能希望使用这些文件格式，但使用特定于应用程序的扩展名。然而，在没有明显替代方案的情况下，我们建议使用.npy和.npz。

版本编号

这些格式的版本编号与 NumPy 版本编号是独立的。如果格式升级，numpy.io中的代码仍将能够读取和写入版本 1.0 文件。

格式版本 1.0

前 6 个字节是一个魔术字符串：正好为\x93NUMPY。

接下来的 1 个字节是无符号字节：文件格式的主要版本号，例如\x01。

接下来的 1 个字节是无符号字节：文件格式的次要版本号，例如\x00。注意：文件格式的版本与 numpy 软件包的版本无关。

接下来的 2 个字节形成一个小端无符号短整型：头数据 HEADER_LEN 的长度。

接下来的 HEADER_LEN 字节形成描述数组格式的头数据。这是一个 ASCII 字符串，包含一个字典的 Python 文字表达式。它以换行符（\n）结尾，并用空格（\x20）填充，使得len(magic string) + 2 + len(length) + HEADER_LEN的总和能够被 64 整除，以��对齐。

字典包含三个键：

“descr”dtype.descr

可作为参数传递给numpy.dtype构造函数以创建数组 dtype 的对象。

“fortran_order”布尔值

数组数据是否是 Fortran 连续的。由于 Fortran 连续数组是一种常见的非 C 连续形式，我们允许它们直接写入磁盘以提高效率。

“shape”整数元组

数组的形状。

为了重复性和可读性，字典键按字母顺序排序。这仅为方便起见。作者应尽可能实现这一点。读者不应依赖于此。

在头部之后是数组数据。如果 dtype 包含 Python 对象（即dtype.hasobject is True），则数据是数组的 Python pickle。否则，数据是数组的连续（无论是 C 还是 Fortran，取决于fortran_order）字节。消费者可以通过将形状给定的元素数量相乘（注意shape=()表示有 1 个元素）乘以dtype.itemsize来计算字节数。

格式版本 2.0

版本 1.0 格式仅允许数组头的总大小为 65535 字节。结构化数组的列数较多时可能会超过此限制。版本 2.0 格式将头大小扩展到 4 GiB。numpy.save将根据数据的需要自动保存为 2.0 格式，否则将始终使用更兼容的 1.0 格式。

因此，头的第四个元素的描述变为：“接下来的 4 个字节形成一个小端无符号整型：头数据 HEADER_LEN 的长度。”

格式版本 3.0

这个版本用 utf8 编码的字符串替换了 ASCII 字符串（实际上是 latin1），因此支持具有任何 Unicode 字段名称的结构化类型。

注意

.npy 格式，包括创建动机和替代方案的比较，在 “npy-format” NEP 中有描述，但随着时间的推移，细节已经发生变化，本文档更为当前。

函数

descr_to_dtype(descr)	根据给定描述返回 dtype。
dtype_to_descr(dtype)	从 dtype 获取可序列化的描述符。
header_data_from_array_1_0(array)	从 numpy.ndarray 获取头部元数据的字典。
magic(major, minor)	返回给定文件格式版本的魔术字符串。
open_memmap(filename[, mode, dtype, shape, ...])	将 .npy 文件作为内存映射数组打开。
read_array(fp[, allow_pickle, ...])	从 NPY 文件中读取数组。
read_array_header_1_0(fp[, max_header_size])	使用 1.0 文件格式版本从文件对象中读取数组头。
read_array_header_2_0(fp[, max_header_size])	使用 2.0 文件格式版本从文件对象中读取数组头。
read_magic(fp)	读取魔术字符串以获取文件格式的版本。
write_array(fp, array[, version, ...])	将数组写入 NPY 文件，包括头部。
write_array_header_1_0(fp, d)	使用 1.0 格式写入数组头。
write_array_header_2_0(fp, d)	使用 2.0 格式写入数组头。

NPY 格式

用于将 numpy 数组保存到磁盘的简单格式，包含有关它们的所有信息。

.npy 格式是 NumPy 中用于在磁盘上持久化单个任意 NumPy 数组的标准二进制文件格式。该格式存储了重建数组所需的所有形状和 dtype 信息，即使在具有不同架构的另一台机器上也能正确重建数组。该格式旨在尽可能简单，同时实现其有限的目标。

.npz 格式是在磁盘上持久化多个 NumPy 数组的标准格式。一个 .npz 文件是一个 zip 文件，包含多个 .npy 文件，每个文件对应一个数组。

能力

• 可以表示所有 NumPy 数组，包括嵌套记录数组和对象数组。

• 以其本机二进制形式表示数据。

• 直接支持 Fortran 连续数组。

• 存储了重建数组所需的所有信息，包括形状和 dtype，在具有不同架构的机器上。支持小端和大端数组，并且具有小端数字的文件将在读取文件的任何机器上产生小端数组。类型是根据其实际大小描述的。例如，如果具有 64 位 C “long int”的机器写出一个带有“long ints”的数组，那么具有 32 位 C “long ints”的读取机器将产生一个带有 64 位整数的数组。

• 易于逆向工程。数据集通常比创建它们的程序存在时间更长。一位称职的开发人员应该能够使用他们喜欢的编程语言创建一个解决方案，以读取大部分给定的 .npy 文件而无需太多文档。

• 允许对数据进行内存映射。参见 open_memmap。

• 可以从类似文件流对象而不是实际文件中读取。

• 存储对象数组，即包含任意 Python 对象的数组。具有对象数组的文件不能进行内存映射，但可以读取和写入磁盘。

限制

• 任意的 numpy.ndarray 子类并不完全保留。子类将被接受进行写入，但只有数组数据将被写出。在读取文件时将创建一个常规的 numpy.ndarray 对象。

警告

由于对结构化 dtypes 的解释存在限制，具有空名称字段的 dtypes 将其名称替换为‘f0’、‘f1’等。这样的数组将无法完全准确地通过格式循环。数据完整；只有字段名称会有所不同。我们正在努力解决这个问题。这个修复不需要更改文件格式。具有这种结构的数组仍然可以保存和恢复，并且可以通过使用 loadedarray.view(correct_dtype) 方法恢复正确的 dtype。

文件扩展名

我们建议使用.npy和.npz扩展名保存以这种格式保存的文件。这绝不是一个要求；应用程序可能希望使用这些文件格式，但使用特定于应用程序的扩展名。然而，在没有明显替代方案的情况下，我们建议使用.npy和.npz。

版本编号

这些格式的版本编号与 NumPy 版本编号无关。如果格式升级，numpy.io中的代码仍将能够读取和写入版本 1.0 文件。

格式版本 1.0

前 6 个字节是一个魔术字符串：确切地为\x93NUMPY。

下一个字节是一个无符号字节：文件格式的主版本号，例如\x01。

下一个字节是一个无符号字节：文件格式的次版本号，例如\x00。注意：文件格式的版本与 numpy 软件包的版本无关。

接下来的 2 个字节形成一个小端无符号短整数：头部数据 HEADER_LEN 的长度。

接下来的 HEADER_LEN 字节形成描述数组格式的头部数据。这是一个 ASCII 字符串，其中包含一个字典的 Python 文字表达式。它以换行符（\n）结尾，并用空格（\x20）填充，使得len(magic string) + 2 + len(length) + HEADER_LEN的总和能够被 64 整除，以便对齐。

字典包含三个键：

“descr”dtype.descr

一个可以作为参数传递给numpy.dtype构造函数以创建数组 dtype 的对象。

“fortran_order”布尔值

数组数据是否是 Fortran 连续的。由于 Fortran 连续数组是一种常见的非 C 连续形式，我们允许它们直接写入磁盘以提高效率。

“shape”整数元组

数组的形状。

为了重复性和可读性，字典键按字母顺序排序。这仅供方便。如果可能的话，写入者应该实现这一点。读者不应该依赖于此。

在头部之后是数组数据。如果 dtype 包含 Python 对象（即dtype.hasobject为 True），那么数据是数组的 Python pickle。否则，数据是数组的连续（无论是 C 还是 Fortran，取决于fortran_order）字节。消费者可以通过将形状给定的元素数乘以dtype.itemsize来计算字节数（注意shape=()表示有 1 个元素）。

格式版本 2.0

版本 1.0 格式只允许数组头部的总大小为 65535 字节。这可以被具有大量列的结构化数组超过。版本 2.0 格式将头部大小扩展到 4 GiB。如果数据需要，numpy.save将自动保存为 2.0 格式，否则它将始终使用更兼容的 1.0 格式。

因此，头部的第四个元素的描述变为：“接下来的 4 个字节形成一个小端无符号整数：头部数据 HEADER_LEN 的长度。”

格式版本 3.0

此版本将 ASCII 字符串（实际上是 latin1）替换为 utf8 编码的字符串，因此支持具有任何 Unicode 字段名称的结构化类型。

注意事项

描述了.npy格式，包括创建动机和与其他格式的比较，在“npy-format” NEP中，然而细节随着时间的推移而发展，这份文档更为当前。

功能

• 可以表示所有 NumPy 数组，包括嵌套记录数组和对象数组。

• 以其本机二进制形式表示数据。

• 直接支持 Fortran 连续数组。

• 存储重建数组所需的所有信息，包括在不同架构的机器上的形状和数据类型。支持小端和大端数组，并且具有小端数字的文件将在任何读取文件的机器上产生小端数组。类型是根据它们的实际大小描述的。例如，如果一个具有 64 位 C “long int”的机器写出一个带有“long ints”的数组，那么一个具有 32 位 C “long ints”的读取机器将产生一个带有 64 位整数的数组。

• 易于逆向工程。数据集通常比创建它们的程序存在时间更长。一位称职的开发人员应该能够使用他们喜欢的编程语言创建一个解决方案，以读取大多数给定的.npy文件而无需太多文档。

• 允许对数据进行内存映射。请参阅open_memmap。

• 可以从类似文件流对象而不是实际文件中读取。

• 存储对象数组，即包含任意 Python 对象的数组。具有对象数组的文件不可进行内存映射，但可以读取和写入磁盘。

限制

• 任意的 numpy.ndarray 子类不会完全保留。子类将被接受进行写入，但只有数组数据将被写出。在读取文件时将创建一个常规的 numpy.ndarray 对象。

警告

由于对结构化数据类型的解释存在限制，具有空字段名称的数据类型将被替换为‘f0’、‘f1’等。这样的数组将无法完全准确地循环通过格式。数据是完整的；只有字段名称会有所不同。我们正在努力解决这个问题。这个修复不需要更改文件格式。具有这种结构的数组仍然可以保存和恢复，并且可以通过使用loadedarray.view(correct_dtype)方法恢复正确的数据类型。

文件扩展名

我们建议使用.npy和.npz扩展名保存以这种格式保存的文件。这绝不是一个要求；应用程序可能希望使用这些文件格式，但使用特定于应用程序的扩展名。然而，在没有明显替代方案的情况下，我们建议使用.npy和.npz。

版本编号

这些格式的版本编号与 NumPy 版本编号是独立的。如果格式升级，numpy.io中的代码仍然能够读取和写入 Version 1.0 文件。

格式版本 1.0

前 6 个字节是一个魔术字符串：正好是\x93NUMPY。

接下来的 1 个字节是一个无符号字节：文件格式的主要版本号，例如\x01。

接下来的 1 个字节是一个无符号字节：文件格式的次要版本号，例如\x00。注意：文件格式的版本与 numpy 软件包的版本无关。

接下来的 2 个字节形成一个小端无符号短整数：头部数据 HEADER_LEN 的长度。

接下来的 HEADER_LEN 字节形成描述数组格式的头部数据。它是一个 ASCII 字符串，其中包含一个字典的 Python 文字表达式。它以换行符（\n）结尾，并用空格（\x20）填充，使得len(magic string) + 2 + len(length) + HEADER_LEN的总和能够被 64 整除，以便对齐。

字典包含三个键：

“descr”dtype.descr

可以作为参数传递给numpy.dtype构造函数以创建数组 dtype 的对象。

“fortran_order”bool

数组数据是否是 Fortran 连续的。由于 Fortran 连续数组是一种常见的非 C 连续形式，我们允许它们直接写入磁盘以提高效率。

“shape”int 元组

数组的形状。

为了重复性和可读性，字典键按字母顺序排序。这仅仅是为了方便。如果可能的话，写入者应该实现这一点。读者不应该依赖于此。

在头部之后是数组数据。如果 dtype 包含 Python 对象（即dtype.hasobject is True），那么数据是数组的 Python pickle。否则，数据是数组的连续（无论是 C 还是 Fortran，取决于fortran_order）字节。消费者可以通过将形状给定的元素数量相乘（注意shape=()表示有 1 个元素）来计算字节数，乘以dtype.itemsize。

格式版本 2.0

版本 1.0 格式只允许数组头部的总大小为 65535 字节。这可以被具有大量列的结构化数组超过。版本 2.0 格式将头部大小扩展到 4 GiB。numpy.save将自动保存为 2.0 格式，如果数据需要，否则它将始终使用更兼容的 1.0 格式。

因此，头部的第四个元素的描述变为：“接下来的 4 个字节形成一个小端无符号整数：头部数据 HEADER_LEN 的长度。”

格式版本 3.0

这个版本用 utf8 编码的字符串替换了 ASCII 字符串（实际上是 latin1），因此支持具有任何 Unicode 字段名称的结构化类型。

注意

.npy 格式，包括创建动机和与其他替代方案的比较，在 “npy-format” NEP 中有描述，然而随着时间的推移，细节已经发生变化，本文档更为当前。

线性代数（numpy.linalg）

原文：numpy.org/doc/1.26/reference/routines.linalg.html

NumPy 线性代数函数依赖于 BLAS 和 LAPACK，提供了标准线性代数算法的高效低级实现。这些库可能由 NumPy 自身提供，使用了它们的参考实现的 C 版本，但是在可能的情况下，更倾向于利用专门处理器功能的高度优化库。这些库的示例包括OpenBLAS，MKL (TM)和 ATLAS。由于这些库是多线程且处理器相关的，可能需要环境变量和外部包，如threadpoolctl，来控制线程数或指定处理器架构。

SciPy 库还包含一个linalg子模块，SciPy 和 NumPy 子模块提供的功能有重叠。SciPy 包含了在numpy.linalg中找不到的函数，如与 LU 分解和 Schur 分解相关的函数，多种计算伪逆的方法，以及矩阵的函数，如矩阵对数。一些在两者中都存在的函数在scipy.linalg中具有增强功能。例如，scipy.linalg.eig可以接受第二个矩阵参数来解决广义特征值问题。然而，NumPy 中的一些函数具有更灵活的广播选项。例如，numpy.linalg.solve可以处理“堆叠”数组，而scipy.linalg.solve只接受单个方阵作为其第一个参数。

注意

在本页中使用的术语矩阵指的是一个 2d numpy.array对象，而不是一个numpy.matrix对象。后者已不再推荐，即使是用于线性代数。有关更多信息，请参阅矩阵对象文档。

@运算符

介绍自 NumPy 1.10.0 起，@运算符在计算 2d 数组之间的矩阵乘积时比其他方法更可取。numpy.matmul函数实现了@运算符。

矩阵和向量乘积

dot(a, b[, out])	两个数组的点积。
linalg.multi_dot(arrays, *[, out])	在单个函数调用中计算两个或多个数组的点积，同时自动选择最快的计算顺序。
vdot(a, b, /)	返回两个向量的点积。
inner(a, b, /)	两个数组的内积。
outer(a, b[, out])	计算两个向量的外积。
matmul(x1, x2, /[, out, casting, order, ...])	两个数组的矩阵乘积。
tensordot(a, b[, axes])	计算沿指定轴的张量点积。
einsum(subscripts, *operands[, out, dtype, ...])	对操作数执行 Einstein 求和约定。
einsum_path(subscripts, *operands[, optimize])	通过考虑中间数组的创建，评估 einsum 表达式的最低成本收缩顺序。
linalg.matrix_power(a, n)	将方阵提升到（整数）幂n。
kron(a, b)	两个数组的 Kronecker 积。

分解

linalg.cholesky(a)	Cholesky 分解。
linalg.qr(a[, mode])	计算矩阵的 qr 分解。
linalg.svd(a[, full_matrices, compute_uv, ...])	奇异值分解。

矩阵特征值

linalg.eig(a)	计算方阵的特征值和右特征向量。
linalg.eigh(a[, UPLO])	返回复厄米（共轭对称）或实对称矩阵的特征值和特征向量。
linalg.eigvals(a)	计算一般矩阵的特征值。
linalg.eigvalsh(a[, UPLO])	计算复厄米或实对称矩阵的特征值。

范数和其他数字

linalg.norm(x[, ord, axis, keepdims])	矩阵或向量范数。
linalg.cond(x[, p])	计算矩阵的条件数。
linalg.det(a)	计算数组的行列式。
linalg.matrix_rank(A[, tol, hermitian])	使用 SVD 方法返回数组的矩阵秩
linalg.slogdet(a)	计算数组行列式的符号和（自然）对数。
trace(a[, offset, axis1, axis2, dtype, out])	返回数组对角线上的和。

解方程和矩阵求逆

linalg.solve(a, b)	解线性矩阵方程或线性标量方程组。
linalg.tensorsolve(a, b[, axes])	解张量方程 a x = b 以求解 x。
linalg.lstsq(a, b[, rcond])	返回线性矩阵方程的最小二乘解。
linalg.inv(a)	计算矩阵的（乘法）逆。
linalg.pinv(a[, rcond, hermitian])	计算矩阵的（Moore-Penrose）伪逆。
linalg.tensorinv(a[, ind])	计算 N 维数组的“逆”。

异常

linalg.LinAlgError	由 linalg 函数引发的通用 Python 异常派生对象。

一次对多个矩阵进行线性代数运算

新版本为 1.8.0。

上述列出的几个线性代数例程能够同时为多个矩阵计算结果，只要它们堆叠到同一个数组中。

在文档中通过输入参数规范来指示，例如 a : (..., M, M) array_like。这意味着，例如给定输入数组 a.shape == (N, M, M)，它被解释为 N 个大小为 M×M 的矩阵的“堆叠”。类似的规范适用于返回值，例如行列式具有 det : (...)，在这种情况下将返回形状为 det(a).shape == (N,) 的数组。这推广到对更高维数组的线性代数操作：多维数组的最后 1 或 2 维被解释为向量或矩阵，适用于每个操作。

@ 运算符

在 NumPy 1.10.0 中引入，@ 运算符在计算二维数组之间的矩阵乘积时优于其他方法。numpy.matmul 函数实现了 @ 运算符。

矩阵和向量乘积

dot(a, b[, out])	两个数组的点积。
linalg.multi_dot(arrays, *[, out])	在单个函数调用中计算两个或多个数组的点积，同时自动选择最快的计算顺序。
vdot(a, b, /)	返回两个向量的点积。
inner(a, b, /)	两个数组的内积。
outer(a, b[, out])	计算两个向量的外积。
matmul(x1, x2, /[, out, casting, order, ...])	两个数组的矩阵乘积。
tensordot(a, b[, axes])	计算沿指定轴的张量点积。
einsum(subscripts, *operands[, out, dtype, ...])	对操作数执行爱因斯坦求和约定。
einsum_path(subscripts, *operands[, optimize])	通过考虑创建中间数组来评估 einsum 表达式的最低成本收缩顺序。
linalg.matrix_power(a, n)	将方阵提升到（整数）幂 n。
kron(a, b)	两个数组的 Kronecker 乘积。

分解

linalg.cholesky(a)	Cholesky 分解。
linalg.qr(a[, mode])	计算矩阵的 QR 分解。
linalg.svd(a[, full_matrices, compute_uv, ...])	奇异值分解。

矩阵特征值

linalg.eig(a)	计算方阵的特征值和右特征向量。
linalg.eigh(a[, UPLO])	返回复共轭厄米特（共轭对称）或实对称矩阵的特征值和特征向量。
linalg.eigvals(a)	计算一般矩阵的特征值。
linalg.eigvalsh(a[, UPLO])	计算复共轭厄米特或实对称矩阵的特征值。

范数和其他数字

linalg.norm(x[, ord, axis, keepdims])	矩阵或向量范数。
linalg.cond(x[, p])	计算矩阵的条件数。
linalg.det(a)	计算数组的行列式。
linalg.matrix_rank(A[, tol, hermitian])	使用 SVD 方法返回数组的矩阵秩
linalg.slogdet(a)	计算数组行列式的符号和（自然）对数。
trace(a[, offset, axis1, axis2, dtype, out])	返回数组对角线上��和。

解方程和矩阵求逆

linalg.solve(a, b)	解线性矩阵方程或线性标量方程组。
linalg.tensorsolve(a, b[, axes])	解张量方程 a x = b 得到 x。
linalg.lstsq(a, b[, rcond])	返回线性矩阵方程的最小二乘解。
linalg.inv(a)	计算矩阵的（乘法）逆。
linalg.pinv(a[, rcond, hermitian])	计算矩阵的（Moore-Penrose）伪逆。
linalg.tensorinv(a[, ind])	计算 N 维数组的“逆”。

异常

linalg.LinAlgError	由 linalg 函数引发的通用 Python 异常派生对象。

一次对多个矩阵进行线性代数运算

新版本为 1.8.0。

上述几个线性代数例程能够同时计算多个矩阵的结果，如果它们堆叠到同一个数组中。

这在文档中通过输入参数规范来指示，例如 a : (..., M, M) array_like。这意味着，例如给定输入数组 a.shape == (N, M, M)，它被解释为“N 个大小为 M 乘 M 的矩阵”堆叠在一起。类似的规范也适用于返回值，例如行列式具有 det : (...)，在这种情况下将返回形状为 det(a).shape == (N,) 的数组。这推广到对高维数组进行线性代数运算：多维数组的最后 1 或 2 维被解释为向量或矩阵，适用于每个操作。

numpy.dot

原文：numpy.org/doc/1.26/reference/generated/numpy.dot.html

numpy.dot(a, b, out=None)

两个数组的点积。具体来说，

• 如果a和b都是 1-D 数组，则是向量的内积（不进行复共轭）。

• 如果a和b都是 2-D 数组，则是矩阵乘法，但推荐使用matmul或a @ b。

• 如果a或b中有一个是 0-D（标量），它等同于multiply，推荐使用numpy.multiply(a, b)或a * b。

• 如果a是一个 N 维数组，b是一个 1-D 数组，则是a的最后一个轴和b的和积。

• 如果a是一个 N 维数组，b是一个 M 维数组（其中M>=2），它是a的最后一个轴和b的倒数第二个轴的和积：

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

在可能的情况下使用优化的 BLAS 库（参见numpy.linalg）。

参数：

a类似数组

第一个参数。

b类似数组

第二个参数。

out数组，可选

输出参数。必须具有与未使用时返回的完全相同的类型。特别是，它必须具有正确的类型，必须是 C 连续的，其 dtype 必须是对于dot(a,b)将返回的 dtype。这是一个性能特性。因此，如果不满足这些条件，将引发异常，而不是尝试灵活处理。

返回：

output数组

返回a和b的点积。如果a和b都是标量或都是 1-D 数组，则返回一个标量；否则返回一个数组。如果给定out，则返回它。

引发：

ValueError

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

另请参阅

vdot

复共轭点积。

tensordot

在任意轴上的和积。

einsum

爱因斯坦求和约定。

matmul

‘@’操作符作为带有输出参数的方法。

linalg.multi_dot

点积链式。

示例

>>> 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.linalg.multi_dot

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.multi_dot.html

linalg.multi_dot(arrays, *, out=None)

在单个函数调用中计算两个或多个数组的点积，同时自动选择最快的评估顺序。

multi_dot链接numpy.dot并使用矩阵的最佳括号化[1] [2]。根据矩阵的形状，这可以大大加快乘法运算速度。

如果第一个参数是 1-D，则将其视为行向量。如果最后一个参数是 1-D，则将其视为列向量。其他参数必须是 2-D。

将multi_dot视为：

def multi_dot(arrays): return functools.reduce(np.dot, arrays) 

参数：

arrays数组序列

如果第一个参数是 1-D，则将其视为行向量。如果最后一个参数是 1-D，则将其视为列向量。其他参数必须是 2-D。

outndarray，可选

输出参数。这必须具有与未使用时返回的完全相同的类型。特别是，它必须具有正确的类型，必须是 C 连续的，其 dtype 必须是dot(a, b)将返回的 dtype。这是一个性能特性。因此，如果不满足这些条件，将引发异常，而不是尝试灵活处理。

版本 1.19.0 中的新功能。

返回：

outputndarray

返回所提供数组的点积。

参见

numpy.dot

两个参数的点乘。

笔记

可以使用以下函数计算矩阵乘法的成本：

def cost(A, B):
    return A.shape[0] * A.shape[1] * B.shape[1] 

假设我们有三个矩阵 (A_{10x100}, B_{100x5}, C_{5x50})。

两种不同括号化的成本如下：

cost((AB)C) = 10*100*5 + 10*5*50   = 5000 + 2500   = 7500
cost(A(BC)) = 10*100*50 + 100*5*50 = 50000 + 25000 = 75000 

参考资料

[1]

Cormen，“算法导论”，第 15.2 章，第 370-378 页

[2]

en.wikipedia.org/wiki/Matrix_chain_multiplication

示例

multi_dot允许您编写：

>>> from numpy.linalg import multi_dot
>>> # Prepare some data
>>> A = np.random.random((10000, 100))
>>> B = np.random.random((100, 1000))
>>> C = np.random.random((1000, 5))
>>> D = np.random.random((5, 333))
>>> # the actual dot multiplication
>>> _ = multi_dot([A, B, C, D]) 

而不是：

>>> _ = np.dot(np.dot(np.dot(A, B), C), D)
>>> # or
>>> _ = A.dot(B).dot(C).dot(D) 

numpy.vdot

原文：numpy.org/doc/1.26/reference/generated/numpy.vdot.html

numpy.vdot(a, b, /)

返回两个向量的点积。

函数 vdot(a, b)处理复数与 dot(a, b)不同。如果第一个参数是复数，则在计算点积时会使用第一个参数的复共轭。

注意，vdot与dot处理多维数组的方式不同：它不执行矩阵乘积，而是首先将输入参数展平为 1-D 向量。因此，它只应用于向量。

参数：

aarray_like

如果a是复数，则在计算点积之前会取其复共轭。

barray_like

点积的第二个参数。

返回：

outputndarray

a和b的点积。根据a和b的类型，可以是 int、float 或 complex。

另请参阅

dot

返回点积，不使用第一个参数的复共轭。

示例

>>> a = np.array([1+2j,3+4j])
>>> b = np.array([5+6j,7+8j])
>>> np.vdot(a, b)
(70-8j)
>>> np.vdot(b, a)
(70+8j) 

注意，高维数组会被展平！

>>> a = np.array([[1, 4], [5, 6]])
>>> b = np.array([[4, 1], [2, 2]])
>>> np.vdot(a, b)
30
>>> np.vdot(b, a)
30
>>> 1*4 + 4*1 + 5*2 + 6*2
30 

numpy.inner

原文：numpy.org/doc/1.26/reference/generated/numpy.inner.html

numpy.inner(a, b, /)

两个数组的内积。

向量的普通内积对于 1-D 数组（不包括复共轭），在更高维度上是最后轴上的求和乘积。

参数：

a, b数组样式

如果a和b都是非标量，则它们的最后维必须匹配。

返回：

out ndarray

如果a和b都是标量或者都是 1-D 数组，则返回一个标量；否则返回一个数组。out.shape = (*a.shape[:-1], *b.shape[:-1])

引发：

ValueError

如果a和b都是非标量且它们的最后维大小不同。

另请参阅

tensordot

在任意轴上求和乘积。

dot

广义矩阵乘积，使用b的倒数第二维。

einsum

爱因斯坦求和约定。

注意

对于向量（1-D 数组），它计算普通内积：

np.inner(a, b) = sum(a[:]*b[:]) 

更一般地，如果ndim(a) = r > 0且ndim(b) = s > 0：

np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1)) 

或者明确地：

np.inner(a, b)[i0,...,ir-2,j0,...,js-2]
     = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:]) 

此外，a或b可能是标量，此时：

np.inner(a,b) = a*b 

示例

向量的普通内积：

>>> a = np.array([1,2,3])
>>> b = np.array([0,1,0])
>>> np.inner(a, b)
2 

一些多维示例：

>>> a = np.arange(24).reshape((2,3,4))
>>> b = np.arange(4)
>>> c = np.inner(a, b)
>>> c.shape
(2, 3)
>>> c
array([[ 14,  38,  62],
 [ 86, 110, 134]]) 

>>> a = np.arange(2).reshape((1,1,2))
>>> b = np.arange(6).reshape((3,2))
>>> c = np.inner(a, b)
>>> c.shape
(1, 1, 3)
>>> c
array([[[1, 3, 5]]]) 

b是标量的一个示例：

>>> np.inner(np.eye(2), 7)
array([[7., 0.],
 [0., 7.]]) 

numpy.outer

原文：numpy.org/doc/1.26/reference/generated/numpy.outer.html

numpy.outer(a, b, out=None)

计算两个向量的外积。

给定长度分别为M和N的两个向量a和b，外积[1]为：

[[a_0*b_0  a_0*b_1 ... a_0*b_{N-1} ]
 [a_1*b_0    .
 [ ...          .
 [a_{M-1}*b_0            a_{M-1}*b_{N-1} ]] 

参数：

a(M,) array_like

第一个输入向量。如果不是 1 维的，则会被展平。

b(N,) array_like

第二个输入向量。如果不是 1 维的，则会被展平。

out(M, N) ndarray, optional

结果存储的位置

1.9.0 版本中的新功能。

返回：

out(M, N) ndarray

out[i, j] = a[i] * b[j]

另请参阅

inner

einsum

einsum('i,j->ij', a.ravel(), b.ravel())是等效的。

ufunc.outer

除了 1D 维度和其他操作外，还有其他维度的泛化。np.multiply.outer(a.ravel(), b.ravel())是等效的。

tensordot

np.tensordot(a.ravel(), b.ravel(), axes=((), ()))是等效的。

参考

[1]

G. H. Golub 和 C. F. Van Loan，《矩阵计算》，第 3 版，马里兰州巴尔的摩，约翰斯·霍普金斯大学出版社，1996 年，第 8 页。

示例

创建一个（非常）粗糙的网格以计算 Mandelbrot 集：

>>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))
>>> rl
array([[-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.]])
>>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))
>>> im
array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
 [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
 [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
 [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
 [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
>>> grid = rl + im
>>> grid
array([[-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],
 [-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],
 [-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],
 [-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],
 [-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j]]) 

一个使用字母“向量”的示例：

>>> x = np.array(['a', 'b', 'c'], dtype=object)
>>> np.outer(x, [1, 2, 3])
array([['a', 'aa', 'aaa'],
 ['b', 'bb', 'bbb'],
 ['c', 'cc', 'ccc']], dtype=object) 

numpy.matmul

原文：numpy.org/doc/1.26/reference/generated/numpy.matmul.html

numpy.matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis]) = <ufunc 'matmul'>

两个数组的矩阵乘积。

参数：

x1, x2array_like

输入数组，不允许标量。

outndarray，可选

存储结果的位置。如果提供，它必须具有与签名 (n,k),(k,m)->(n,m) 匹配的形状。如果未提供或为 None，则返回一个新分配的数组。

**kwargs

对于其他仅关键字参数，请参阅 ufunc 文档。

版本 1.16 中的新功能：现在处理 ufunc kwargs

返回：

yndarray

输入的矩阵乘积。仅当 x1、x2 都是 1-D 向量时才是标量。

引发：

ValueError

如果x1的最后一个维度与x2的倒数第二个维度大小不同。

如果传入了一个标量值。

另请参见

vdot

复共轭点积。

tensordot

在任意轴上求和乘积。

einsum

爱因斯坦求和约定。

dot

具有不同广播规则的替代矩阵乘积。

注意

行为取决于以下方式的参数。

• 如果两个参数都是 2-D，则它们将像常规矩阵一样相乘。

• 如果任一参数是 N-D，N > 2，则将其视为驻留在最后两个索引中的矩阵堆栈，并相应地进行广播。

• 如果第一个参数是 1-D，则通过在其维度前添加 1 来将其提升为矩阵。矩阵乘法后，前置的 1 将被移除。

• 如果第二个参数是 1-D，则通过在其维度后添加 1 来将其提升为矩阵。矩阵乘法后，附加的 1 将被移除。

matmul 与 dot 在两个重要方面有所不同：

• 标量乘法不允许，使用*代替。

• 矩阵堆栈将一起广播，就好像矩阵是元素一样，遵守签名(n,k),(k,m)->(n,m)：

  >>> a = np.ones([9, 5, 7, 4])
  >>> c = np.ones([9, 5, 4, 3])
  >>> np.dot(a, c).shape
  (9, 5, 7, 9, 5, 3)
  >>> np.matmul(a, c).shape
  (9, 5, 7, 3)
  >>> # n is 7, k is 4, m is 3 
  

matmul 函数实现了 Python 3.5 中引入的@运算符的语义，遵循PEP 465。

在可能的情况下使用优化的 BLAS 库（请参阅numpy.linalg）。

示例

对于 2-D 数组，它是矩阵乘积：

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

对于 2-D 与 1-D 混合，结果是通常的。

>>> a = np.array([[1, 0],
...               [0, 1]])
>>> b = np.array([1, 2])
>>> np.matmul(a, b)
array([1, 2])
>>> np.matmul(b, a)
array([1, 2]) 

对于数组堆栈，广播是常规的

>>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4))
>>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2))
>>> np.matmul(a,b).shape
(2, 2, 2)
>>> np.matmul(a, b)[0, 1, 1]
98
>>> sum(a[0, 1, :] * b[0 , :, 1])
98 

向量、向量返回标量内积，但两个参数都不是复共轭的：

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

标量乘法会引发错误。

>>> np.matmul([1,2], 3)
Traceback (most recent call last):
...
ValueError: matmul: Input operand 1 does not have enough dimensions ... 

@运算符可用作 ndarrays 上np.matmul的简写。

>>> x1 = np.array([2j, 3j])
>>> x2 = np.array([2j, 3j])
>>> x1 @ x2
(-13+0j) 

版本 1.10.0 中的新功能。

numpy.tensordot

原文：numpy.org/doc/1.26/reference/generated/numpy.tensordot.html

numpy.tensordot(a, b, axes=2)

沿指定轴计算张量点积。

给定两个张量a和b，以及包含两个 array_like 对象（(a_axes, b_axes)）的 array_like 对象，对a和b的元素（分量）在由a_axes和b_axes指定的轴上的乘积求和。第三个参数可以是一个单个非负整数型标量N；如果是这样，那么a的最后N个维度和b的前N个维度将被求和。

参数：

a, b array_like

要“点积”的张量。

axes int 或 (2,) array_like

• integer_like 如果是一个 int N，则按顺序对a的最后 N 个轴和b的前 N 个轴求和。相应轴的大小必须匹配。

• (2,) array_like 或者，一个要进行求和的轴的列表，第一个序列应用于a，第二个序列应用于b。这两个元素的 array_like 必须具有相同的长度。

返回：

output ndarray

输入的张量点积。

另请参阅

dot, einsum

注意

三种常见用例是：

• axes = 0：张量积(a\otimes b)

• axes = 1：张量点积(a\cdot b)

• axes = 2：（默认）张量双缩并(a:b)

当axes是整数型时，求和的顺序将是：首先是a中的第-N 个轴和b中的第 0 个轴，然后是a中的第-1 个轴和b中的第 N 个轴。

当有多个要求和的轴 - 并且它们不是a（b）的最后（第一个）轴时 - 参数axes应该由两个相同长度的序列组成，第一个要求和的轴首先在两个序列中给出，第二个轴第二个，依此类推。

结果的形状由第一个张量的未缩并轴，后跟第二个张量的未缩并轴组成。

示例

一个“传统”的示例：

>>> a = np.arange(60.).reshape(3,4,5)
>>> b = np.arange(24.).reshape(4,3,2)
>>> c = np.tensordot(a,b, axes=([1,0],[0,1]))
>>> c.shape
(5, 2)
>>> c
array([[4400., 4730.],
 [4532., 4874.],
 [4664., 5018.],
 [4796., 5162.],
 [4928., 5306.]])
>>> # A slower but equivalent way of computing the same...
>>> d = np.zeros((5,2))
>>> for i in range(5):
...   for j in range(2):
...     for k in range(3):
...       for n in range(4):
...         d[i,j] += a[k,n,i] * b[n,k,j]
>>> c == d
array([[ True,  True],
 [ True,  True],
 [ True,  True],
 [ True,  True],
 [ True,  True]]) 

利用+和*的重载的扩展示例：

>>> a = np.array(range(1, 9))
>>> a.shape = (2, 2, 2)
>>> A = np.array(('a', 'b', 'c', 'd'), dtype=object)
>>> A.shape = (2, 2)
>>> a; A
array([[[1, 2],
 [3, 4]],
 [[5, 6],
 [7, 8]]])
array([['a', 'b'],
 ['c', 'd']], dtype=object) 

>>> np.tensordot(a, A) # third argument default is 2 for double-contraction
array(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object) 

>>> np.tensordot(a, A, 1)
array([[['acc', 'bdd'],
 ['aaacccc', 'bbbdddd']],
 [['aaaaacccccc', 'bbbbbdddddd'],
 ['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object) 

>>> np.tensordot(a, A, 0) # tensor product (result too long to incl.)
array([[[[['a', 'b'],
 ['c', 'd']],
 ... 

>>> np.tensordot(a, A, (0, 1))
array([[['abbbbb', 'cddddd'],
 ['aabbbbbb', 'ccdddddd']],
 [['aaabbbbbbb', 'cccddddddd'],
 ['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object) 

>>> np.tensordot(a, A, (2, 1))
array([[['abb', 'cdd'],
 ['aaabbbb', 'cccdddd']],
 [['aaaaabbbbbb', 'cccccdddddd'],
 ['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object) 

>>> np.tensordot(a, A, ((0, 1), (0, 1)))
array(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object) 

>>> np.tensordot(a, A, ((2, 1), (1, 0)))
array(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object) 

numpy.einsum

原文：numpy.org/doc/1.26/reference/generated/numpy.einsum.html

numpy.einsum(subscripts, *operands, out=None, dtype=None, order='K', casting='safe', optimize=False)

对操作数执行爱因斯坦求和约定的计算。

使用爱因斯坦求和约定，许多常见的多维线性代数数组操作可以以简单的方式表示。在隐式模式下，einsum计算这些值。

在显式模式下，einsum提供了进一步的灵活性，以计算可能不被视为经典爱因斯坦求和操作的其他数组操作，通过禁用或强制对指定的下标标签进行求和。

请参阅说明和示例以进行澄清。

参数：

下标str

指定求和的下标为逗号分隔的下标标签列表。除非包括明确的指示符‘->’以及精确输出形式的下标标签，否则将执行隐式（经典爱因斯坦求和）计算。

操作数数组列表

这些是操作的数组。

输出ndarray，可选

如果提供，计算将在此数组中进行。

dtype，可选

如果提供，强制计算使用指定的数据类型。请注意，您可能还需要提供一个更自由的转换参数以允许转换。默认值为 None。

顺序，可选

控制输出的内存布局。‘C’表示它应该是 C 连续的。‘F’表示它应该是 Fortran 连续的，‘A’表示如果输入都是‘F’，则应该是‘F’，否则为‘C’。‘K’表示应尽可能接近输入的布局，包括任意排列的轴。默认值为‘K’。

casting，可选

控制可能发生的数据转换类型。不建议将其设置为‘unsafe’，因为它可能会对累积产生不利影响。

• ‘no’表示数据类型不应被转换。
• ‘equiv’表示仅允许字节顺序更改。
• ‘safe’表示仅允许可以保留值的转换。
• ‘same_kind’表示仅允许安全转换或在一种类型内的转换，例如从 float64 到 float32。
• ‘unsafe’表示可能进行任何数据转换。

默认值为‘safe’。

优化，可选

控制是否应进行中间优化。如果为 False，则不会进行任何优化，如果为 True，则默认为‘greedy’算法。还接受来自np.einsum_path函数的显式收缩列表。有关更多详细信息，请参见np.einsum_path。默认为 False。

返回：

输出ndarray

基于爱因斯坦求和约定的计算。

参见

einsum_path, dot, inner, outer, tensordot, linalg.multi_dot

einops

类似的冗长接口由einops包提供，以涵盖额外的操作：转置，重塑/展平，重复/平铺，挤压/展开和约简。

opt_einsum

opt_einsum以与后端无关的方式优化了类似 einsum 表达式的收缩顺序。

注意事项

版本 1.6.0 中的新功能。

爱因斯坦求和约定可用于计算许多多维、线性代数的数组操作。einsum提供了一种简洁的表示方式。

以下是einsum可以计算的一些操作的非穷尽列表，以及示例：

• 数组的迹，numpy.trace.

• 返回对角线，numpy.diag。

• 数组轴求和，numpy.sum。

• 转置和排列，numpy.transpose.

• 矩阵乘法和点积，numpy.matmul numpy.dot。

• 向量内积和外积，numpy.inner numpy.outer。

• 广播，逐元素和标量乘法，numpy.multiply。

• 张量收缩，numpy.tensordot.

• 链式数组操作，按照高效的计算顺序，numpy.einsum_path。

下标字符串是一个逗号分隔的下标标签列表，其中每个标签指的是相应操作数的一个维度。每当一个标签重复出现时，它就会被求和，因此np.einsum('i,i', a, b)等同于np.inner(a,b)。如果一个标签只出现一次，它就不会被求和，因此np.einsum('i', a)会产生一个不变的a视图。进一步的例子np.einsum('ij,jk', a, b)描述了传统的矩阵乘法，并等同于np.matmul(a,b)。一个操作数中重复的下标标签会取对角线。例如，np.einsum('ii', a)等同于np.trace(a)。

在隐式模式下，所选择的下标很重要，因为输出的轴会按字母顺序重新排序。这意味着np.einsum('ij', a)不会影响 2D 数组，而np.einsum('ji', a)会取其转置。此外，np.einsum('ij,jk', a, b)返回矩阵乘法，而np.einsum('ij,jh', a, b)返回乘法的转置，因为下标‘h’在下标‘i’之前。

在显式模式下，输出可以通过指定输出下标标签来直接控制。这需要标识符‘->’以及输出下标标签列表。此功能增加了函数的灵活性，因为可以在需要时禁用或强制求和。调用np.einsum('i->', a)类似于np.sum(a, axis=-1)，而np.einsum('ii->i', a)类似于np.diag(a)。不同之处在于einsum默认不允许广播。此外，np.einsum('ij,jh->ih', a, b)直接指定了输出下标标签的顺序，因此返回矩阵乘法，不同于上面隐式模式中的示例。

要启用和控制广播，请使用省略号。默认的 NumPy 风格广播是通过在每个术语的左侧添加省略号来完成的，例如np.einsum('...ii->...i', a)。要沿着第一个和最后一个轴进行迹运算，可以使用np.einsum('i...i', a)，或者要使用左侧索引进行矩阵-矩阵乘法而不是右侧索引，可以使用np.einsum('ij...,jk...->ik...', a, b)。

当只有一个操作数时，不会对轴求和，并且没有提供输出参数，则会返回对操作数的视图，而不是新数组。因此，对角线作为np.einsum('ii->i', a)会产生一个视图（在版本 1.10.0 中更改）。

einsum还提供了另一种提供下标和操作数的方法，即einsum(op0, sublist0, op1, sublist1, ..., [sublistout])。如果没有以这种格式提供输出形状，则将以隐式模式计算einsum，否则将以显式模式执行。下面的示例具有相应的einsum调用，使用了两个参数方法。

版本 1.10.0 中的新功能。

从 einsum 返回的视图现在在输入数组可写时也是可写的。例如，np.einsum('ijk...->kji...', a)现在将产生与np.swapaxes(a, 0, 2)相同的效果，而np.einsum('ii->i', a)将返回 2D 数组对角线的可写视图。

版本 1.12.0 中的新功能。

添加了optimize参数，它将优化 einsum 表达式的收缩顺序。对于三个或更多操作数的收缩，这可以大大增加计算效率，但在计算过程中会增加更大的内存占用。

通常应用‘贪婪’算法，经验测试表明在大多数情况下返回最优路径。在某些情况下，‘最优’将通过更昂贵的、详尽的搜索返回超级路径。对于迭代计算，建议计算一次最优路径并通过将其作为参数提供来重复使用该路径。下面给出一个示例。

查看numpy.einsum_path以获取更多详细信息。

示例

>>> a = np.arange(25).reshape(5,5)
>>> b = np.arange(5)
>>> c = np.arange(6).reshape(2,3) 

矩阵的迹：

>>> np.einsum('ii', a)
60
>>> np.einsum(a, [0,0])
60
>>> np.trace(a)
60 

提取对角线（需要显式形式）：

>>> np.einsum('ii->i', a)
array([ 0,  6, 12, 18, 24])
>>> np.einsum(a, [0,0], [0])
array([ 0,  6, 12, 18, 24])
>>> np.diag(a)
array([ 0,  6, 12, 18, 24]) 

沿轴求和（需要显式形式）：

>>> np.einsum('ij->i', a)
array([ 10,  35,  60,  85, 110])
>>> np.einsum(a, [0,1], [0])
array([ 10,  35,  60,  85, 110])
>>> np.sum(a, axis=1)
array([ 10,  35,  60,  85, 110]) 

对于更高维度的数组，可以使用省略号对单个轴求和：

>>> np.einsum('...j->...', a)
array([ 10,  35,  60,  85, 110])
>>> np.einsum(a, [Ellipsis,1], [Ellipsis])
array([ 10,  35,  60,  85, 110]) 

计算矩阵转置，或重新排列任意数量的轴：

>>> np.einsum('ji', c)
array([[0, 3],
 [1, 4],
 [2, 5]])
>>> np.einsum('ij->ji', c)
array([[0, 3],
 [1, 4],
 [2, 5]])
>>> np.einsum(c, [1,0])
array([[0, 3],
 [1, 4],
 [2, 5]])
>>> np.transpose(c)
array([[0, 3],
 [1, 4],
 [2, 5]]) 

向量内积：

>>> np.einsum('i,i', b, b)
30
>>> np.einsum(b, [0], b, [0])
30
>>> np.inner(b,b)
30 

矩阵向量乘法：

>>> np.einsum('ij,j', a, b)
array([ 30,  80, 130, 180, 230])
>>> np.einsum(a, [0,1], b, [1])
array([ 30,  80, 130, 180, 230])
>>> np.dot(a, b)
array([ 30,  80, 130, 180, 230])
>>> np.einsum('...j,j', a, b)
array([ 30,  80, 130, 180, 230]) 

广播和标量乘法：

>>> np.einsum('..., ...', 3, c)
array([[ 0,  3,  6],
 [ 9, 12, 15]])
>>> np.einsum(',ij', 3, c)
array([[ 0,  3,  6],
 [ 9, 12, 15]])
>>> np.einsum(3, [Ellipsis], c, [Ellipsis])
array([[ 0,  3,  6],
 [ 9, 12, 15]])
>>> np.multiply(3, c)
array([[ 0,  3,  6],
 [ 9, 12, 15]]) 

向量外积：

>>> np.einsum('i,j', np.arange(2)+1, b)
array([[0, 1, 2, 3, 4],
 [0, 2, 4, 6, 8]])
>>> np.einsum(np.arange(2)+1, [0], b, [1])
array([[0, 1, 2, 3, 4],
 [0, 2, 4, 6, 8]])
>>> np.outer(np.arange(2)+1, b)
array([[0, 1, 2, 3, 4],
 [0, 2, 4, 6, 8]]) 

张量收缩：

>>> a = np.arange(60.).reshape(3,4,5)
>>> b = np.arange(24.).reshape(4,3,2)
>>> np.einsum('ijk,jil->kl', a, b)
array([[4400., 4730.],
 [4532., 4874.],
 [4664., 5018.],
 [4796., 5162.],
 [4928., 5306.]])
>>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3])
array([[4400., 4730.],
 [4532., 4874.],
 [4664., 5018.],
 [4796., 5162.],
 [4928., 5306.]])
>>> np.tensordot(a,b, axes=([1,0],[0,1]))
array([[4400., 4730.],
 [4532., 4874.],
 [4664., 5018.],
 [4796., 5162.],
 [4928., 5306.]]) 

可写返回数组（自版本 1.10.0 起）：

>>> a = np.zeros((3, 3))
>>> np.einsum('ii->i', a)[:] = 1
>>> a
array([[1., 0., 0.],
 [0., 1., 0.],
 [0., 0., 1.]]) 

省略号用法示例：

>>> a = np.arange(6).reshape((3,2))
>>> b = np.arange(12).reshape((4,3))
>>> np.einsum('ki,jk->ij', a, b)
array([[10, 28, 46, 64],
 [13, 40, 67, 94]])
>>> np.einsum('ki,...k->i...', a, b)
array([[10, 28, 46, 64],
 [13, 40, 67, 94]])
>>> np.einsum('k...,jk', a, b)
array([[10, 28, 46, 64],
 [13, 40, 67, 94]]) 

链式数组操作。对于更复杂的收缩，通过重复计算‘贪婪’路径或预先计算‘最优’路径并重复应用它，使用einsum_path插入（自版本 1.12.0 起）可能实现速度提升。性能改进在处理更大的数组时可能特别显著：

>>> a = np.ones(64).reshape(2,4,8) 

基本的einsum：~1520ms（在 3.1GHz 英特尔 i5 上进行基准测试。）

>>> for iteration in range(500):
...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a) 

子优化的einsum（由于重复路径计算时间）：~330ms

>>> for iteration in range(500):
...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal') 

贪婪的einsum（更快的最优路径近似）：~160ms

>>> for iteration in range(500):
...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy') 

最优的einsum（在某些用例中的最佳使用模式）：~110ms

>>> path = np.einsum_path('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')[0]
>>> for iteration in range(500):
...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path) 

numpy.einsum_path

原文：numpy.org/doc/1.26/reference/generated/numpy.einsum_path.html

numpy.einsum_path(subscripts, *operands, optimize='greedy')

通过考虑中间数组的创建，评估einsum表达式的最低成本收缩顺序。

参数：

subscripts字符串

指定求和的下标。

*operands数组列表

这些是操作的数组。

optimize

选择路径类型。如果提供了一个元组，则假定第二个参数是创建的最大中间大小。如果只提供了一个参数，则使用最大输入或输出数组大小作为最大中间大小。

• 如果给定以einsum_path开头的列表，则将其用作收缩路径

• 如果为 False，则不进行优化

• 如果为 True，默认为‘贪婪’算法

• ‘最佳’ 一种算法，通过组合地探索列出的张量的所有可能的收缩方式，并选择成本最低的路径。随着收缩项数量的增加呈指数级增长。

• ‘贪婪’ 一种算法，每一步选择最佳的对收缩。实际上，该算法在每一步搜索最大的内部、Hadamard，然后外部乘积。随着收缩项数量的增加呈立方比例增长。对于大多数收缩来说，等同于‘最佳’路径。

默认为‘贪婪’。

返回：

path元组列表

一个einsum路径的列表表示。

string_repr字符串

einsum路径的可打印表示。

另请参阅

einsum, linalg.multi_dot

注意

结果路径指示应首先收缩输入收缩的哪些项，然后将此收缩的结果附加到收缩列表的末尾。然后可以对此列表进行迭代，直到所有中间收缩完成。

示例

我们可以从一个链点示例开始。在这种情况下，最佳的做法是首先收缩b和c张量，如路径的第一个元素(1, 2)所示。结果张量添加到收缩的末尾，然后完成剩余的收缩(0, 1)。

>>> np.random.seed(123)
>>> a = np.random.rand(2, 2)
>>> b = np.random.rand(2, 5)
>>> c = np.random.rand(5, 2)
>>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy')
>>> print(path_info[0])
['einsum_path', (1, 2), (0, 1)]
>>> print(path_info[1])
 Complete contraction:  ij,jk,kl->il # may vary
 Naive scaling:  4
 Optimized scaling:  3
 Naive FLOP count:  1.600e+02
 Optimized FLOP count:  5.600e+01
 Theoretical speedup:  2.857
 Largest intermediate:  4.000e+00 elements
-------------------------------------------------------------------------
scaling                  current                                remaining
-------------------------------------------------------------------------
 3                   kl,jk->jl                                ij,jl->il
 3                   jl,ij->il                                   il->il 

一个更复杂的索引转换示例。

>>> I = np.random.rand(10, 10, 10, 10)
>>> C = np.random.rand(10, 10)
>>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C,
...                            optimize='greedy') 

>>> print(path_info[0])
['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)]
>>> print(path_info[1]) 
 Complete contraction:  ea,fb,abcd,gc,hd->efgh # may vary
 Naive scaling:  8
 Optimized scaling:  5
 Naive FLOP count:  8.000e+08
 Optimized FLOP count:  8.000e+05
 Theoretical speedup:  1000.000
 Largest intermediate:  1.000e+04 elements
--------------------------------------------------------------------------
scaling                  current                                remaining
--------------------------------------------------------------------------
 5               abcd,ea->bcde                      fb,gc,hd,bcde->efgh
 5               bcde,fb->cdef                         gc,hd,cdef->efgh
 5               cdef,gc->defg                            hd,defg->efgh
 5               defg,hd->efgh                               efgh->efgh 

numpy.linalg.matrix_power

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.matrix_power.html

linalg.matrix_power(a, n)

将方阵提升到（整数）幂n。

对于正整数n，幂是通过重复矩阵平方和矩阵乘法计算的。如果n == 0，则返回与M相同形状的单位矩阵。如果n < 0，则计算逆矩阵，然后将其提升到abs(n)次幂。

注意

目前不支持对象矩阵的堆叠。

参数：

a(…, M, M) 类似数组

要“提升”的矩阵。

n整数

指数可以是任何整数或长整数，正数、负数或零。

返回：

an**(…, M, M) ndarray 或矩阵对象

返回值与M具有相同的形状和类型；如果指数是正数或零，则元素的类型与M的元素相同。如果指数为负数，则元素为浮点数。

引发：

线性代数错误

对于不是方阵的矩阵，或者（对于负幂）无法通过数值方法求逆的情况。

示例

>>> from numpy.linalg import matrix_power
>>> i = np.array([[0, 1], [-1, 0]]) # matrix equiv. of the imaginary unit
>>> matrix_power(i, 3) # should = -i
array([[ 0, -1],
 [ 1,  0]])
>>> matrix_power(i, 0)
array([[1, 0],
 [0, 1]])
>>> matrix_power(i, -3) # should = 1/(-i) = i, but w/ f.p. elements
array([[ 0.,  1.],
 [-1.,  0.]]) 

稍微复杂一点的例子

>>> q = np.zeros((4, 4))
>>> q[0:2, 0:2] = -i
>>> q[2:4, 2:4] = i
>>> q # one of the three quaternion units not equal to 1
array([[ 0., -1.,  0.,  0.],
 [ 1.,  0.,  0.,  0.],
 [ 0.,  0.,  0.,  1.],
 [ 0.,  0., -1.,  0.]])
>>> matrix_power(q, 2) # = -np.eye(4)
array([[-1.,  0.,  0.,  0.],
 [ 0., -1.,  0.,  0.],
 [ 0.,  0., -1.,  0.],
 [ 0.,  0.,  0., -1.]]) 

numpy.kron

原文：numpy.org/doc/1.26/reference/generated/numpy.kron.html

numpy.kron(a, b)

两个数组的克罗内克积。

计算克罗内克积，由第二个数组的块组成，由第一个数组缩放。

参数：

a, barray_like

返回：

outndarray

另见

outer

外积

注意事项

该函数假定 a 和 b 的维数相同，如有必要，将最小的维数前置为 1。 如果 a.shape = (r0,r1,..,rN) 和 b.shape = (s0,s1,...,sN)，克罗内克积的形状为 (r0*s0, r1*s1, ..., rN*SN)。 元素是来自 a 和 b 的元素的乘积，通过以下明确组织：

kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN] 

其中：

kt = it * st + jt,  t = 0,...,N 

在常见的二维情况下（N=1），可以可视化块结构：

[[ a[0,0]*b,   a[0,1]*b,  ... , a[0,-1]*b  ],
 [  ...                              ...   ],
 [ a[-1,0]*b,  a[-1,1]*b, ... , a[-1,-1]*b ]] 

示例

>>> np.kron([1,10,100], [5,6,7])
array([  5,   6,   7, ..., 500, 600, 700])
>>> np.kron([5,6,7], [1,10,100])
array([  5,  50, 500, ...,   7,  70, 700]) 

>>> np.kron(np.eye(2), np.ones((2,2)))
array([[1.,  1.,  0.,  0.],
 [1.,  1.,  0.,  0.],
 [0.,  0.,  1.,  1.],
 [0.,  0.,  1.,  1.]]) 

>>> a = np.arange(100).reshape((2,5,2,5))
>>> b = np.arange(24).reshape((2,3,4))
>>> c = np.kron(a,b)
>>> c.shape
(2, 10, 6, 20)
>>> I = (1,3,0,2)
>>> J = (0,2,1)
>>> J1 = (0,) + J             # extend to ndim=4
>>> S1 = (1,) + b.shape
>>> K = tuple(np.array(I) * np.array(S1) + np.array(J1))
>>> c[K] == a[I]*b[J]
True 

numpy.linalg.cholesky

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.cholesky.html

linalg.cholesky(a)

Cholesky 分解。

返回方阵a的 Cholesky 分解， L * L.H，其中L为下三角矩阵，.H 为共轭转置算子（如果a是实数值，则为普通转置）。a必须是埃尔米特（实数值的话就是对称）并且正定的。没有检查是否a是埃尔米特的。此外，只使用a的下三角和对角元素。事实上只返回L。

Parameters:

a(…, M, M) 数组形式

埃尔米特（如果所有元素都是实数，则为对称），正定输入矩阵。

Returns:

L(…, M, M) 数组形式

a的下三角 Cholesky 分解。如果a是矩阵对象，就返回一个矩阵对象。

Raises:

LinAlgError

若分解失败，例如a非正定。

See also

scipy.linalg.cholesky

SciPy 中的相似函数。

scipy.linalg.cholesky_banded

对带状埃尔米特正定矩阵进行 Cholesky 分解。

scipy.linalg.cho_factor

矩阵的 Cholesky 分解，可用于scipy.linalg.cho_solve中。

Notes

版本 1.8.0 中的新功能。

适用广播规则，请参见numpy.linalg文档以获取详细信息。

Cholesky 分解通常用作快速求解

[A \mathbf{x} = \mathbf{b}]

（当A既是埃尔米特/对称且是正定的时候）。

首先，我们求解(\mathbf{y})在

[L \mathbf{y} = \mathbf{b},]

之后，对于(\mathbf{x})，使用

[L.H \mathbf{x} = \mathbf{y}.]

Examples

>>> A = np.array([[1,-2j],[2j,5]])
>>> A
array([[ 1.+0.j, -0.-2.j],
 [ 0.+2.j,  5.+0.j]])
>>> L = np.linalg.cholesky(A)
>>> L
array([[1.+0.j, 0.+0.j],
 [0.+2.j, 1.+0.j]])
>>> np.dot(L, L.T.conj()) # verify that L * L.H = A
array([[1.+0.j, 0.-2.j],
 [0.+2.j, 5.+0.j]])
>>> A = [[1,-2j],[2j,5]] # what happens if A is only array_like?
>>> np.linalg.cholesky(A) # an ndarray object is returned
array([[1.+0.j, 0.+0.j],
 [0.+2.j, 1.+0.j]])
>>> # But a matrix object is returned if A is a matrix object
>>> np.linalg.cholesky(np.matrix(A))
matrix([[ 1.+0.j,  0.+0.j],
 [ 0.+2.j,  1.+0.j]]) 

numpy.linalg.qr

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.qr.html

linalg.qr(a, mode='reduced')

计算矩阵的 qr 分解。

将矩阵a因子化为qr，其中q为正交矩阵，r为上三角矩阵。

参数：

aarray_like，形状（…，M，N）

至少为 2 的维度的类似数组对象。

mode，optional

如果 K = min(M，N)，则

• ‘reduced’：返回维度为（…，M，K），（…，K，N）的 Q，R（默认）

• ‘complete’：返回维度为（…，M，M），（…，M，N）的 Q，R

• ‘r’：仅返回维度为（…，K，N）的 R

• ‘raw’：返回维度为（…，N，M），（…，K，）的 h，tau

选项‘reduced’，‘complete’和‘raw’是 numpy 1.8 中的新特性，请查阅说明以获取更多信息。默认为‘reduced’，为了与之前版本的 numpy 保持向后兼容性，可以省略‘reduced’和旧默认值‘full’。请注意，在‘raw’模式下返回的数组 h 进行了转置以调用 Fortran。‘economic’模式已弃用。模式‘full’和‘economic’可以仅使用第一个字母进行传递以实现向后兼容性，但所有其他模式必须拼写完整。有关更多解释，请查看说明。

返回：

当模式为‘reduced’或‘complete’时，结果将是一个具有

属性Q和R。

Qndarray of float or complex, optional

具有正交列的矩阵。当 mode = ‘complete’时，结果是一个正交/酉矩阵，取决于a是实数还是复数。在这种情况下，行列式可能是+/- 1。如果输入数组的维数大于 2，则返回具有上述属性的矩阵堆栈。

Rndarray of float or complex, optional

上三角矩阵或者如果输入数组的维数大于 2，则返回上三角矩阵的堆栈。

(h, tau)ndarrays of np.double or np.cdouble, optional

数组 h 包含生成 q 和 r 的 Householder 反射器。tau 数组包含反射器的缩放因子。在不推荐使用的“经济”模式中，仅返回 h。

引发：

LinAlgError

如果因子化失败。

另请参阅

scipy.linalg.qr

SciPy 中类似的函数。

scipy.linalg.rq

计算矩阵的 RQ 分解。

说明

这是对 LAPACK 例程dgeqrf，zgeqrf，dorgqr和zungqr的接口。

更多关于 qr 分解的信息，请参见：[zh.wikipedia.org/wiki/QR 分解](https://zh.wikipedia.org/wiki/QR 分解)

ndarray 下的子类除了 'raw' 模式之外都会被保留。因此，如果 a 的类型是 matrix，那么所有的返回值也将是矩阵。

NumPy 1.8.0 中新增了 “reduced”，“complete” 和 “raw” 选项以及将 “full” 选项作为 “reduced” 的别名。此外，还弃用了 “full” 和 “economic” 选项。因为 “full” 是先前的默认选项，而 “reduced” 是新的默认选项，所以通过默认设置 mode 即可保持向后兼容性。添加 “raw” 选项是为了使用 Householder reflectors 可以将数组乘以 q 的 LAPACK 函数。请注意，在这种情况下，返回的数组的类型为 np.double 或 np.cdouble，并且 h 数组被转置以符合 FORTRAN 的兼容性。目前，numpy 没有暴露使用 “raw” 返回值的例程，但是一些例程在 lapack_lite 中可用并等待相应的工作。

例子

>>> a = np.random.randn(9, 6)
>>> Q, R = np.linalg.qr(a)
>>> np.allclose(a, np.dot(Q, R))  # a does equal QR
True
>>> R2 = np.linalg.qr(a, mode='r')
>>> np.allclose(R, R2)  # mode='r' returns the same R as mode='full'
True
>>> a = np.random.normal(size=(3, 2, 2)) # Stack of 2 x 2 matrices as input
>>> Q, R = np.linalg.qr(a)
>>> Q.shape
(3, 2, 2)
>>> R.shape
(3, 2, 2)
>>> np.allclose(a, np.matmul(Q, R))
True 

示例说明了 qr 的常见用法：解决最小二乘问题

对于给定数据：{(0,1), (1,0), (1,2), (2,1)}，在 y = y0 + mx 中最小平方最佳的 m 和 y0 是多少？（画出这些点，你会发现应该是 y0 = 0，m = 1）。这个问题通过解方程组 Ax = b 来得到答案，其中：

A = array([[0, 1], [1, 1], [1, 1], [2, 1]])
x = array([[y0], [m]])
b = array([[1], [0], [2], [1]]) 

如果 A = QR，并且 Q 是正交的（通过 Gram-Schmidt 过程总可以得到这样一个矩阵），那么 x = inv(R) * (Q.T) * b。（然而，在 numpy 实践中，我们只需使用 lstsq）。

>>> A = np.array([[0, 1], [1, 1], [1, 1], [2, 1]])
>>> A
array([[0, 1],
 [1, 1],
 [1, 1],
 [2, 1]])
>>> b = np.array([1, 2, 2, 3])
>>> Q, R = np.linalg.qr(A)
>>> p = np.dot(Q.T, b)
>>> np.dot(np.linalg.inv(R), p)
array([  1.,   1.]) 

numpy.linalg.svd

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.svd.html

linalg.svd(a, full_matrices=True, compute_uv=True, hermitian=False)

奇异值分解。

当a是 2D 数组，且full_matrices=False，则将其分解为u @ np.diag(s) @ vh = (u * s) @ vh，其中u和vh的共轭转置是具有标准正交列的 2D 数组，s是a的奇异值的 1D 数组。当a是更高维度时，将以堆叠模式进行奇异值分解，如下所述。

参数：

a(…, M, N)数组型

具有a.ndim >= 2的实数或复数数组。

full_matricesbool, optional

如果为 True（默认值），u和vh的形状分别为(..., M, M)和(..., N, N)。否则，形状分别为(..., M, K)和(..., K, N)，其中K = min(M, N)。

compute_uvbool, optional

是否计算u和vh以及s。默认值为 True。

hermitianbool, optional

如果为 True，则假定a是厄米（实值情况下为对称的），从而可以更有效地找到奇异值。默认为 False。

1.17.0 版本中的新增内容。

返回：

当compute_uv为 True 时，结果将是具有以下属性的命名元组

属性名称：

U数组

单位数组。前a.ndim - 2维具有与输入a相同的大小。最后两个维度的大小取决于full_matrices的值。仅在compute_uv为 True 时返回。

S(…, K)数组

各向量的奇异值，每个向量按降序排序。前a.ndim - 2维与输入a的大小相同。

Vh数组

单位数组。前a.ndim - 2维具有与输入a相同的大小。最后两个维度的大小取决于full_matrices的值。仅在compute_uv为 True 时返回。

引发：

LinAlgError

如果 SVD 计算无法收敛。

另请参见

scipy.linalg.svd

SciPy 中的类似函数。

scipy.linalg.svdvals

计算矩阵的奇异值。

注释

在 1.8.0 版本中更改：广播规则适用，有关详细信息，请参阅numpy.linalg文档。

使用 LAPACK 例程_gesdd执行分解。

SVD 通常用于分解二维矩阵(A)。下面将讨论高维情况。在二维情况下，SVD 表示为(A = U S V^H)，其中(A = a)，(U= u)，(S= \mathtt{np.diag}(s))和(V^H = vh)。一维数组s包含a的奇异值，u和vh是酉矩阵。vh的行是(A^H A)的特征向量，u的列是(A A^H)的特征向量。在这两种情况下，相应的（可能非零）特征值由s**2给出。

如果a的维数超过两个，则应用广播规则，如同时对多个矩阵进行线性代数运算中所解释的那样。这意味着 SVD 以“堆叠”模式工作：它遍历第一个a.ndim - 2维的所有索引，对于每个组合，SVD 应用于最后两个索引。矩阵a可以使用(u * s[..., None, :]) @ vh或u @ (s[..., None] * vh)重构分解。（对于 Python 版本低于 3.5，@运算符可以被函数np.matmul替换。）

如果a是一个matrix对象（而不是一个ndarray），那么所有返回值也是。

示例

>>> a = np.random.randn(9, 6) + 1j*np.random.randn(9, 6)
>>> b = np.random.randn(2, 7, 8, 3) + 1j*np.random.randn(2, 7, 8, 3) 

基于完整 SVD 的重构，二维情况：

>>> U, S, Vh = np.linalg.svd(a, full_matrices=True)
>>> U.shape, S.shape, Vh.shape
((9, 9), (6,), (6, 6))
>>> np.allclose(a, np.dot(U[:, :6] * S, Vh))
True
>>> smat = np.zeros((9, 6), dtype=complex)
>>> smat[:6, :6] = np.diag(S)
>>> np.allclose(a, np.dot(U, np.dot(smat, Vh)))
True 

基于降维 SVD 的重构，二维情况：

>>> U, S, Vh = np.linalg.svd(a, full_matrices=False)
>>> U.shape, S.shape, Vh.shape
((9, 6), (6,), (6, 6))
>>> np.allclose(a, np.dot(U * S, Vh))
True
>>> smat = np.diag(S)
>>> np.allclose(a, np.dot(U, np.dot(smat, Vh)))
True 

基于完整 SVD 的重构，四维情况：

>>> U, S, Vh = np.linalg.svd(b, full_matrices=True)
>>> U.shape, S.shape, Vh.shape
((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3))
>>> np.allclose(b, np.matmul(U[..., :3] * S[..., None, :], Vh))
True
>>> np.allclose(b, np.matmul(U[..., :3], S[..., None] * Vh))
True 

基于降维 SVD 的重构，四维情况：

>>> U, S, Vh = np.linalg.svd(b, full_matrices=False)
>>> U.shape, S.shape, Vh.shape
((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3))
>>> np.allclose(b, np.matmul(U * S[..., None, :], Vh))
True
>>> np.allclose(b, np.matmul(U, S[..., None] * Vh))
True 

numpy.linalg.eig

numpy.org/doc/1.26/reference/generated/numpy.linalg.eig.html

linalg.eig(a)

计算方阵的特征值和右特征向量。

参数:

a(…, M, M) 数组

将计算特征值和右特征向量的矩阵

返回:

具有以下属性的命名元组:

特征值(…, M) 数组

每个特征值根据其重数重复。特征值不一定有序。结果数组将是复杂型，除非虚部为零，那么它将被转换为实型。当 a 是真实的时，生成的特征值将是实数（虚部为零）或成共轭对。

eigenvectors(…, M, M) 数组

规范化的（单位“长度”）特征向量，使得列 eigenvectors[:,i] 是对应于特征值 eigenvalues[i] 的特征向量。

引发:

LinAlgError

如果特征值计算不收敛。

另请参阅

eigvals

非对称数组的特征值。

eigh

实对称或复 Hermitian（共轭对称）数组的特征值和特征向量。

eigvalsh

实对称或复 Hermitian（共轭对称）数组的特征值。

scipy.linalg.eig

SciPy 中的类似功能还解决了广义特征值问题。

scipy.linalg.schur

对于酉矩阵和其他非 Hermitian 正规矩阵的最佳选择。

注意

1.8.0 版中的新功能。

广播规则适用，请参阅 numpy.linalg 文档以了解详细信息。

这是使用 _geev LAPACK 例程实现的，该例程计算一般方阵的特征值和特征向量。

w 的数字是 a 的特征值，如果存在一个向量 v 使得 a @ v = w * v。因此，数组 a，eigenvalues 和 eigenvectors 满足等式 a @ eigenvectors[:,i] = eigenvalues[i] * eigenvalues[:,i] 对于(i \in {0,...,M-1})。

eigenvectors 数组可能不是最大秩的，也就是说，一些列可能线性相关，尽管四舍五入错误可能掩盖了这一事实。如果特征值都不同，那么理论上特征向量是线性无关的，a 可以通过使用 eigenvectors 的相似变换对角化，即 inv(eigenvectors) @ a @ eigenvectors 为对角线。

对于非埃尔米特正规矩阵，推荐使用 SciPy 函数scipy.linalg.schur，因为这将确保矩阵eigenvectors是幺正的，而使用eig时并非如此。舒尔分解产生一个上三角矩阵而不是对角矩阵，但对于正规矩阵，只需要上三角矩阵的对角线部分，剩下的是四舍五入误差。

最后，强调了eigenvectors由a的 right（即右侧）特征向量组成。满足 y.T @ a = z * y.T 的向量y为a的left特征向量，一般来说，矩阵的左特征向量和右特征向量并不一定是（可能是共轭）转置关系。

参考资料

G. Strang，《线性代数及其应用》，第 2 版，Orlando, FL, Academic Press, Inc., 1980, 各种页码。

示例

>>> from numpy import linalg as LA 

具有实特征值和特征向量的（几乎）平凡示例。

>>> eigenvalues, eigenvectors = LA.eig(np.diag((1, 2, 3)))
>>> eigenvalues
array([1., 2., 3.])
>>> eigenvectors
array([[1., 0., 0.],
 [0., 1., 0.],
 [0., 0., 1.]]) 

具有复特征值和特征向量的实矩阵；注意特征值互为共轭复数。

>>> eigenvalues, eigenvectors = LA.eig(np.array([[1, -1], [1, 1]]))
>>> eigenvalues
array([1.+1.j, 1.-1.j])
>>> eigenvectors
array([[0.70710678+0.j        , 0.70710678-0.j        ],
 [0\.        -0.70710678j, 0\.        +0.70710678j]]) 

具有实特征值的复数矩阵（但特征向量是复数）；注意 a.conj().T == a，即，a 是埃尔米特矩阵。

>>> a = np.array([[1, 1j], [-1j, 1]])
>>> eigenvalues, eigenvectors = LA.eig(a)
>>> eigenvalues
array([2.+0.j, 0.+0.j])
>>> eigenvectors
array([[ 0\.        +0.70710678j,  0.70710678+0.j        ], # may vary
 [ 0.70710678+0.j        , -0\.        +0.70710678j]]) 

要小心四舍五入误差！

>>> a = np.array([[1 + 1e-9, 0], [0, 1 - 1e-9]])
>>> # Theor. eigenvalues are 1 +/- 1e-9
>>> eigenvalues, eigenvectors = LA.eig(a)
>>> eigenvalues
array([1., 1.])
>>> eigenvectors
array([[1., 0.],
 [0., 1.]]) 

numpy.linalg.eigh

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.eigh.html

linalg.eigh(a, UPLO='L')

返回复 Hermite（共轭对称）或实对称矩阵的特征值和特征向量。

返回两个对象，一个包含 a 的特征值的一维数组，以及相应特征向量（按列排列）的二维方阵或矩阵（取决于输入类型）。

参数：

a(…, M, M) 数组

要计算其特征值和特征向量的 Hermite 或实对称矩阵。

UPLO, 可选

指定计算是使用 a 的下三角部分（‘L’，默认）还是上三角部分（‘U’）。无论这个值是什么，对角线的实部将被考虑在内以保持 Hermite 矩阵的概念。因此，对角线的虚部将始终被视为零。

返回：

具有以下属性的命名元组：

eigenvalues(…, M) 数组

按升序排列的特征值，每个根据其重数重复。

eigenvectors

列 eigenvectors[:, i] 是与特征值 eigenvalues[i] 对应的归一化特征向量。如果 a 是一个矩阵对象，则会返回一个矩阵对象。

引发：

LinAlgError

如果特征值计算不收敛。

另请参见

eigvalsh

实对称或复 Hermite（共轭对称）数组的特征值。

eig

非对称数组的特征值和右特征向量。

eigvals

非对称数组的特征值。

scipy.linalg.eigh

SciPy 中的类似函数（但也解决了广义特征值问题）。

注意事项

自版本 1.8.0 新增。

广播规则适用，请参阅numpy.linalg文档以获取详细信息。

使用 LAPACK 程序 _syevd、_heevd 计算特征值/特征向量。

实对称或复 Hermite 矩阵的特征值始终为实数。[1]（列）特征向量的数组 eigenvalues 是幺正的，a、eigenvalues 和 eigenvectors 满足方程 dot(a, eigenvectors[:, i]) = eigenvalues[i] * eigenvectors[:, i]。

参考资料

[1]

G. Strang，《线性代数及其应用》，第 2 版，奥兰多，FL，Academic Press, Inc.，1980 年，第 222 页。

示例

>>> from numpy import linalg as LA
>>> a = np.array([[1, -2j], [2j, 5]])
>>> a
array([[ 1.+0.j, -0.-2.j],
 [ 0.+2.j,  5.+0.j]])
>>> eigenvalues, eigenvectors = LA.eigh(a)
>>> eigenvalues
array([0.17157288, 5.82842712])
>>> eigenvectors
array([[-0.92387953+0.j        , -0.38268343+0.j        ], # may vary
 [ 0\.        +0.38268343j,  0\.        -0.92387953j]]) 

>>> np.dot(a, eigenvectors[:, 0]) - eigenvalues[0] * eigenvectors[:, 0] # verify 1st eigenval/vec pair
array([5.55111512e-17+0.0000000e+00j, 0.00000000e+00+1.2490009e-16j])
>>> np.dot(a, eigenvectors[:, 1]) - eigenvalues[1] * eigenvectors[:, 1] # verify 2nd eigenval/vec pair
array([0.+0.j, 0.+0.j]) 

>>> A = np.matrix(a) # what happens if input is a matrix object
>>> A
matrix([[ 1.+0.j, -0.-2.j],
 [ 0.+2.j,  5.+0.j]])
>>> eigenvalues, eigenvectors = LA.eigh(A)
>>> eigenvalues
array([0.17157288, 5.82842712])
>>> eigenvectors
matrix([[-0.92387953+0.j        , -0.38268343+0.j        ], # may vary
 [ 0\.        +0.38268343j,  0\.        -0.92387953j]]) 

>>> # demonstrate the treatment of the imaginary part of the diagonal
>>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])
>>> a
array([[5.+2.j, 9.-2.j],
 [0.+2.j, 2.-1.j]])
>>> # with UPLO='L' this is numerically equivalent to using LA.eig() with:
>>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
>>> b
array([[5.+0.j, 0.-2.j],
 [0.+2.j, 2.+0.j]])
>>> wa, va = LA.eigh(a)
>>> wb, vb = LA.eig(b)
>>> wa; wb
array([1., 6.])
array([6.+0.j, 1.+0.j])
>>> va; vb
array([[-0.4472136 +0.j        , -0.89442719+0.j        ], # may vary
 [ 0\.        +0.89442719j,  0\.        -0.4472136j ]])
array([[ 0.89442719+0.j       , -0\.        +0.4472136j],
 [-0\.        +0.4472136j,  0.89442719+0.j       ]]) 

numpy.linalg.eigvals

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.eigvals.html

linalg.eigvals(a)

计算一般矩阵的特征值。

eigvals 和 eig 的主要区别：没有返回特征向量。

参数：

a(…, M, M) array_like

一个复值或实值矩阵，将计算其特征值。

返回：

w(…, M,) ndarray

每个特征值，根据其重数重复。它们不一定有序，也不一定是实数矩阵的实数。

引发：

LinAlgError

如果特征值计算不收敛。

参见

eig

一般数组的特征值和右特征向量

eigvalsh

实对称或复埃尔米特（共轭对称）数组的特征值。

eigh

实对称或复埃尔米特（共轭对称）数组的特征值和特征向量。

scipy.linalg.eigvals

SciPy 中类似的函数。

注释

新版本 1.8.0 中新增。

广播规则适用，请参阅numpy.linalg文档以获取详细信息。

这是使用 _geev LAPACK 程序包实现的，它计算一般方阵的特征值和特征向量。

示例

说明，利用对角矩阵的特征值是其对角元素，将一个矩阵左乘以正交矩阵 Q，右乘以 Q.T（Q 的转置）会保留“中间”矩阵的特征值。换句话说，如果 Q 是正交的，则 Q * A * Q.T 的特征值与 A 相同：

>>> from numpy import linalg as LA
>>> x = np.random.random()
>>> Q = np.array([[np.cos(x), -np.sin(x)], [np.sin(x), np.cos(x)]])
>>> LA.norm(Q[0, :]), LA.norm(Q[1, :]), np.dot(Q[0, :],Q[1, :])
(1.0, 1.0, 0.0) 

现在在一侧用 Q 乘以对角矩阵，另一侧用 Q.T 乘以对角矩阵：

>>> D = np.diag((-1,1))
>>> LA.eigvals(D)
array([-1.,  1.])
>>> A = np.dot(Q, D)
>>> A = np.dot(A, Q.T)
>>> LA.eigvals(A)
array([ 1., -1.]) # random 

numpy.linalg.eigvalsh

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.eigvalsh.html

linalg.eigvalsh(a, UPLO='L')

计算一个复共轭对称或实对称矩阵的特征值。

与 eigh 的主要区别：不计算特征向量。

参数：

a(…, M, M) array_like

待计算其特征值的复数或实数值矩阵。

UPLO, 可选

指定是否使用a的下三角部分（‘L’，默认）或上三角部分（‘U’）进行计算。无论该值是什么，对角线的实部都将在计算中被考虑，以保持复共轭矩阵的概念。因此，对角线的虚部始终被视为零。

返回:

w(…, M,) 数组

特征值按升序排列，根据其重数重复。

引发：

LinAlgError

如果特征值计算没有收敛。

另请参阅

eigh

实对称或复共轭（共轭对称）阵列的特征值和特征向量。

eigvals

一般实数或复数阵列的特征值。

eig

一般实数或复数阵列的特征值和右特征向量。

scipy.linalg.eigvalsh

SciPy 中的类似函数。

注意

自版本 1.8.0 起的新功能。

广播规则适用，详情请参阅numpy.linalg文档。

特征值是使用 LAPACK 例程_syevd、_heevd计算的。

示例

>>> from numpy import linalg as LA
>>> a = np.array([[1, -2j], [2j, 5]])
>>> LA.eigvalsh(a)
array([ 0.17157288,  5.82842712]) # may vary 

>>> # demonstrate the treatment of the imaginary part of the diagonal
>>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])
>>> a
array([[5.+2.j, 9.-2.j],
 [0.+2.j, 2.-1.j]])
>>> # with UPLO='L' this is numerically equivalent to using LA.eigvals()
>>> # with:
>>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
>>> b
array([[5.+0.j, 0.-2.j],
 [0.+2.j, 2.+0.j]])
>>> wa = LA.eigvalsh(a)
>>> wb = LA.eigvals(b)
>>> wa; wb
array([1., 6.])
array([6.+0.j, 1.+0.j]) 

numpy.linalg.norm

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.norm.html

linalg.norm(x, ord=None, axis=None, keepdims=False)

矩阵或向量范数。

此函数能根据ord参数的值返回 8 种不同的矩阵范数，或者无穷多个向量范数（见下文）。

参数：

xarray_like

输入数组。如果axis为 None，则x必须是 1-D 或 2-D，除非ord为 None。如果axis和ord都为 None，则返回x.ravel的 2-范数。

ord，可选

范数的次序（见Notes下的表）。inf 表示 numpy 的inf对象。默认为 None。

axis, 可选。

如果axis是整数，则指定沿着x计算向量范数的轴。如果axis是一个二元组，则指定保存 2-D 矩阵的轴，并计算这些矩阵的矩阵范数。如果axis为 None，则返回向量范数（当x为 1-D）或矩阵范数（当x为 2-D）。默认为 None。

新版 1.8.0 中新增。

keepdimsbool, 可选

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

新版 1.10.0 中新增。

返回：

nfloat or ndarray

矩阵或向量的范数。

另请参阅

scipy.linalg.norm

SciPy 中的类似函数。

注意

对于ord < 1的值，���格地说，结果不是数学上的‘范数’，但对于各种数值目的仍然可能有用。

可计算如下范数：

ord	矩阵的范数	向量的范数
None	弗罗贝尼乌斯范数	2-范数
‘fro’	弗罗贝尼乌斯范数	–
‘nuc’	核范数	–
inf	最大值（沿 axis=1 的绝对值之和）	最大值（绝对值）
-inf	最小值（沿 axis=1 的绝对值之和）	最小值（绝对值）
0	–	sum(x != 0)
1	最大值（沿 axis=0 的绝对值之和）	如下
-1	最小值（沿 axis=0 的绝对值之和）	如下
2	2-范数（最大奇异值）	如下
-2	最小奇异值	如下
其它	–	sum(abs(x)ord)(1./ord)

弗罗贝尼乌斯范数由[1]给出：

(||A||F = [\sum abs(a_{i,j})²]^{1/2})

核范数是奇异值的和。

弗罗贝尼乌斯和核范数顺序仅对矩阵定义，并且当x.ndim != 2时引发 ValueError。

参考

[1]

G. H. Golub 和 C. F. Van Loan，Matrix Computations，Baltimore，MD，约翰霍普金斯大学出版社，1985 年，第 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 

使用axis参数来计算向量范数：

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

使用axis参数来计算矩阵范数：

>>> 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.linalg.cond

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.cond.html

linalg.cond(x, p=None)

计算矩阵的条件数。

该函数能够使用七种不同的范数之一返回条件数，具体取决于p的值（参见下面的参数）。

参数：

x(…, M, N) array_like

寻找条件数的矩阵。

p, 可选

用于计算条件数的范数的阶数：

p	矩阵的范数
---	---
None	2-范数，直接使用 SVD 计算
‘fro’	Frobenius 范数
inf	max(sum(abs(x), axis=1))
-inf	min(sum(abs(x), axis=1))
1	max(sum(abs(x), axis=0))
-1	min(sum(abs(x), axis=0))
2	2-范数（最大奇异值）
-2	最小奇异值

inf 表示 numpy.inf 对象，Frobenius 范数是平方和的平方根范数。

返回：

c

矩阵的条件数。可能是无穷大。

请参阅

numpy.linalg.norm

注意事项

x的条件数被定义为x的范数乘以x的逆的范数[1]；该范数可以是通常的 L2 范数（平方和的平方根），或者是其他许多矩阵范数之一。

参考文献

[1]

G. Strang，《线性代数及其应用》，Orlando, FL, Academic Press, Inc., 1980, pg. 285。

示例

>>> from numpy import linalg as LA
>>> a = np.array([[1, 0, -1], [0, 1, 0], [1, 0, 1]])
>>> a
array([[ 1,  0, -1],
 [ 0,  1,  0],
 [ 1,  0,  1]])
>>> LA.cond(a)
1.4142135623730951
>>> LA.cond(a, 'fro')
3.1622776601683795
>>> LA.cond(a, np.inf)
2.0
>>> LA.cond(a, -np.inf)
1.0
>>> LA.cond(a, 1)
2.0
>>> LA.cond(a, -1)
1.0
>>> LA.cond(a, 2)
1.4142135623730951
>>> LA.cond(a, -2)
0.70710678118654746 # may vary
>>> min(LA.svd(a, compute_uv=False))*min(LA.svd(LA.inv(a), compute_uv=False))
0.70710678118654746 # may vary 

numpy.linalg.det

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.det.html

linalg.det(a)

计算数组的行列式。

参数：

a(…, M, M) array_like

输入用于计算行列式的数组。

返回：

det(…) array_like

a 的行列式。

参见

slogdet

另一种表示行列式的方式，更适用于可能发生下溢/上溢的大矩阵。

scipy.linalg.det

SciPy 中类似的函数。

注意事项

新版本 1.8.0 中增加。

广播规则适用，请参阅numpy.linalg 文档了解详情。

通过使用 LAPACK 例程 z/dgetrf 进行 LU 分解来计算行列式。

示例

2-D 数组[[a, b], [c, d]] 的行列式是 ad - bc：

>>> a = np.array([[1, 2], [3, 4]])
>>> np.linalg.det(a)
-2.0 # may vary 

计算一组矩阵的行列式：

>>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])
>>> a.shape
(3, 2, 2)
>>> np.linalg.det(a)
array([-2., -3., -8.]) 

numpy.linalg.matrix_rank

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.matrix_rank.html

linalg.matrix_rank(A, tol=None, hermitian=False)

使用 SVD 方法返回数组的矩阵秩

数组的秩是大于 tol 的奇异值的数量。

版本 1.14 中的更改：现在可以对矩阵栈进行操作

参数：

A 类数组

输入向量或矩阵栈。

tol（…）类数组，浮点数，可选

SVD 值低于此阈值被视为零。如果 tol 为 None，且 S 为 M 的奇异值数组，eps 为 S 的数据类型的 epsilon 值，则将 tol 设置为 S.max() * max(M, N) * eps。

版本 1.14 中的更改：可广播与矩阵栈

hermitianbool，可选

如果为 True，则假定 A 是共轭（如果为实值，则为对称），从而可以更有效地找到奇异值。默认值为 False。

版本 1.14 中的新功能。

返回：

rank(…) 类数组

A 的秩。

注意事项

用于检测秩缺陷的默认阈值是对 A 的奇异值的幅度的测试。默认情况下，我们将小于 S.max() * max(M, N) * eps 的奇异值视为指示秩缺陷（使用上述符号）。这是 MATLAB 使用的算法[1]。它也出现在 Numerical recipes 中，讨论线性最小二乘的 SVD 解[2]。

这种默认阈值旨在检测秩缺陷，并考虑了 SVD 计算的数值误差。假设 A 中有一列是其他列的精确（在浮点数中）线性组合。在 A 上计算 SVD 通常不会产生一个完全等于 0 的奇异值：最小奇异值与 0 的差异将是由于计算 SVD 时的数值精度导致的。我们对较小的奇异值的阈值考虑了这种数值精度，并且默认阈值将检测到此类数值秩缺陷。即使 A 的某些列的线性组合与 A 的另一列并不完全相等，而只是在数值上非常接近 A 的另一列，该阈值也可以声明矩阵 A 具有秩缺陷。

我们选择我们的默认阈值，因为它被广泛使用。其他阈值也是可能的。例如，Numerical recipes 的 2007 版本中还有一个备选阈值为 S.max() * np.finfo(A.dtype).eps / 2. * np.sqrt(m + n + 1.)。作者将此阈值描述为基于“预期舍入误差”（p 71）。

以上阈值涉及在计算 SVD 时浮点舍入误差的处理。然而，你可能对A中误差源有更多信息，这会让你考虑其他的容差值以检测有效的秩缺乏。最有用的容差度量取决于你打算在矩阵上执行的操作。例如，如果你的数据来自不确定测量，且不确定性大于浮点 epsilon，那么选择接近该不确定性的容差可能更好。如果不确定性是绝对而非相对的，则容差可以是绝对的。

参考文献

[1]

MATLAB 参考文档，“秩” www.mathworks.com/help/techdoc/ref/rank.html

[2]

W. H. Press, S. A. Teukolsky, W. T. Vetterling 和 B. P. Flannery，“Numerical Recipes (第 3 版)”，剑桥大学出版社，2007 年，第 795 页。

示例

>>> from numpy.linalg import matrix_rank
>>> matrix_rank(np.eye(4)) # Full rank matrix
4
>>> I=np.eye(4); I[-1,-1] = 0. # rank deficient matrix
>>> matrix_rank(I)
3
>>> matrix_rank(np.ones((4,))) # 1 dimension - rank 1 unless all 0
1
>>> matrix_rank(np.zeros((4,)))
0 

numpy.linalg.slogdet

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.slogdet.html

linalg.slogdet(a)

计算数组的符号和（自然）对数行列式。

如果一个数组的行列式非常小或非常大，则对det的调用可能会溢出或下溢。这个程序更健壮，因为它计算的是行列式的对数而不是行列式本身。

参数：

a(…, M, M) 数组型

输入数组，必须是二维方阵。

返回：

具有以下属性的命名元组：

sign(…) 数组型

表示行列式符号的数字。对于实矩阵，这是 1、0 或 -1。对于复矩阵，这是绝对值为 1 的复数（即在单位圆上），否则为 0。

logabsdet(…) 数组型

行列式的自然对数绝对值。

如果行列式为零，则sign将为 0，logabsdet 将为

-Inf。在所有情况下，行列式等于sign * np.exp(logabsdet)。

请参阅

det

注意

新版本 1.8.0。

广播规则适用，请参阅numpy.linalg文档以了解详情。

新版本 1.6.0。

通过使用 LAPACK 程序z/dgetrf进行 LU 分解计算行列式。

例子

二维数组[[a, b], [c, d]]的行列式是ad - bc：

>>> a = np.array([[1, 2], [3, 4]])
>>> (sign, logabsdet) = np.linalg.slogdet(a)
>>> (sign, logabsdet)
(-1, 0.69314718055994529) # may vary
>>> sign * np.exp(logabsdet)
-2.0 

为一堆矩阵计算对数行列式：

>>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])
>>> a.shape
(3, 2, 2)
>>> sign, logabsdet = np.linalg.slogdet(a)
>>> (sign, logabsdet)
(array([-1., -1., -1.]), array([ 0.69314718,  1.09861229,  2.07944154]))
>>> sign * np.exp(logabsdet)
array([-2., -3., -8.]) 

这个程序成功了普通的det没有成功的地方：

>>> np.linalg.det(np.eye(500) * 0.1)
0.0
>>> np.linalg.slogdet(np.eye(500) * 0.1)
(1, -1151.2925464970228) 

numpy.trace

原文：numpy.org/doc/1.26/reference/generated/numpy.trace.html

numpy.trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)

返回数组沿对角线的总和。

如果 a 是 2-D，则返回沿其对角线的总和，并给定偏移量，即，所有 i 的元素 a[i,i+offset] 的和。

如果 a 大于两个维度，则由 axis1 和 axis2 指定的轴用于确定返回的迹为 2-D 子数组。返回数组的形状与 a 相同，但删除了 axis1 和 axis2。

参数:

a 类似数组

被取对角线的输入数组。

offset 整数，可选

与主对角线的偏移量。可以为正数或负数。默认为 0。

axis1, axis2 整数，可选

用作应该获取对角线的 2-D 子数组的第一个和第二个轴的轴。默认为 a 的前两轴。

dtype 数据类型，可选

确定返回数组的数据类型以及元素求和的累加器的数据类型。如果 dtype 的值为 None，并且 a 是小于默认整数精度的整数类型，则使用默认整数精度。否则，精度与 a 的精度相同。

out 数组，可选

数组，其输出需放置的位置。其类型保持不变，必须具有正确的形状以容纳输出。

返回:

sum_along_diagonals 数组

如果 a 是 2-D，则返回沿对角线的总和。如果 a 的维度更大，则返回沿对角线的总和数组。

另请参见

diag, diagonal, diagflat

示例

>>> np.trace(np.eye(3))
3.0
>>> a = np.arange(8).reshape((2,2,2))
>>> np.trace(a)
array([6, 8]) 

>>> a = np.arange(24).reshape((2,2,2,3))
>>> np.trace(a).shape
(2, 3) 

numpy.linalg.solve

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.solve.html

linalg.solve(a, b)

解线性矩阵方程或线性标量方程组。

计算线性矩阵方程 ax = b 的“精确”解 x。该方程确定性好，即满秩。

参数：

a(…, M, M) 数组

系数矩阵。

b，数组样式

纵坐标或“因变量”值。

返回值：

x 数组

系统 a x = b 的解。返回形状与 b 相同。

引发错误：

线性代数错误

如果 a 是奇异的或不是方阵。

另请参见

scipy.linalg.solve

SciPy 中类似的函数。

注意事项

新版本 1.8.0 中新增。

适用于广播规则，详情请参见 numpy.linalg 文档。

使用 LAPACK 例程 _gesv 计算解。

a 必须是方阵且满秩，即所有行（或等效地，列）必须线性独立；如果不满足这两个条件，请使用 lstsq 求解系统/方程的最小二乘“解决方案”。

参考资料

[1]

G. Strang, 线性代数及其应用, 第 2 版，奥兰多，FL，Academic Press，Inc。，1980 年，第 22 页。

示例

解方程组 x0 + 2 * x1 = 1 和 3 * x0 + 5 * x1 = 2：

>>> a = np.array([[1, 2], [3, 5]])
>>> b = np.array([1, 2])
>>> x = np.linalg.solve(a, b)
>>> x
array([-1.,  1.]) 

检查解的正确性：

>>> np.allclose(np.dot(a, x), b)
True 

numpy.linalg.tensorsolve

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.tensorsolve.html

linalg.tensorsolve(a, b, axes=None)

解张量方程a x = b，求解x。

假设x的所有索引在乘积中与a的最右边的索引一起被求和，如在例如tensordot(a, x, axes=x.ndim)中所做的那样。

参数：

a类似数组

系数张量，形状为b.shape + Q。Q，一个元组，等于a的子张量的形状，其中包含适当数量的最右边索引，并且必须满足prod(Q) == prod(b.shape)（在这种意义上，a被称为“方阵”）。

b类似数组

右手张量，可以是任意形状。

轴整数元组，可选

对a中的轴重新排序，以便在求逆之前将其移到正确位置。如果为 None（默认），则不进行重新排序。

返回：

x数组，形状 Q

异常：

LinAlgError

如果a是奇异的或不是“方阵”（在上述意义上）。

参见

numpy.tensordot, tensorinv, numpy.einsum

示例

>>> a = np.eye(2*3*4)
>>> a.shape = (2*3, 4, 2, 3, 4)
>>> b = np.random.randn(2*3, 4)
>>> x = np.linalg.tensorsolve(a, b)
>>> x.shape
(2, 3, 4)
>>> np.allclose(np.tensordot(a, x, axes=3), b)
True 

numpy.linalg.lstsq

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.lstsq.html

linalg.lstsq(a, b, rcond='warn')

返回线性矩阵方程的最小二乘解。

计算近似解方程 a @ x = b 的向量 x。方程可能是欠定的、完全确定的或过完全确定的（即，a 的线性独立行数可能小于、等于或大于其线性独立列数）。如果 a 是方的且满秩的，则 x（除舍入误差外）是方程的“精确”解。否则，x 最小化欧几里德二范数 (||b - ax||)。如果有多个最小化解，则返回具有最小二范数 (||x||) 的解。

参数：

a(M, N) 类似数组

“系数”矩阵。

b 类似数组

纵坐标或“因变量”值。如果 b 是二维的，则对 b 的每个 K 列计算最小二乘解。

rcond浮点数，可选

小奇异值的截断比例 a。为了确定秩，如果奇异值小于 rcond 乘以 a 的最大奇异值，则将其视为零。

从 1.14.0 版更改：如果未设置，将给出 FutureWarning。以前的默认值 -1 将使用机器精度作为 rcond 参数，新默认值将使用机器精度乘以 max(M, N)。要消除警告并使用新默认值，请使用 rcond=None，要继续使用旧行为，请使用 rcond=-1。

返回：

x 数组

最小二乘解。如果 b 是二维的，则解在 x 的 K 列中。

残差 数组

残差平方和：对 b - a @ x 中每一列的欧几里德二范数进行平方。如果 a 的秩 < N 或 M <= N，则这是一个空数组。如果 b 是一维的，那么这是一个形状为 (1,) 的数组。否则形状为 (K,)。

秩整数

a 矩阵的秩。

s(min(M, N),) 数组

a 的奇异值。

引发：

LinAlgError

如果计算不收敛。

参见

scipy.linalg.lstsq

SciPy 中的类似函数。

注解

如果 b 是一个矩阵，则所有的数组结果将作为矩阵返回。

例子

通过一些带有噪音数据点的拟合直线，y = mx + c：

>>> x = np.array([0, 1, 2, 3])
>>> y = np.array([-1, 0.2, 0.9, 2.1]) 

通过检查系数，我们发现线条的斜率大约为 1，并在纵轴上大致为-1 处相交。

我们可以将线性方程重写为 y = Ap，其中 A = [[x 1]] 和 p = [[m], [c]]。现在使用 lstsq 解出 p：

>>> A = np.vstack([x, np.ones(len(x))]).T
>>> A
array([[ 0.,  1.],
 [ 1.,  1.],
 [ 2.,  1.],
 [ 3.,  1.]]) 

>>> m, c = np.linalg.lstsq(A, y, rcond=None)[0]
>>> m, c
(1.0 -0.95) # may vary 

绘制数据以及拟合的直线：

>>> import matplotlib.pyplot as plt
>>> _ = plt.plot(x, y, 'o', label='Original data', markersize=10)
>>> _ = plt.plot(x, m*x + c, 'r', label='Fitted line')
>>> _ = plt.legend()
>>> plt.show() 

../../_images/numpy-linalg-lstsq-1.png

numpy.linalg.inv

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.inv.html

linalg.inv(a)

计算矩阵的（乘法）逆。

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

参数：

a(…, M, M) 数组样式

要求求逆的矩阵。

返回：

ainv(…, M, M) ndarray 或 矩阵

矩阵 a 的（乘法）逆。

引发：

LinAlgError

如果 a 不是方阵或求逆失败。

另请参阅

scipy.linalg.inv

SciPy 中的类似函数。

注释

1.8.0 版本中的新功能。

广播规则适用，请参阅numpy.linalg文档以获取详细信息。

示例

>>> 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.linalg.pinv

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.pinv.html

linalg.pinv(a, rcond=1e-15, hermitian=False)

计算矩阵的（M-彭罗斯）伪逆。

使用奇异值分解（SVD）计算矩阵的广义逆，并包括所有大奇异值。

从版本 1.14 开始发生变化：现在可以操作矩阵堆叠

Parameters:

a(…, M, N) 数组

要求伪逆的矩阵或矩阵堆叠。

rcond(…) 浮点数的数组

小奇异值的截断。小于或等于rcond * largest_singular_value的奇异值被设为零。广播到矩阵堆叠。

hermitianbool, optional

如果为 True，则假定a是埃尔米特（如果为实值，则为对称），从而可以更有效地找到奇异值的方法。 默认为 False。

版本 1.17.0 中的新功能。

Returns:

B(…, N, M) ndarray

a的伪逆。如果a是matrix实例，则B也是。

Raises:

LinAlgError

如果 SVD 计算无法收敛。

See also

scipy.linalg.pinv

SciPy 中的类似函数。

scipy.linalg.pinvh

计算埃尔米特矩阵的（M-彭罗斯）伪逆。

Notes

矩阵 A 的伪逆，表示为(A^+)，定义为：“‘解决’[最小二乘问题]的矩阵(Ax = b)”，即，如果(\bar{x})是所述解决方案，则(A^+)是那个矩阵，使得(\bar{x} = A^+b)。

可以表明，如果(Q_1 \Sigma Q_2^T = A)是 A 的奇异值分解，则(A^+ = Q_2 \Sigma^+ Q_1^T)，其中(Q_{1,2})是正交矩阵，(\Sigma)是由 A 的所谓奇异值构成的对角矩阵（通常后面是零），然后(\Sigma^+)是简单地由 A 的奇异值的倒数构成的对角矩阵（同样后面是零）。[1]

References

[1]

G. Strang，线性代数及其应用，第 2 版，奥兰多，FL，学术出版社，1980 年，第 139-142 页。

Examples

以下示例检查a * a+ * a == a和a+ * a * a+ == a+是否成立：

>>> a = np.random.randn(9, 6)
>>> B = np.linalg.pinv(a)
>>> np.allclose(a, np.dot(a, np.dot(B, a)))
True
>>> np.allclose(B, np.dot(B, np.dot(a, B)))
True 

numpy.linalg.tensorinv

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.tensorinv.html

linalg.tensorinv(a, ind=2)

计算 N 维数组的“逆”。

结果是相对于 tensordot 操作tensordot(a, b, ind)的a的逆，即，达到浮点精度，tensordot(tensorinv(a), a, ind)是 tensordot 操作的"单位"张量。

参数：

aarray_like

Tensor to ‘invert’. Its shape must be ‘square’, i. e., prod(a.shape[:ind]) == prod(a.shape[ind:]).

indint, 可选

参与逆求和的第一个索引的数量。必须是正整数，默认值为 2。

返回：

bndarray

a的 tensordot 逆，形状为a.shape[ind:] + a.shape[:ind]。

抛出：

LinAlgError

如果a是奇异的或者不是“方形”（在上述意义上）。

另请参阅

numpy.tensordot, tensorsolve

示例

>>> a = np.eye(4*6)
>>> a.shape = (4, 6, 8, 3)
>>> ainv = np.linalg.tensorinv(a, ind=2)
>>> ainv.shape
(8, 3, 4, 6)
>>> b = np.random.randn(4, 6)
>>> np.allclose(np.tensordot(ainv, b), np.linalg.tensorsolve(a, b))
True 

>>> a = np.eye(4*6)
>>> a.shape = (24, 8, 3)
>>> ainv = np.linalg.tensorinv(a, ind=1)
>>> ainv.shape
(8, 3, 24)
>>> b = np.random.randn(24)
>>> np.allclose(np.tensordot(ainv, b, 1), np.linalg.tensorsolve(a, b))
True 

numpy.linalg.LinAlgError

原文：numpy.org/doc/1.26/reference/generated/numpy.linalg.LinAlgError.html

exception linalg.LinAlgError

由 linalg 函数引发的通用 Python 异常衍生对象。

通用目的异常类，从 Python 的 ValueError 类派生，当线性代数相关条件会阻止函数进一步正确执行时，在 linalg 函数中以程序方式引发。

参数：

无

例子

>>> from numpy import linalg as LA
>>> LA.inv(np.zeros((2,2)))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
 File "...linalg.py", line 350,
 in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 File "...linalg.py", line 249,
 in solve
 raise LinAlgError('Singular matrix')
numpy.linalg.LinAlgError: Singular matrix 

逻辑函数

原文：numpy.org/doc/1.26/reference/routines.logic.html

真值测试

all(a[, axis, out, keepdims, where])	测试数组沿给定轴的所有元素是否都为 True。
any(a[, axis, out, keepdims, where])	测试数组沿给定轴是否存在任意元素为 True。

数组内容

isfinite(x, /[, out, where, casting, order, ...])	测试元素级是否为有限数(非无穷大且非 NaN)。
isinf(x, /[, out, where, casting, order, ...])	测试元素级是否为正无穷大或负无穷大。
isnan(x, /[, out, where, casting, order, ...])	测试元素级是否为 NaN，并以布尔数组形式返回结果。
isnat(x, /[, out, where, casting, order, ...])	测试元素级是否为非时间(NaT)，并以布尔数组形式返回结果。
isneginf(x[, out])	测试元素级是否为负无穷大，并以布尔数组形式返回结果。
isposinf(x[, out])	测试元素级是否为正无穷大，并以布尔数组形式返回结果。

数组类型测试

iscomplex(x)	返回一个布尔数组，如果输入元素是复数则为 True。
iscomplexobj(x)	检查是否为复数类型或复数数组。
isfortran(a)	检查数组是否为 Fortran 连续但不为 C 连续。
isreal(x)	返回一个布尔数组，如果输入元素是实数则为 True。
isrealobj(x)	如果 x 是非复数类型或复数数组，则返回 True。
isscalar(element)	如果 element 的类型是标量类型，则返回 True。

逻辑操作

logical_and(x1, x2, /[, out, where, ...])	逐元素计算 x1 和 x2 的真值。
logical_or(x1, x2, /[, out, where, casting, ...])	逐元素计算 x1 或 x2 的真值。
logical_not(x, /[, out, where, casting, ...])	逐元素计算 NOT x 的真值。
logical_xor(x1, x2, /[, out, where, ...])	逐元素计算 x1 XOR x2 的真值。

比较

allclose(a, b[, rtol, atol, equal_nan])	如果两个数组在容差内逐元素相等则返回 True。
isclose(a, b[, rtol, atol, equal_nan])	返回一个布尔数组，其中两个数组在容差内逐元素相等。
array_equal(a1, a2[, equal_nan])	如果两个数组具有相同的形状和元素，则返回 True，否则返回 False。
array_equiv(a1, a2)	如果输入数组形状一致且所有元素相等则返回 True。
greater(x1, x2, /[, out, where, casting, ...])	返回（x1 > x2）的逐元素真值。
greater_equal(x1, x2, /[, out, where, ...])	返回（x1 >= x2）的逐元素真值。
	less(x1, x2, /[, out, where, casting, ...])
less_equal(x1, x2, /[, out, where, casting, ...])	返回（x1 <= x2）的逐元素真值。
	equal(x1, x2, /[, out, where, casting, ...])
not_equal(x1, x2, /[, out, where, casting, ...])	逐元素返回（x1 != x2）。

真值测试

all(a[, axis, out, keepdims, where])	测试沿给定轴的所有数组元素是否求值为 True。
	any(a[, axis, out, keepdims, where])

数组内容

isfinite(x, /[, out, where, casting, order, ...])	逐元素测试是否为有限值（既不是无穷大也不是非数）。
isinf(x, /[, out, where, casting, order, ...])	逐元素测试是否为正无穷或负无穷。
isnan(x, /[, out, where, casting, order, ...])	逐元素测试是否为 NaN，并将结果作为布尔数组返回。
isnat(x, /[, out, where, casting, order, ...])	逐元素测试是否为 NaT（不是时间），并返回布尔数组结果。
isneginf(x[, out])	逐元素测试是否为负无穷大，返回布尔数组结果。
isposinf(x[, out])	逐元素测试是否为正无穷大，返回布尔数组结果。

数组类型测试

iscomplex(x)	返回一个布尔数组，输入元素为复数时返回 True。
iscomplexobj(x)	检查复数类型或复数数组。
isfortran(a)	检查数组是否是 Fortran 连续但不是C 连续。
isreal(x)	返回一个布尔数组，输入元素为实数时返回 True。
isrealobj(x)	如果 x 是非复数类型或复数数组，则返回 True。
isscalar(element)	如果 element 的类型是标量类型，则返回 True。

逻辑运算

logical_and(x1, x2, /[, out, where, ...])	逐元素计算 x1 AND x2 的真值。
logical_or(x1, x2, /[, out, where, casting, ...])	逐元素计算 x1 OR x2 的真值。
logical_not(x, /[, out, where, casting, ...])	逐元素计算 NOT x 的真值。
logical_xor(x1, x2, /[, out, where, ...])	逐元素计算 x1 XOR x2 的真值。

比较

allclose(a, b[, rtol, atol, equal_nan])	如果两个数组在容差范围内逐元素相等，则返回 True。
isclose(a, b[, rtol, atol, equal_nan])	返回一个布尔数组，在容差范围内两个数组逐元素相等。
array_equal(a1, a2[, equal_nan])	如果两个数组具有相同的形状和元素，则为 True，否则为 False。
array_equiv(a1, a2)	如果输入数组形状一致且所有元素相等，则返回 True。
greater(x1, x2, /[, out, where, casting, ...])	返回逐元素 (x1 > x2) 的真值。
greater_equal(x1, x2, /[, out, where, ...])	返回逐元素 (x1 >= x2) 的真值。
less(x1, x2, /[, out, where, casting, ...])	返回逐元素 (x1 < x2) 的真值。
less_equal(x1, x2, /[, out, where, casting, ...])	返回逐元素 (x1 <= x2) 的真值。
equal(x1, x2, /[, out, where, casting, ...])	返回逐元素 (x1 == x2) 的真值。
not_equal(x1, x2, /[, out, where, casting, ...])	返回逐元素 (x1 != x2) 的真值。

numpy.all

原文：numpy.org/doc/1.26/reference/generated/numpy.all.html

numpy.all(a, axis=None, out=None, keepdims=<no value>, *, where=<no value>)

测试给定轴向的所有数组元素是否评估为 True。

参数：

aarray_like

输入数组或可转换为数组的对象。

axisNone 或 int 或 int 的元组，可选

执行逻辑 AND 减少的轴或轴。默认值（axis=None）是对输入数组的所有维度执行逻辑 AND。axis可能是负数，此时它从最后一个轴计数到第一个轴。

在 1.7.0 版本中新增。

如果这是一个 int 的元组，则对多个轴执行减少操作，而不是像以前一样对单个轴或所有轴执行减少操作。

outndarray，可选

替代输出数组，用于放置结果。它必须具有与期望输出相同的形状，并且其类型将被保留（例如，如果dtype(out)是 float，则结果将由 0.0 和 1.0 组成）。有关更多详细信息，请参见输出类型确定。

keepdimsbool，可选

如果设置为 True，则被减少的轴会作为大小为一的维度保留在结果中。使用此选项，结果将正确地与输入数组进行广播。

如果传递了默认值，则不会将keepdims传递给all的子类的方法，但任何非默认值都会。如果子类的方法未实现keepdims，则会引发任何异常。

wherebool 数组，可选

用于检查所有True值的元素。有关详细信息，请参见reduce。

在 1.20.0 版本中新增。

返回：

allndarray, bool

除非指定了out，否则将返回新的布尔值或数组，其中out的引用将被返回。

另请参见

ndarray.all

等效方法

any

测试给定轴向的任何元素是否评估为 True。

注意

不是数字（NaN）、正无穷大和负无穷大的计算结果为True，因为它们不等于零。

示例

>>> np.all([[True,False],[True,True]])
False 

>>> np.all([[True,False],[True,True]], axis=0)
array([ True, False]) 

>>> np.all([-1, 4, 5])
True 

>>> np.all([1.0, np.nan])
True 

>>> np.all([[True, True], [False, True]], where=[[True], [False]])
True 

>>> o=np.array(False)
>>> z=np.all([-1, 4, 5], out=o)
>>> id(z), id(o), z
(28293632, 28293632, array(True)) # may vary