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

NumPy 1.26 中文文档（十）

原文：numpy.org/doc/

numpy.iinfo

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

class numpy.iinfo(type)

整数类型的机器限制。

参数：

int_type整数类型，dtype 或实例

要获取信息的整数数据类型的种类。

另请参阅

finfo

浮点数数据类型的等价物。

示例

对类型：

>>> ii16 = np.iinfo(np.int16)
>>> ii16.min
-32768
>>> ii16.max
32767
>>> ii32 = np.iinfo(np.int32)
>>> ii32.min
-2147483648
>>> ii32.max
2147483647 

对实例：

>>> ii32 = np.iinfo(np.int32(10))
>>> ii32.min
-2147483648
>>> ii32.max
2147483647 

属性：

bitsint

类型所占的位数。

dtypedtype

返回iinfo返回信息的 dtype。

minint

给定 dtype 的最小值。

maxint

给定 dtype 的最大值。

numpy.issctype

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

numpy.issctype(rep)

确定给定对象是否表示标量数据类型。

参数：

repany

如果 rep 是标量 dtype 的实例，则返回 True。如果不是，则返回 False。

返回：

outbool

检查 rep 是否是标量 dtype 的布尔结果。

参见

issubsctype, issubdtype, obj2sctype, sctype2char

示例

>>> np.issctype(np.int32)
True
>>> np.issctype(list)
False
>>> np.issctype(1.1)
False 

字符串也是标量类型：

>>> np.issctype(np.dtype('str'))
True 

numpy.issubdtype

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

numpy.issubdtype(arg1, arg2)

如果第一个参数是类型码，且在类型层次结构中较低/相等，则返回 True。

这类似于内置的 issubclass, 但适用于 dtype.

参数:

arg1, arg2dtype_like

dtype 或可转换为其的对象

返回:

outbool

另请参阅

标量

numpy 类型层次结构概览。

issubsctype, issubclass_

例子

issubdtype 可以用来检查数组的类型：

>>> ints = np.array([1, 2, 3], dtype=np.int32)
>>> np.issubdtype(ints.dtype, np.integer)
True
>>> np.issubdtype(ints.dtype, np.floating)
False 

>>> floats = np.array([1, 2, 3], dtype=np.float32)
>>> np.issubdtype(floats.dtype, np.integer)
False
>>> np.issubdtype(floats.dtype, np.floating)
True 

不同大小的类似类型不是彼此的子类型：

>>> np.issubdtype(np.float64, np.float32)
False
>>> np.issubdtype(np.float32, np.float64)
False 

但两者都是 floating 的子类型：

>>> np.issubdtype(np.float64, np.floating)
True
>>> np.issubdtype(np.float32, np.floating)
True 

为方便起见，也允许使用类似 dtype 的对象：

>>> np.issubdtype('S1', np.string_)
True
>>> np.issubdtype('i4', np.signedinteger)
True 

numpy.issubsctype

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

numpy.issubsctype(arg1, arg2)

确定第一个参数是否是第二个参数的子类。

参数：

arg1, arg2数据类型或数据类型说明符

数据类型。

返回：

outbool

结果。

另请参见

issctype, issubdtype, obj2sctype

示例

>>> np.issubsctype('S8', str)
False
>>> np.issubsctype(np.array([1]), int)
True
>>> np.issubsctype(np.array([1]), float)
False 

numpy.issubclass_

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

numpy.issubclass_(arg1, arg2)

判断一个类是否是第二个类的子类。

issubclass_ 等同于 Python 内置的issubclass，不同之处在于如果其中一个参数不是类，则返回 False 而不是引发 TypeError。

参数：

arg1类

输入类。如果arg1是arg2的子类，则返回 True。

arg2类或类元组。

输入类。如果是类元组，则如果arg1是元组元素之一的子类，则返回 True。

返回值：

out布尔值

arg1是否是arg2的子类。

另请参见

issubsctype, issubdtype, issctype

示例

>>> np.issubclass_(np.int32, int)
False
>>> np.issubclass_(np.int32, float)
False
>>> np.issubclass_(np.float64, float)
True 

numpy.find_common_type

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

numpy.find_common_type(array_types, scalar_types)

遵循标准强制规则确定共同类型。

自 NumPy 版本 1.25 起已弃用：

此函数已被弃用，请使用numpy.promote_types或numpy.result_type。要为scalar_types参数实现语义，请使用numpy.result_type并传递 Python 值 0, 0.0，或 0j。在几乎所有情况下，这将得到相同的结果。有关更多信息和罕见的例外，请参阅NumPy 1.25 发行说明。

参数：

array_types序列

由表示数组的 dtypes 或可转换为 dtype 的对象组成的列表。

scalar_types序列

由表示标量的 dtypes 或可转换为 dtype 的对象组成的列表。

返回：

datatypedtype

共同的数据类型，即array_types中的最大值，忽略scalar_types，除非scalar_types的最大值属于不同种类（dtype.kind）。如果该种类不被理解，则返回 None。

另请参考

dtype, common_type, can_cast, mintypecode

示例

>>> np.find_common_type([], [np.int64, np.float32, complex])
dtype('complex128')
>>> np.find_common_type([np.int64, np.float32], [])
dtype('float64') 

标准的类型转换规则确保了标量不会将数组向上转型，除非标量属于一种完全不同类型的数据（即在数据类型层次结构中处于不同的层级）：

>>> np.find_common_type([np.float32], [np.int64, np.float64])
dtype('float32') 

复数是一种不同类型，因此它会将array_types参数中的浮点数向上转型：

>>> np.find_common_type([np.float32], [complex])
dtype('complex128') 

类型说明字符串可转换为 dtypes，因此可以用于替代 dtypes：

>>> np.find_common_type(['f4', 'f4', 'i4'], ['c8'])
dtype('complex128') 

numpy.typename

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

numpy.typename(char)

返回给定数据类型代码的描述。

参数：

charstr

数据类型代码。

返回：

outstr

输入数据类型代码的描述。

另请参阅

dtype, typecodes

示例

>>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q',
...              'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q']
>>> for typechar in typechars:
...     print(typechar, ' : ', np.typename(typechar))
...
S1  :  character
?  :  bool
B  :  unsigned char
D  :  complex double precision
G  :  complex long double precision
F  :  complex single precision
I  :  unsigned integer
H  :  unsigned short
L  :  unsigned long integer
O  :  object
Q  :  unsigned long long integer
S  :  string
U  :  unicode
V  :  void
b  :  signed char
d  :  double precision
g  :  long precision
f  :  single precision
i  :  integer
h  :  short
l  :  long integer
q  :  long long integer 

numpy.sctype2char

译文：numpy.org/doc/1.26/reference/generated/numpy.sctype2char.html

numpy.sctype2char(sctype)

返回标量 dtype 的字符串表示形式。

参数:

sctype标量 dtype 或对象

如果是标量 dtype，则返回相应的字符串字符。如果是对象，sctype2char试图推断其标量类型，然后返回相应的字符串字符。

返回：

typecharstr

与标量类型对应的字符串字符。

异常：

ValueError

如果sctype是一个无法推断类型的对象。

另请参阅

obj2sctype, issctype, issubsctype, mintypecode

示例

>>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]:
...     print(np.sctype2char(sctype))
l # may vary
d
D
S
O 

>>> x = np.array([1., 2-1.j])
>>> np.sctype2char(x)
'D'
>>> np.sctype2char(list)
'O' 

numpy.mintypecode

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

numpy.mintypecode(typechars, typeset='GDFgdf', default='d')

返回给定类型可以安全转换的最小大小类型的字符。

返回的类型字符必须代表最小大小的 dtype，以便返回类型的数组可以处理typechars中所有类型的数组的数据（或者如果typechars是一个数组，则其 dtype.char）。

参数：

typecharsstr 列表或 array_like

如果是字符串列表，则每个字符串应代表一个 dtype。如果是 array_like，则使用数组 dtype 的字符表示。

typesetstr 或 str 列表，可选

返回字符的字符集。默认字符集为‘GDFgdf’。

defaultstr，可选

默认字符，如果typechars中的字符没有匹配typeset中的字符，则返回默认字符。

返回：

typecharstr

代表找到的最小大小类型的字符。

另请参阅

dtype, sctype2char, maximum_sctype

示例

>>> np.mintypecode(['d', 'f', 'S'])
'd'
>>> x = np.array([1.1, 2-3.j])
>>> np.mintypecode(x)
'D' 

>>> np.mintypecode('abceh', default='G')
'G' 

numpy.maximum_sctype

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

numpy.maximum_sctype(t)

返回输入的与之最高精度相同类型的标量类型。

参数：

tdtype 或 dtype 指示符

输入的数据类型。可以是一个dtype 对象或可转换为dtype 的对象。

返回：

outdtype

与 t 相同类型的最高精度数据类型(dtype.kind )。

另请参阅

obj2sctype， mintypecode， sctype2char

dtype

示例：

>>> np.maximum_sctype(int)
<class 'numpy.int64'>
>>> np.maximum_sctype(np.uint8)
<class 'numpy.uint64'>
>>> np.maximum_sctype(complex)
<class 'numpy.complex256'> # may vary 

>>> np.maximum_sctype(str)
<class 'numpy.str_'> 

>>> np.maximum_sctype('i2')
<class 'numpy.int64'>
>>> np.maximum_sctype('f4')
<class 'numpy.float128'> # may vary 

具有自动定义域的数学函数

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

注释

numpy.emath 是 numpy.lib.scimath 的一个首选别名，在导入 numpy 后可用。

包装函数以更用户友好的方式调用某些数学函数，其输出数据类型在输入的某些域中与输入数据类型不同。

例如，对于像log这样具有分支切割的函数，该模块中的版本在复平面上提供数学上有效的答案：

>>> import math
>>> np.emath.log(-math.exp(1)) == (1+1j*math.pi)
True 

类似地，sqrt，其他基数对数，power 和三角函数都得到了正确处理。请参阅各自的文档字符串以获取特定的示例。

函数

sqrt(x)	计算x的平方根。
log(x)	计算x的自然对数。
log2(x)	计算x的对数，以 2 为底。
logn(n, x)	计算以 n 为底的 x 的对数。
log10(x)	计算x的对数，以 10 为底。
power(x, p)	x 的 p 次方，(x**p)。
arccos(x)	计算x的反余弦值。
arcsin(x)	计算x的反正弦值。
arctanh(x)	计算x的反双曲正切值。

函数

sqrt(x)	计算x的平方根。
log(x)	计算x的自然对数。
log2(x)	计算x的对数，以 2 为底。
logn(n, x)	计算以 n 为底的 x 的对数。
log10(x)	计算x的对数，以 10 为底。
power(x, p)	返回 x 的 p 次方，(x**p)。
arccos(x)	计算 x 的反余弦值。
arcsin(x)	计算 x 的反正弦值。
arctanh(x)	计算 x 的反双曲正切值。

numpy.emath.sqrt

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

emath.sqrt(x)

计算 x 的平方根。

对于负输入元素，会返回一个复数（与numpy.sqrt不同，它会返回 NaN）。

参数：

x类似数组

输入值。

返回：

outndarray 或标量

x的平方根。如果x是标量，out也是如此，否则将返回一个数组。

另请参阅

numpy.sqrt

示例

对于真实且非负的输入，这就像使用numpy.sqrt一样：

>>> np.emath.sqrt(1)
1.0
>>> np.emath.sqrt([1, 4])
array([1.,  2.]) 

但它自动处理负输入：

>>> np.emath.sqrt(-1)
1j
>>> np.emath.sqrt([-1,4])
array([0.+1.j, 2.+0.j]) 

由于：浮点数 0.0 和-0.0 是不同的，所以会有不同的结果。

要更加灵活地控制，可显式地使用complex()如下所示：

>>> np.emath.sqrt(complex(-4.0, 0.0))
2j
>>> np.emath.sqrt(complex(-4.0, -0.0))
-2j 

numpy.emath.log

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

emath.log(x)

计算 x 的自然对数。

返回 (log_e(x)) 的“主值”（有关此内容的描述，请参见numpy.log）。对于实数 x > 0，这是一个实数（log(0)返回-inf，log(np.inf)返回inf）。否则，返回复数的主值。

参数：

x类似数组

需要其对数的值。

返回：

out 数组或标量

x 值的对数。如果 x 是标量，则 out 也是标量，否则返回数组。

另请参阅

numpy.log

注意

对于在实数 x < 0 时返回NAN的 log()，请使用numpy.log（注意，然而，否则numpy.log和这个log是相同的，即返回-inf，返回inf，并且如果x.imag != 0则返回复数的主值）。

示例

>>> np.emath.log(np.exp(1))
1.0 

负参数被处理“正确”（请注意exp(log(x)) == x不适用于实数x < 0）：

>>> np.emath.log(-np.exp(1)) == (1 + np.pi * 1j)
True 

numpy.emath.log2

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

emath.log2(x)

计算以 2 为底的 x 的对数。

返回 (log_2(x)) 的“主值”（有关此的描述，请参见numpy.log2）。对于实 x > 0，这是一个实数（log2(0) 返回 -inf，log2(np.inf) 返回 inf）。否则，返回复数主值。

参数：

x：array_like

需要取对数的数值（们）。

返回：

out：ndarray 或 标量

x 值的以 2 为底的对数。如果 x 是标量，则 out 也是标量，否则返回一个数组。

另请参见

numpy.log2

注释

要求实 x < 0 时返回 NAN 的 log2()，请使用 numpy.log2（但请注意，否则 numpy.log2 和此 log2 相同，即对于 x = 0 两者都返回 -inf，对于 x = inf 都返回 inf，并且特别地，如果 x.imag != 0 则返回复数的主值）。

示例

我们设置打印精度，以便可以自动测试示例：

>>> np.set_printoptions(precision=4) 

>>> np.emath.log2(8)
3.0
>>> np.emath.log2([-4, -8, 8])
array([2.+4.5324j, 3.+4.5324j, 3.+0.j    ]) 

numpy.emath.logn

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

emath.logn(n, x)

对x取以n为底的对数。

如果x包含负数输入，则结果在复数域中计算并返回。

参数：

n：类似于数组

计算对数的整数底数。

x：类似于数组

需要计算其底为n的对数值（或者值）的数值（或者值）。

返回值：

out：ndarray 或 标量

x的底为n的对数值（或者值）。如果x是一个标量，则out也是标量，否则返回一个数组。

示例：

>>> np.set_printoptions(precision=4) 

>>> np.emath.logn(2, [4, 8])
array([2., 3.])
>>> np.emath.logn(2, [-4, -8, 8])
array([2.+4.5324j, 3.+4.5324j, 3.+0.j    ]) 

numpy.emath.log10

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

emath.log10(x)

计算x的以 10 为底的对数。

返回log_{10}(x)的“主值”（有关此内容的描述，请参阅numpy.log10）。对于实数x > 0，这是一个实数（log10(0)返回-inf，log10(np.inf)返回inf）。否则，返回复数主值。

参数：

xarray_like 或标量

需要其以 10 为底的对数的值。

返回值：

outndarray 或标量

x值的以 10 为底的对数。如果x是标量，则out也是标量，否则返回一个数组对象。

另请参阅

numpy.log10

注意事项

对于 log10()在真实x < 0时返回NAN的情况，请使用numpy.log10（不过，请注意，否则numpy.log10和这个log10是相同的，即对于x = 0，两者都返回-inf，对于x = inf，都返回inf，特别地，如果x.imag != 0，则返回复数主值）。

示例

（我们设置了打印精度，以便自动测试示例）

>>> np.set_printoptions(precision=4) 

>>> np.emath.log10(10**1)
1.0 

>>> np.emath.log10([-10**1, -10**2, 10**2])
array([1.+1.3644j, 2.+1.3644j, 2.+0.j    ]) 

numpy.emath.power

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

emath.power(x, p)

将 x 提高到幂 p，(x**p)。

如果x包含负值，则输出将转换为复数域。

参数：

x数组样式

输入值。

p int 的数组样式

将x提高到的幂。如果x包含多个值，则p必须是标量，或者包含与x相同数量的值。在后一种情况下，结果是x[0]**p[0], x[1]**p[1], ...。

返回：

out ndarray 或标量

x**p的结果。如果x和p是标量，则out也是标量，否则返回数组。

另请参阅

numpy.power

示例

>>> np.set_printoptions(precision=4) 

>>> np.emath.power([2, 4], 2)
array([ 4, 16])
>>> np.emath.power([2, 4], -2)
array([0.25  ,  0.0625])
>>> np.emath.power([-2, 4], 2)
array([ 4.-0.j, 16.+0.j]) 

numpy.emath.arccos

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

emath.arccos(x)

计算x的反余弦。

返回x的反余弦的“主值”（关于此的描述，请参见numpy.arccos）。对于实数x，使得abs(x) <= 1，这是一个闭区间([0, \pi])中的实数。否则，返回复数的主值。

参数：

x 类似数组或 标量

需要其 arccos 的值。

返回值：

out ndarray 或 标量

x值的反余弦。如果x是标量，则out也是如此，否则将返回一个数组对象。

另请参阅

numpy.arccos

注意事项

对于一个返回NAN的 arccos()，当实数x不在区间[-1,1]时，请使用numpy.arccos。

示例

>>> np.set_printoptions(precision=4) 

>>> np.emath.arccos(1) # a scalar is returned
0.0 

>>> np.emath.arccos([1,2])
array([0.-0.j   , 0.-1.317j]) 

numpy.emath.arcsin

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

emath.arcsin(x)

计算 x 的反正弦。

返回 x 的反正弦的“主值”（有关此主值的描述，请参见 numpy.arcsin）。对于实数 x 使得 abs(x) <= 1，这是一个闭区间内的实数 ([-\pi/2, \pi/2])。否则，返回复数的主值。

参数：

x，array_like 或标量

需要计算反正弦的值。

返回值：

out，ndarray 或标量

x 值的反正弦。如果 x 是标量，则 out 也是标量，否则将返回数组对象。

另请参见

numpy.arcsin

注意事项

对于一个 arcsin() 当实数 x 不在区间[-1,1]时返回 NAN，请使用 numpy.arcsin。

示例

>>> np.set_printoptions(precision=4) 

>>> np.emath.arcsin(0)
0.0 

>>> np.emath.arcsin([0,1])
array([0\.    , 1.5708]) 

numpy.emath.arctanh

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

emath.arctanh(x)

计算 x 的反双曲正切值。

返回arctanh(x)的“主值”（关于此的描述，请参见numpy.arctanh）。对于实数 x，使得 abs(x) < 1，这将是一个实数。如果 abs(x) > 1，或者 x 为复数，则结果为复数。最后，x = 1返回inf，x=-1返回-inf。

参数：

x类数组

需要求其反双曲正切值的值（们）。

返回：

out数组或标量

x 值的反双曲正切值。如果 x 是标量，则 out 也是标量，否则返回一个数组。

也见

numpy.arctanh

注释

对于 NAN 返回的反双曲正切值在实际 x 不在区间 (-1,1)时，请使用numpy.arctanh(然而，对于 x = +/-1，此后者返回 +/-inf)。

示例

>>> np.set_printoptions(precision=4) 

>>> from numpy.testing import suppress_warnings
>>> with suppress_warnings() as sup:
...     sup.filter(RuntimeWarning)
...     np.emath.arctanh(np.eye(2))
array([[inf,  0.],
 [ 0., inf]])
>>> np.emath.arctanh([1j])
array([0.+0.7854j]) 

浮点错误处理

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

设置和获取错误处理

seterr([all, divide, over, under, invalid])	设置处理浮点错误的方式。
geterr()	获取当前处理浮点错误的方式。
seterrcall(func)	设置浮点错误回调函数或日志对象。
geterrcall()	返回当前用于浮点错误的回调函数。
errstate(**kwargs)	用于处理浮点错误的上下文管理器。

内部函数

seterrobj(errobj, /)	设置定义浮点错误处理的对象。
geterrobj()	返回定义浮点错误处理的当前对象。

设置和获取错误处理

seterr([all, divide, over, under, invalid])	设置处理浮点错误的方式。
geterr()	获取当前处理浮点错误的方式。
seterrcall(func)	设置浮点错误回调函数或日志对象。
geterrcall()	返回当前用于浮点错误的回调函数。
errstate(**kwargs)	用于处理浮点错误的上下文管理器。

内部函数

seterrobj(errobj, /)	设置定义浮点错误处理的对象。
geterrobj()	返回定义浮点错误处理的当前对象。

numpy.seterr

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

numpy.seterr(all=None, divide=None, over=None, under=None, invalid=None)

设置浮点错误的处理方式。

注意，对整数标量类型（例如int16）的操作与浮点数类型相同，并且受到这些设置的影响。

参数：

all，可选

一次性设置所有类型的浮点错误处理方式：

• ignore：当异常发生时不采取任何操作。

• warn：通过 Python warnings模块打印RuntimeWarning。

• raise：引发FloatingPointError。

• 调用：使用seterrcall函数指定调用一个函数。

• print：直接在stdout上打印警告。

• log：记录由seterrcall指定的 Log 对象中的错误。

默认情况下不更改当前行为。

divide，可选

除零处理方式。

over，可选

浮点溢出的处理方式。

under，可选

浮点下溢处理方式。

invalid，可选

无效浮点操作的处理方式。

返回：

old_settingsdict

包含旧设置的字典。

另请参见

seterrcall

设置“call”模式的回调函数。

geterr，geterrcall，errstate

注意事项

浮点异常在 IEEE 754 标准[1]中定义：

• 除零：从有限数得到无限结果。

• 溢出：结果太大无法表示。

• 下溢：结果接近零，导致丢失了一些精度。

• 无效操作：结果不是可表示的数字，通常表示产生了 NaN。

[1]

en.wikipedia.org/wiki/IEEE_754

示例

>>> old_settings = np.seterr(all='ignore')  #seterr to known value
>>> np.seterr(over='raise')
{'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}
>>> np.seterr(**old_settings)  # reset to default
{'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'} 

>>> np.int16(32000) * np.int16(3)
30464
>>> old_settings = np.seterr(all='warn', over='raise')
>>> np.int16(32000) * np.int16(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FloatingPointError: overflow encountered in scalar multiply 

>>> old_settings = np.seterr(all='print')
>>> np.geterr()
{'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'}
>>> np.int16(32000) * np.int16(3)
30464 

numpy.geterr

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

numpy.geterr()

获取当前处理浮点数错误的方式。

返回：

resdict

一个字典，键为“divide”、“over”、“under”和“invalid”，对应的值为字符串“ignore”、“print”、“log”、“warn”、“raise”和“call”。这些键代表可能发生的浮点数异常，而这些值定义了如何处理这些异常。

另请参阅

geterrcall，seterr，seterrcall

笔记

若要详细了解浮点数异常的类型和处理选项，请参阅seterr的完整文档。

示例

>>> np.geterr()
{'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'}
>>> np.arange(3.) / np.arange(3.)
array([nan,  1.,  1.]) 

>>> oldsettings = np.seterr(all='warn', over='raise')
>>> np.geterr()
{'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'}
>>> np.arange(3.) / np.arange(3.)
array([nan,  1.,  1.]) 

numpy.seterrcall

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

numpy.seterrcall(func)

设置浮点错误回调函数或日志对象。

有两种方法可以捕获浮点错误消息。首先是将错误处理程序设置为 'call'，使用 seterr。然后，设置要使用此函数调用的函数。

第二种方法是将错误处理程序设置为 'log'，使用 seterr。然后，浮点错误触发对提供对象的“写”方法的调用。

参数：

func可调用 f(err, flag) 或具有写入方法的对象

浮点错误时调用的函数（“调用”模式）或其“写”方法用于记录此类消息的对象（“日志”模式）。

调用函数接受两个参数。第一个是描述错误类型的字符串（如“零除”，“溢出”，“下溢”或“无效值”），第二个是状态标志。该标志是一个字节，其最低有效位指示错误类型，其中之一是“除法”，“上溢”，“下溢”，“无效”：

[0 0 0 0 divide over under invalid] 

换句话说，flags = divide + 2*over + 4*under + 8*invalid。

如果提供了一个对象，它的写入方法应该接受一个参数，即字符串。

返回：

h可调用，日志实例或无

旧的错误处理程序。

另请参阅

seterr, geterr, geterrcall

示例

错误时的回调：

>>> def err_handler(type, flag):
...     print("Floating point error (%s), with flag %s" % (type, flag))
... 

>>> saved_handler = np.seterrcall(err_handler)
>>> save_err = np.seterr(all='call') 

>>> np.array([1, 2, 3]) / 0.0
Floating point error (divide by zero), with flag 1
array([inf, inf, inf]) 

>>> np.seterrcall(saved_handler)
<function err_handler at 0x...>
>>> np.seterr(**save_err)
{'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'} 

记录错误消息：

>>> class Log:
...     def write(self, msg):
...         print("LOG: %s" % msg)
... 

>>> log = Log()
>>> saved_handler = np.seterrcall(log)
>>> save_err = np.seterr(all='log') 

>>> np.array([1, 2, 3]) / 0.0
LOG: Warning: divide by zero encountered in divide
array([inf, inf, inf]) 

>>> np.seterrcall(saved_handler)
<numpy.core.numeric.Log object at 0x...>
>>> np.seterr(**save_err)
{'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'} 

numpy.geterrcall

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

numpy.geterrcall()

返回当前用于浮点错误的回调函数。

当浮点错误（“divide”、“over”、“under”或“invalid”之一）的错误处理设置为“call”或“log”时，返回使用geterrcall设置的函数或日志实例。此函数或日志实例已通过seterrcall设置。

返回值：

errobj可调用对象、日志实例或 None

当前错误处理程序。如果未通过seterrcall设置处理程序，则返回 None。

另请参见

seterrcall、seterr和geterr

注意事项

关于浮点异常类型和处理选项的完整文档，请参阅seterr。

示例

>>> np.geterrcall()  # we did not yet set a handler, returns None 

>>> oldsettings = np.seterr(all='call')
>>> def err_handler(type, flag):
...     print("Floating point error (%s), with flag %s" % (type, flag))
>>> oldhandler = np.seterrcall(err_handler)
>>> np.array([1, 2, 3]) / 0.0
Floating point error (divide by zero), with flag 1
array([inf, inf, inf]) 

>>> cur_handler = np.geterrcall()
>>> cur_handler is err_handler
True 

numpy.errstate

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

class numpy.errstate(**kwargs)

浮点错误处理的上下文管理器。

使用errstate的实例作为上下文管理器，允许该上下文中的语句以已知的错误处理行为执行。进入上下文时，使用seterr和seterrcall设置错误处理，并在退出时将其重置为之前的状态。

自 1.17.0 版更改：errstate也可以作为函数装饰器使用，如果需要包装整个函数，则可节省一个缩进级别。有关更多信息，请参见contextlib.ContextDecorator。

参数：

kwargs

关键字参数。有效关键字是可能的浮点异常。每个关键字应具有定义特定错误处理的字符串值。可能的值为{'ignore'，'warn'，'raise'，'call'，'print'，'log'}。

另请参见

seterr，geterr，seterrcall，geterrcall

注释

要完整了解浮点异常类型和处理选项，请参阅seterr的完整文档。

示例

>>> olderr = np.seterr(all='ignore')  # Set error handling to known state. 

>>> np.arange(3) / 0.
array([nan, inf, inf])
>>> with np.errstate(divide='warn'):
...     np.arange(3) / 0.
array([nan, inf, inf]) 

>>> np.sqrt(-1)
nan
>>> with np.errstate(invalid='raise'):
...     np.sqrt(-1)
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
FloatingPointError: invalid value encountered in sqrt 

在上下文之外，错误处理行为并未改变：

>>> np.geterr()
{'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} 

方法

__call__(func)	将自身作为函数调用。

numpy.seterrobj

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

numpy.seterrobj(errobj, /)

设置定义浮点错误处理的对象。

错误对象包含定义 NumPy 错误处理行为的所有信息。seterrobj在设置错误处理行为的其他函数（seterr，seterrcall）中被内部使用。

参数：

errobj 列表

错误对象，一个包含三个元素的列表：[内部 NumPy 缓冲区大小、错误掩码、错误回调函数]。

错误掩码是一个单个整数，它保存了所有四种浮点错误的处理信息。对于每种错误类型的信息都包含在整数的三位中。如果我们以 8 进制打印它，我们可以看到对于“无效”、“下溢”、“上溢”和“除以零”（按顺序）设置了什么处理方式。打印出来的字符串可以用以下方式解释：

• 0: ‘忽略’

• 1: ‘警告’

• 2: ‘抛出’

• 3: ‘调用’

• 4: ‘打印’

• 5: ‘记录’

另请参阅

geterrobj，seterr，geterr，seterrcall，geterrcall

getbufsize，setbufsize

注释

有关浮点异常类型和处理选项的完整文档，请参阅seterr。

示例

>>> old_errobj = np.geterrobj()  # first get the defaults
>>> old_errobj
[8192, 521, None] 

>>> def err_handler(type, flag):
...     print("Floating point error (%s), with flag %s" % (type, flag))
...
>>> new_errobj = [20000, 12, err_handler]
>>> np.seterrobj(new_errobj)
>>> np.base_repr(12, 8)  # int for divide=4 ('print') and over=1 ('warn')
'14'
>>> np.geterr()
{'over': 'warn', 'divide': 'print', 'invalid': 'ignore', 'under': 'ignore'}
>>> np.geterrcall() is err_handler
True 

离散傅里叶变换（numpy.fft）

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

SciPy 模块scipy.fft是numpy.fft的更全面的超集，包括了一个基本的例程。

标准 FFT

fft(a[, n, axis, norm])	计算一维离散傅里叶变换。
ifft(a[, n, axis, norm])	计算一维逆离散傅里叶变换。
fft2(a[, s, axes, norm])	计算二维离散傅里叶变换。
ifft2(a[, s, axes, norm])	计算二维逆离散傅里叶变换。
fftn(a[, s, axes, norm])	计算 N 维离散傅里叶变换。
ifftn(a[, s, axes, norm])	计算 N 维逆离散傅里叶变换。

实 FFT

rfft(a[, n, axis, norm])	为实输入计算一维离散傅里叶变换。
irfft(a[, n, axis, norm])	计算rfft的逆。
rfft2(a[, s, axes, norm])	计算实数组的二维 FFT。
irfft2(a[, s, axes, norm])	计算rfft2的逆。
rfftn(a[, s, axes, norm])	为实输入计算 N 维离散傅里叶变换。
irfftn(a[, s, axes, norm])	计算rfftn的逆。

厄米 FFT

hfft(a[, n, axis, norm])	计算具有厄米对称性的信号的 FFT，即实谱。
ihfft(a[, n, axis, norm])	计算具有厄米对称性的信号的逆 FFT。

辅助例程

fftfreq(n[, d])	返回离散傅里叶变换的采样频率。
rfftfreq(n[, d])	返回离散傅里叶变换的采样频率（在与 rfft、irfft 一起使用时）。
fftshift(x[, axes])	将零频率分量移至频谱的中心。
ifftshift(x[, axes])	fftshift的反函数。

背景信息

傅里叶分析基本上是一种将函数表示为周期性分量之和，并从这些分量中恢复函数的方法。当函数及其傅里叶变换都被替换为离散化的对应物时，就称为离散傅里叶变换(DFT)。DFT 在数值计算中已经成为一种主要方法，部分原因是计算 DFT 的一个非常快速的算法，称为快速傅里叶变换(FFT)，这个算法早在高斯(1805 年)之前就被知晓，并由库利和图基以其当前形式公之于众[CT]。Press 等人[NR]提供了对傅里叶分析及其应用的易于理解的介绍。

由于离散傅里叶变换将输入分解为在离散频率上起作用的分量，所以它在数字信号处理中有很多应用，例如用于滤波，在这种情况下，变换的输入被称为一个信号，它存在于时域中。输出被称为频谱或变换，存在于频域中。

实现细节

有很多方法可以定义离散傅里叶变换(DFT)，可能会涉及到指数符号的正负、归一化等。在这个实现中，DFT 的定义如下：

[A_k = \sum_{m=0}^{n-1} a_m \exp\left{-2\pi i{mk \over n}\right} \qquad k = 0,\ldots,n-1.]

DFT 一般来说是针对复数输入和输出定义的，线性频率为(f)的单频分量由复指数表示为(a_m = \exp{2\pi i,f m\Delta t})，其中(\Delta t)为采样间隔。

结果中的值遵循所谓的“标准”顺序：如果 A = fft(a, n)，那么 A[0] 包含零频率项（信号的总和），对于实数输入总是纯实的。然后 A[1:n/2] 包含正频率项，而 A[n/2+1:] 包含负频率项，按照递减的负频率顺序。对于偶数个输入点，A[n/2] 代表正负奈奎斯特频率，并且对于实数输入总是纯实的。对于奇数个输入点，A[(n-1)/2] 包含最大正频率，而 A[(n+1)/2] 包含最大负频率。例程 np.fft.fftfreq(n) 返回一个数组，其中包含输出元素的频率。例程 np.fft.fftshift(A) 将变换及其频率移动以使零频率分量位于中间，而 np.fft.ifftshift(A) 撤销了该移位。

当输入 a 是时域信号，并且 A = fft(a)，np.abs(A) 是其幅度谱，np.abs(A)**2 是其功率谱。相位谱由 np.angle(A) 获得。

逆 DFT 被定义为

[a_m = \frac{1}{n}\sum_{k=0}^{n-1}A_k\exp\left{2\pi i{mk\over n}\right} \qquad m = 0,\ldots,n-1.]

它与正向变换的指数参数的符号不同，以及默认标准化为 (\frac{1}{n})。

类型提升

numpy.fft 将 float32 和 complex64 数组分别提升为 float64 和 complex128 数组。对于不提升输入数组的 FFT 实现，请参见scipy.fftpack。

标准化

参数norm表示直接/反向变换对的方向和标准化因子。默认的标准化（"backward"）使得直接（正向）变换不经缩放，而反向（逆向）变换经缩放 (\frac{1}{n})。可以通过将关键字参数norm设置为"ortho"获得单位变换，从而使得直接和逆向变换都经缩放 (\frac{1}{\sqrt{n}})。最后，通过将关键字参数norm设置为"forward"，使得直接变换经缩放 (\frac{1}{n})，而逆向变换不经缩放（即与默认的"backward"完全相反）。对于向后兼容性，*None*是默认选项"backward"的别名。

实部和厄米变换

当输入是纯实数时，其变换是埃尔米特的，即频率(f_k)处的分量是频率(-f_k)处分量的复共轭，这意味着对于实数输入，负频率分量中没有任何来自正频率分量中不可从中获取的信息。rfft 函数族旨在对实数输入进行操作，并且通过仅计算正频率分量（包括奈奎斯特频率）利用了此对称性。因此，n输入点会产生n/2+1个复数输出点。这个函数族的逆假设了其输入的对称性，并且对于n个点的输出使用n/2+1个输入点。

相应地，当频谱是纯实时，信号是埃尔米特的。hfft 函数族利用了这种对称性，使用n/2+1输入（时间）域中的复点对n频域中的实点。

在更高维度中，会使用 FFT，例如用于图像分析和滤波。FFT 的计算效率意味着它也可以是计算大型卷积的更快捷方式，利用了时域中卷积等效于频域中逐点相乘的性质。

更高维度

在二维中，DFT 的定义如下：

[A_{kl} = \sum_{m=0}^{M-1} \sum_{n=0}^{N-1} a_{mn}\exp\left{-2\pi i \left({mk\over M}+{nl\over N}\right)\right} \qquad k = 0, \ldots, M-1;\quad l = 0, \ldots, N-1,]

它以明显的方式扩展到更高维，而高维中的逆变换也以相同的方式扩展。

参考

[CT]

Cooley, James W., and John W. Tukey, 1965, “The Fast Fourier Transform,” Math. Comput. 19: 297-301.

[NR]

Press, W., Teukolsky, S., Vetterline, W.T., and Flannery, B.P., 2007, Numerical Recipes: The Art of Scientific Computing, 第 12-13 章。剑桥大学出版社，剑桥，英国。

例子

例如, 请参见各种函数。

标准 FFTs

fft(a[, n, axis, norm])	计算一维离散傅立叶变换。
ifft(a[, n, axis, norm])	计算一维离散傅立叶逆变换。
fft2(a[, s, axes, norm])	计算二维离散傅立叶变换。
ifft2(a[, s, axes, norm])	计算二维离散傅立叶逆变换。
fftn(a[, s, axes, norm])	计算 N 维离散傅立叶变换。
ifftn(a[, s, axes, norm])	计算 N 维离散傅立叶逆变换。

实数 FFT

rfft(a[, n, axis, norm])	为实输入计算一维离散傅立叶变换。
irfft(a[, n, axis, norm])	计算rfft的逆。
rfft2(a[, s, axes, norm])	计算实数组的二维 FFT。
irfft2(a[, s, axes, norm])	计算rfft2的逆。
rfftn(a[, s, axes, norm])	为实输入计算 N 维离散傅立叶变换。
irfftn(a[, s, axes, norm])	计算rfftn的逆。

共轭对称 FFT

hfft(a[, n, axis, norm])	计算具有共轭对称性的信号的 FFT，即实谱。
ihfft(a[, n, axis, norm])	计算具有共轭对称性的信号的逆 FFT。

辅助程序

fftfreq(n[, d])	返回离散傅立叶变换的采样频率。
rfftfreq(n[, d])	返回离散傅立叶变换的采样频率（用于 rfft、irfft）。
fftshift(x[, axes])	将零频率分量移至频谱的中心。
ifftshift(x[, axes])	fftshift的逆。

背景信息

傅里叶分析基本上是一种将函数表示为周期分量之和的方法，并从这些分量中恢复函数。当函数和它的傅里叶变换都用离散化的对应物代替时，它被称为离散傅里叶变换 (DFT)。DFT 已成为数值计算的主要工具之一，部分原因是有一个非常快的计算算法，叫做快速傅里叶变换 (FFT)，它在高斯时期 (1805 年) 就被知晓，并在目前的形式中由库利和图基 [CT] 揭示出来。Press 等人 [NR] 提供了对傅里叶分析及其应用的易懂介绍。

由于离散傅里叶变换将输入分解为在离散频率上有贡献的分量，因此它在数字信号处理中有很多应用，例如滤波，而在此背景下，变换的离散输入通常被称为信号，存在于时域中。输出称为频谱或变换，存在于频域中。

实现细节

有许多方式来定义 DFT，包括指数的符号、归一化等。在这个实现中，DFT 被定义为

[A_k = \sum_{m=0}^{n-1} a_m \exp\left{-2\pi i{mk \over n}\right} \qquad k = 0,\ldots,n-1.]

DFT 通常用于复数输入和输出，线性频率 (f) 的单频率分量通过复指数 (a_m = \exp{2\pi i,f m\Delta t}) 来表示，其中 (\Delta t) 是采样间隔。

结果中的值按所谓的“标准”顺序排列：如果 A = fft(a, n)，那么 A[0] 包含零频率项 (信号的总和)，对于实数输入，它始终是纯实数的。然后 A[1:n/2] 包含正频率项，A[n/2+1:] 按照逐渐减小的负频率顺序包含负频率项。对于偶数个输入点，A[n/2] 表示正负奈奎斯特频率，对于实数输入，它也是纯实数的。对于奇数个输入点，A[(n-1)/2] 包含最大的正频率，而 A[(n+1)/2] 包含最大的负频率。例程 np.fft.fftfreq(n) 返回一个数组，给出了输出中对应元素的频率。例程 np.fft.fftshift(A) 将变换和它们的频率移位，使得零频率分量位于中间，而 np.fft.ifftshift(A) 则撤消了这种移位。

当输入 a 是一个时域信号，且 A = fft(a)，np.abs(A) 是其幅度谱，np.abs(A)**2 是其功率谱。相位谱可以通过 np.angle(A) 得到。

逆 DFT 被定义为

[a_m = \frac{1}{n}\sum_{k=0}^{n-1}A_k\exp\left{2\pi i{mk\over n}\right} \qquad m = 0,\ldots,n-1.]

它与正向变换的差别在于指数参数的符号以及默认的归一化因子 (1/n)。

类型提升

numpy.fft 将 float32 和 complex64 数组提升为分别的 float64 和 complex128 数组。对于不提升输入数组的 FFT 实现，请参阅 scipy.fftpack.

归一化

参数norm指示了一对直接/逆变换的哪个方向被缩放以及使用什么归一化因子。默认的归一化（"backward"）使得直接（正向）变换未缩放，而逆（反向）变换则按 (1/n) 缩放。通过将关键字参数norm设置为"ortho"，可以获得幺正变换，这样直接和逆变换都按 (1/\sqrt{n}) 缩放。最后，将关键字参数norm设置为"forward"将使直接变换按 (1/n) 缩放，而逆变换不进行缩放（即与默认的"backward"完全相反）。None 是默认选项"backward"的一个别名，用于向后兼容性。

实数和 Hermitian 变换

当输入纯粹为实数时，其变换是 Hermitian 的，即，在频率(f_k)处的分量是频率(-f_k)处分量的复共轭，这意味着对于实数输入，在负频率分量中没有额外的信息，这些信息在正频率分量中已经可用。rfft 函数族旨在处理实数输入，并通过仅计算正频率分量来利用这种对称性，直至包括奈奎斯特频率。因此，n 个输入点产生 n/2+1 个复数输出点。这个函数族的反变换假设其输入具有相同的对称性，对于 n 个点的输出使用 n/2+1 个输入点。

相应地，当频谱纯粹为实时，信号为 Hermitian。hfft 函数族利用这种对称性，使用 n/2+1 个复数点作为输入（时间）域，用于 n 个实数点的频率域。

在更高维度中，FFT 被用于图像分析和滤波等任务。FFT 的计算效率意味着它也可以是计算大卷积的一种更快捷的方法，利用了时域中的卷积等于频域中按点相乘的属性。

更高维度

在二维中，DFT 被定义为

[A_{kl} = \sum_{m=0}^{M-1} \sum_{n=0}^{N-1} a_{mn}\exp\left{-2\pi i \left({mk\over M}+{nl\over N}\right)\right} \qquad k = 0, \ldots, M-1;\quad l = 0, \ldots, N-1,]

这种方式直观地扩展到更高维度，而在更高维度中的逆变换也是以相同的方式扩展的。

参考资料

[CT]

Cooley, James W., 和 John W. Tukey, 1965, “用于计算复傅里叶级数的算法,” Math. Comput. 19: 297-301.

[NR]

Press, W., Teukolsky, S., Vetterline, W.T., 和 Flannery, B.P., 2007, Numerical Recipes: The Art of Scientific Computing, ch. 12-13. 剑桥大学出版社, 剑桥, 英国.

例子

有关例子，请参见各种函数。

numpy.fft.fft

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

fft.fft(a, n=None, axis=-1, norm=None)

计算一维离散傅里叶变换。

此函数使用高效的快速傅里叶变换（FFT）算法计算一维n点离散傅里叶变换（DFT）[CT]。

参数：

a类似数组

输入数组，可以是复数。

n整数，可选

输出的变换轴的长度。如果n小于输入的长度，则输入会被裁剪。如果n大于输入的长度，则输入会用零填充。如果n没有给出，那么沿着axis指定的轴的长度会被使用。

axis整数，可选

用来计算 FFT 的轴。如果没有给出，则使用最后一个轴。

norm，可选

在 1.10.0 版本中添加。

标准化模式（参见 numpy.fft）。默认为“backward”。指示前向/后向变换对中的哪个方向进行缩放以及使用什么标准化因子。

1.20.0 版本中新增了“backward”，“forward”值。

返回：

out复数的 ndarray

截断或零填充的输入，沿着axis指示的轴进行变换，或者如果没有指定axis，则沿着最后一个轴进行变换。

引发：

索引错误

如果axis不是a的有效轴。

也参见

numpy.fft

DFT 的定义和使用的约定。

ifft

fft的逆变换。

fft2

双维 FFT。

fftn

n维 FFT。

rfftn

实数输入的n维 FFT。

fftfreq

给定 FFT 参数的频率块。

注意

FFT（快速傅里叶变换）是一种离散傅里叶变换（DFT）可以通过使用计算术语中的对称性来高效计算的方法。当n是 2 的幂时，对称性最高，因此对于这些尺寸，变换是最有效的。

DFT 的定义，以及这个实现中使用的约定，请参见numpy.fft模块的文档。

参考

[CT]

Cooley, James W., and John W. Tukey, 1965, “An algorithm for the machine calculation of complex Fourier series,” Math. Comput. 19: 297-301.

例子

>>> np.fft.fft(np.exp(2j * np.pi * np.arange(8) / 8))
array([-2.33486982e-16+1.14423775e-17j,  8.00000000e+00-1.25557246e-15j,
 2.33486982e-16+2.33486982e-16j,  0.00000000e+00+1.22464680e-16j,
 -1.14423775e-17+2.33486982e-16j,  0.00000000e+00+5.20784380e-16j,
 1.14423775e-17+1.14423775e-17j,  0.00000000e+00+1.22464680e-16j]) 

在这个例子中，实数输入是 Hermitian 的 FFT，即在实部对称，在虚部反对称，正如numpy.fft文档中所描述的：

>>> import matplotlib.pyplot as plt
>>> t = np.arange(256)
>>> sp = np.fft.fft(np.sin(t))
>>> freq = np.fft.fftfreq(t.shape[-1])
>>> plt.plot(freq, sp.real, freq, sp.imag)
[<matplotlib.lines.Line2D object at 0x...>, <matplotlib.lines.Line2D object at 0x...>]
>>> plt.show() 

numpy.fft.ifft

numpy.org/doc/1.26/reference/generated/numpy.fft.ifft.html

fft.ifft(a, n=None, axis=-1, norm=None)

计算一维逆离散傅里叶变换。

此功能计算fft计算的一维n点离散傅里叶变换的逆变换。换句话说，ifft(fft(a)) == a在数值精度范围内成立。有关算法和定义的一般描述，请参见numpy.fft。

输入应按照与fft返回的顺序相同，即，

• a[0]应包含零频率项，

• a[1:n//2]应包含正频率项，

• a[n//2 + 1:]应包含负频率项，按照从最负频率开始的增序排列。

对于偶数个输入点，A[n//2]代表正和负奈奎斯特频率处值的和，因为两者被混叠在一起。详细信息请参见numpy.fft。

参数：

a类似数组

输入数组，可以是复数。

nint，可选

输出的变换轴的长度。如果n小于输入的长度，则裁剪输入。如果n更大，则用零填充输入。如果未给出n，则使用由axis指定的轴上的输入长度。有关填充问题，请参见注释。

axisint，可选

计算逆离散傅里叶变换的轴。如果未给出，则使用最后一个轴。

norm，可选

版本 1.10.0 中的新内容。

规范模式（参见numpy.fft）。默认为“backward”。指示在前向/后向转换对中哪个方向被缩放以及使用什么归一化因子。

版本 1.20.0 中的新内容：添加了“backward”、“forward”值。

返回：

out复数 ndarray

在由axis指示的轴上截取或填充为零的输入，或最后一个轴（如果未指定axis）。

引发：

索引错误

如果axis不是a的有效轴。

另请参见

numpy.fft

介绍，含有定义和一般解释。

fft

一维（正向）FFT，其中ifft是其逆向操作

ifft2

二维逆 FFT。

ifftn

n 维逆 FFT。

注意

如果输入参数n大于输入的大小，则在结尾附加零来填充输入。即使这是一种常见的方法，但可能会导致令人惊讶的结果。如果需要不同的填充方式，在调用ifft之前必须执行。

示例

>>> np.fft.ifft([0, 4, 0, 0])
array([ 1.+0.j,  0.+1.j, -1.+0.j,  0.-1.j]) # may vary 

创建并绘制具有随机相位的带限信号:

>>> import matplotlib.pyplot as plt
>>> t = np.arange(400)
>>> n = np.zeros((400,), dtype=complex)
>>> n[40:60] = np.exp(1j*np.random.uniform(0, 2*np.pi, (20,)))
>>> s = np.fft.ifft(n)
>>> plt.plot(t, s.real, label='real')
[<matplotlib.lines.Line2D object at ...>]
>>> plt.plot(t, s.imag, '--', label='imaginary')
[<matplotlib.lines.Line2D object at ...>]
>>> plt.legend()
<matplotlib.legend.Legend object at ...>
>>> plt.show() 

numpy.fft.fft2

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

fft.fft2(a, s=None, axes=(-2, -1), norm=None)

计算二维离散傅里叶变换。

该函数通过快速傅里叶变换（FFT）在M维数组的任何轴上计算n维离散傅里叶变换。默认情况下，计算在输入数组的最后两个轴上进行，即二维 FFT。

参数：

a类似数组

输入数组，可以是复数

s整数序列，可选

输出的形状（每个转换轴的长度）（s[0]对应轴 0，s[1]对应轴 1，依此类推）。这对应于fft(x, n)中的n。沿每个轴，如果给定的形状小于输入的形状，则裁剪输入。如果它更大，则用零填充输入。如果未给出s，则沿axes指定的轴使用输入的形状。

axes整数序列，可选

在其上计算 FFT 的轴。如果未给出，则使用最后两个轴。axes 中的重复索引表示在该轴上执行变换多次。一个单元素序列表示执行一维 FFT。

norm，可选

新版本 1.10.0 中增加。

归一化模式（参见numpy.fft != 2`。

IndexError

如果axes的一个元素大于a的轴数。

另见

numpy.fft

离散傅里叶变换的整体视图，包括使用的定义和约定。

ifft2

两维逆离散傅里叶变换。

fft

一维离散傅里叶变换。

fftn

n维离散傅里叶变换。

fftshift

将零频率项移到数组中心。对于二维输入，交换第一和第三象限，第二和第四象限。

注意事项

fft2 仅是具有不同axes默认值的fftn。

输出，类似于fft，在转换轴的低阶角落包含了零频率的项，这些轴的前半部分包含了正频率的项，轴的中间包含了奈奎斯特频率的项，而轴的后半部分包含了负频率的项，按照不断减小的负频率顺序排列。

参见fftn以获取详细信息和绘图示例，以及numpy.fft以获取使用的定义和约定。

示例

>>> a = np.mgrid[:5, :5][0]
>>> np.fft.fft2(a)
array([[ 50\.  +0.j        ,   0\.  +0.j        ,   0\.  +0.j        , # may vary
 0\.  +0.j        ,   0\.  +0.j        ],
 [-12.5+17.20477401j,   0\.  +0.j        ,   0\.  +0.j        ,
 0\.  +0.j        ,   0\.  +0.j        ],
 [-12.5 +4.0614962j ,   0\.  +0.j        ,   0\.  +0.j        ,
 0\.  +0.j        ,   0\.  +0.j        ],
 [-12.5 -4.0614962j ,   0\.  +0.j        ,   0\.  +0.j        ,
 0\.  +0.j        ,   0\.  +0.j        ],
 [-12.5-17.20477401j,   0\.  +0.j        ,   0\.  +0.j        ,
 0\.  +0.j        ,   0\.  +0.j        ]]) 

numpy.fft.ifft2

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

fft.ifft2(a, s=None, axes=(-2, -1), norm=None)

计算二维逆离散傅里叶变换。

该函数通过快速傅里叶变换（FFT）计算 M 维数组中任意数量轴上的二维离散傅里叶变换的逆变换。换句话说，ifft2(fft2(a)) == a，精确到数值精度。默认情况下，对输入数组的最后两个轴计算逆变换。

输入应按照与fft2返回的顺序一样进行，也就是说，它的两个轴的低阶角应该有零频率的项，这两个轴的前半部分应有正频率项，这两个轴的中间应有奈奎斯特频率项，并且这两个轴的后半部分应有负频率项，并依次按照递减负频率的顺序排列。

参数：

aarray_like

输入数组，可以是复杂数组。

sint 的序列，可选

输出的形状（每个轴的长度）（s[0]表示轴 0，s[1]表示轴 1，依此类推）。这对应于ifft(x, n)中的n。沿着每个轴，如果给定的形状比输入的形状小，则裁剪输入。如果它大，则用零填充输入。如果未给出s，则使用axes指定的轴的输入形状。有关ifft零填充的问题，请参见注释。

axesint 的序列，可选

用于计算 FFT 的轴。如果未给出，则使用最后两个轴。axes中的重复索引表示对该轴进行多次变换。一个元素的序列表示执行一维 FFT。

norm，可选

从 1.10.0 版本开始。

归一化模式（参见numpy.fft）。默认为“backward”。表示前向/后向变换对中哪个方向标度化以及使用什么归一化因子。

从 1.20.0 版本开始：添加了“backward”，“forward”值。

返回：

out复数 ndarray

截断或零填充的输入，沿着axes指示的轴变换，或者如果未给出axes，则最后两个轴。

异常：

值错误

如果s和axes的长度不同，或者未给出axes和len(s) != 2。

索引错误

如果axes的元素大于a的轴数。

另请参见

numpy.fft

离散傅里叶变换的总体视图，定义和使用的约定。

fft2

前向二维 FFT，其逆变换为ifft2。

ifftn

n维 FFT 的逆变换。

fft

一维 FFT。

ifft

一维逆 FFT。

注意事项

ifft2只是具有不同axes默认值的ifftn。

详见ifftn以获取详细信息和绘图示例，以及numpy.fft以获取定义和惯例。

类似于ifft，零填充是通过在指定维度上向输入附加零来执行的。虽然这是常用的方法，但可能会导致意想不到的结果。如果需要另一种形式的零填充，必须在调用ifft2之前执行。

示例

>>> a = 4 * np.eye(4)
>>> np.fft.ifft2(a)
array([[1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j], # may vary
 [0.+0.j,  0.+0.j,  0.+0.j,  1.+0.j],
 [0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],
 [0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j]]) 

numpy.fft.fftn

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

fft.fftn(a, s=None, axes=None, norm=None)

计算 N 维离散傅里叶变换。

该函数通过快速傅里叶变换（FFT）在M维数组的任意数量的轴上计算N维离散傅里叶变换。

参数：

aarray_like

输入数组，可以是复数。

s整数序列，可选

输出的形状（每个转换轴的长度）（s[0]指轴 0，s[1]指轴 1，依此类推）。这对应于fft(x, n)中的n。对于任何轴，如果给定的形状小于输入的形状，则输入会被裁剪。如果它更大，则输入会用零填充。如果没有给出s，则将使用由axes指定的轴上的输入的形状。

axes整数序列，可选

要计算 FFT 的轴。如果没有给出，将使用最后len(s)个轴，或者如果也没有指定s，则使用所有轴。在axes中重复的索引意味着该轴上的变换被执行多次。

norm，可选

新增功能版本 1.10.0。

标准化模式（参见numpy.fft）。默认为“backward”。指示前向/后向变换对中的哪个方向是缩放的，以及使用什么归一化因子。

新增功能版本 1.20.0：添加了“backward”，“forward”值。

返回：

out复数 ndarray

截取或零填充的输入，沿着axes指示的轴进行变换，或通过* s 和 a *的组合，如上面的参数部分所述。

异常：

ValueError

如果s和axes的长度不同。

IndexError

如果axes的元素大于a的轴数。

另请参见

numpy.fft

离散傅里叶变换的整体视图，包括使用的定义和约定。

ifftn

fftn的反转，n维 FFT 的逆。

fft

一维 FFT，包括使用的定义和约定。

rfftn

实数输入的n维 FFT。

fft2

二维 FFT。

fftshift

将零频率项移至数组中心

笔记

输出与fft类似，它包含所有轴的低阶角落的零频率项，所有轴的前半部分的正频率项，所有轴中的奈奎斯特频率项中间，所有轴的后半部分的负频率项，按递减的负频率顺序排列。

查看numpy.fft了解详细信息、定义和惯例的使用。

例子

>>> a = np.mgrid[:3, :3, :3][0]
>>> np.fft.fftn(a, axes=(1, 2))
array([[[ 0.+0.j,   0.+0.j,   0.+0.j], # may vary
 [ 0.+0.j,   0.+0.j,   0.+0.j],
 [ 0.+0.j,   0.+0.j,   0.+0.j]],
 [[ 9.+0.j,   0.+0.j,   0.+0.j],
 [ 0.+0.j,   0.+0.j,   0.+0.j],
 [ 0.+0.j,   0.+0.j,   0.+0.j]],
 [[18.+0.j,   0.+0.j,   0.+0.j],
 [ 0.+0.j,   0.+0.j,   0.+0.j],
 [ 0.+0.j,   0.+0.j,   0.+0.j]]])
>>> np.fft.fftn(a, (2, 2), axes=(0, 1))
array([[[ 2.+0.j,  2.+0.j,  2.+0.j], # may vary
 [ 0.+0.j,  0.+0.j,  0.+0.j]],
 [[-2.+0.j, -2.+0.j, -2.+0.j],
 [ 0.+0.j,  0.+0.j,  0.+0.j]]]) 

>>> import matplotlib.pyplot as plt
>>> [X, Y] = np.meshgrid(2 * np.pi * np.arange(200) / 12,
...                      2 * np.pi * np.arange(200) / 34)
>>> S = np.sin(X) + np.cos(Y) + np.random.uniform(0, 1, X.shape)
>>> FS = np.fft.fftn(S)
>>> plt.imshow(np.log(np.abs(np.fft.fftshift(FS))**2))
<matplotlib.image.AxesImage object at 0x...>
>>> plt.show() 

numpy.fft.ifftn

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

fft.ifftn(a, s=None, axes=None, norm=None)

计算 N 维逆离散傅立叶变换。

此函数通过快速傅立叶变换（FFT）计算 M 维数组中的任意数量的轴上 N 维离散傅立叶变换的逆变换。换句话说，ifftn(fftn(a)) == a在数值精度范围内。有关使用的定义和约定的描述，请参阅numpy.fft。

输入，类似于ifft，应按照fftn的返回方式排序，即在低阶角中的所有轴中都应有零频率项，所有轴的前一半中应有正频率项，所有轴的中间应有奈奎斯特频率项，并按照逐渐减小的负频率的顺序，所有轴的后一半中应有负频率项。

参数：

aarray_like

输入数组，可以是复数。

sint 的序列，可选

输出的形状（每个变换轴的长度）（s[0]指示轴 0，s[1]指示轴 1，以此类推）。这对应于ifft(x, n)的n。沿任何轴，如果给定的形状小于输入的形状，则截断输入。如果它大于，则用零填充输入。如果没有给出s，则沿着axes指定的轴使用输入的形状。参见有关ifft零填充问题的注释。

axesint 的序列，可选

计算 IFFT 的轴。如果未给出，则使用最后len(s)个轴，如果未指定s，则使用所有轴。在axes中重复的索引意味着在该轴上执行多次逆变换。

norm，可选

版本 1.10.0 中的新功能。

标准化模式（参见numpy.fft）。默认为“backward”。指示前/后变换对中的哪个方向被缩放以及使用什么归一化因子。

1.20.0 版本中的新功能：添加了“backward”、“forward”值。

返回：

out复数 ndarray

由axes指示的轴或由s或a的组合变换，或者被截断或零填充的输入，如上面的参数部分所述。

引发：

ValueError

如果s和axes长度不同。

IndexError

如果axes的元素大于a的轴数。

另见

numpy.fft

使用的定义和约定的离散傅立叶变换的总体视图。

fftn

此处的forward n-dimensional FFT 是ifftn的反向。

ifft

一维逆 FFT。

ifft2

二维逆 FFT。

ifftshift

解除fftshift，将零频率项移到数组的开头。

注意事项

有关使用的定义和惯例，请参见numpy.fft。

零填充，类似于ifft，通过在指定维度上附加零来执行。尽管这是常见的方法，但可能会导致令人惊讶的结果。如果需要另一种形式的零填充，则必须在调用ifftn之前执行。

示例

>>> a = np.eye(4)
>>> np.fft.ifftn(np.fft.fftn(a, axes=(0,)), axes=(1,))
array([[1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j], # may vary
 [0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j],
 [0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],
 [0.+0.j,  0.+0.j,  0.+0.j,  1.+0.j]]) 

创建并绘制具有带限频率内容的图像：

>>> import matplotlib.pyplot as plt
>>> n = np.zeros((200,200), dtype=complex)
>>> n[60:80, 20:40] = np.exp(1j*np.random.uniform(0, 2*np.pi, (20, 20)))
>>> im = np.fft.ifftn(n).real
>>> plt.imshow(im)
<matplotlib.image.AxesImage object at 0x...>
>>> plt.show() 

numpy.fft.rfft

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

fft.rfft(a, n=None, axis=-1, norm=None)

为实数输入计算一维离散傅里叶变换。

该函数通过一种称为快速傅里叶变换（FFT）的高效算法计算实值数组的一维n点离散傅里叶变换（DFT）。

参数：

a array_like

输入数组

n 整数，可选

输入上要使用的转换轴上的点数。如果n小于输入的长度，则输入被裁剪。如果大于输入，则使用零进行填充。如果未给出n，则使用axis指定的轴的输入长度。

axis 整数，可选

计算 FFT 的轴。如果未给出，则使用最后一个轴。

norm，可选

新版本 1.10.0 中。

标准化模式（参见numpy.fft）。默认为“backward”。指示哪个方向的前/后向转换对被缩放以及使用什么标准化因子。

新版本 1.20.0 中添加了“backward”、“forward”值。

返回：

out 复数 ndarray

截断或零填充的输入，沿着由axis指示的轴进行转换，如果未指定，则为最后一个轴。如果n是偶数，则转换轴的长度为(n/2)+1。如果n是奇数，则长度为(n+1)/2。

抛出：

IndexError

如果axis不是a的有效轴。

另请参阅

numpy.fft

DFT 的定义和惯例。

irfft

rfft的逆。

fft

复数输入的一维 FFT。

fftn

n 维 FFT。

rfftn

实输入的n维 FFT。

注意事项

当为纯实数输入计算 DFT 时，输出是厄米对称的，即负频率项只是相应正频率项的复共轭，并且负频率项是多余的。这个函数不会计算负频率项，因此输出的转换轴的长度是n//2 + 1。

当A = rfft(a)且 fs 为采样频率时，A[0]包含零频率项 0*fs，由于厄米对称性是实数。

如果n是偶数，A[-1]包含代表正负 Nyquist 频率（+fs/2 和-fs/2）的项，并且必须是纯实数。如果n是奇数，则在 fs/2 处没有项；A[-1]包含最大的正频率（fs/2*(n-1)/n），在一般情况下是复数。

如果输入a包含虚部，则会被静默丢弃。

示例

>>> np.fft.fft([0, 1, 0, 0])
array([ 1.+0.j,  0.-1.j, -1.+0.j,  0.+1.j]) # may vary
>>> np.fft.rfft([0, 1, 0, 0])
array([ 1.+0.j,  0.-1.j, -1.+0.j]) # may vary 

注意观察fft输出的最后一个元素是实数输入的第二个元素的复共轭。对于rfft，利用这种对称性仅计算非负频率项。

numpy.fft.irfft

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

fft.irfft(a, n=None, axis=-1, norm=None)

计算rfft的逆。

此函数计算实输入的一维n点离散傅立叶变换的逆，该变换由rfft计算。换句话说，irfft(rfft(a), len(a)) == a在数值精度内成立。(请参阅下面的注意事项，了解为什么在此处需要len(a)。)

预期输入的形式为由rfft返回的，即实零频项，后跟按频率递增顺序的复正频率项。由于实输入的离散傅立叶变换是 Hermitian 对称的，因此负频率项被视为相应正频率项的复共轭。

参数:

aarray_like

输入数组。

nint, 可选的

输出的变换轴的长度。对于n个输出点，需要n//2+1个输入点。如果输入比这更长，将被裁剪。如果短于此，则填充为零。如果未给出n，则将其视为2*(m-1)，其中m是由axis指定的轴上的输入长度。

axisint, 可选的

计算逆 FFT 的轴。如果不给定，则使用最后一个轴。

norm, 可选的

1.10.0 版本中新增。

标准化模式(参见numpy.fft)。默认为“backward”。指示哪个方向的前向/后向变换配对被缩放，并具有什么标准化因子。

1.20.0 版本中新增: 添加了“backward”、“forward”值。

返回:

outndarray

截断或零填充的输入，沿由axis指示的轴变换，或者如果未指定axis，则使用最后一个轴。变换后轴的长度为n，或者如果未给出n，则为2*(m-1)，其中m为输入的变换后轴的长度。要获得奇数个输出点，必须指定n。

引发:

IndexError

如果axis不是a的有效轴。

另请参见

numpy.fft

用于 DFT 的定义和约定。

rfft

实输入的一维 FFT，其中irfft是逆。

fft

一维 FFT。

irfft2

实输入的二维 FFT 的逆。

irfftn

实输入的n维 FFT 的逆。

注意

返回a的实值n点逆离散傅立叶变换，其中a包含共轭对称序列的非负频率项。n是结果的长度，而不是输入的长度。

如果指定一个n，使得a必须进行零填充或截断，额外/删除的值将被添加/删除在高频率。因此，可以通过傅里叶插值对一个系列进行* m*点重新采样：a_resamp = irfft(rfft(a), m)。

正确解释共轭输入取决于原始数据的长度，即n给出的长度。这是因为每个输入形状可能对应奇数或偶数长度的信号。默认情况下，irfft假设输出长度为偶数，将最后一个条目放在奈奎斯特频率上；与其对称的频率重复。根据共轭对称性，因此该值被视为纯实数。为了避免丢失信息，必须给出实际输入的正确长度。

示例

>>> np.fft.ifft([1, -1j, -1, 1j])
array([0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j]) # may vary
>>> np.fft.irfft([1, -1j, -1])
array([0.,  1.,  0.,  0.]) 

注意普通ifft输入中的最后一项是第二项的复共轭，并且输出在任何地方都没有虚部。调用irfft时，未指定负频率，输出数组纯粹是实数。

numpy.fft.rfft2

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

fft.rfft2(a, s=None, axes=(-2, -1), norm=None)

计算实数组的二维 FFT。

参数：

a数组

接收的数组，被视为实数。

sint 序列，可选

FFT 的形状。

axesint 序列，可选

计算 FFT 的轴。

norm，可选

在 1.10.0 版新增。

标准化模式（参见numpy.fft）。默认为“backward”。指示前向/后向转换对的哪个方向被放大，并且使用什么归一化因子。

在 1.20.0 版新增：增加了“backward”、“forward”值。

返回：

outndarray

实 2-D FFT 的结果。

亦参见

rfftn

计算输入为真实数据的 N 维离散傅立叶变换。

注意

这实际上只是与默认行为不同的rfftn。更多细节请查看rfftn。

示例

>>> a = np.mgrid[:5, :5][0]
>>> np.fft.rfft2(a)
array([[ 50\.  +0.j        ,   0\.  +0.j        ,   0\.  +0.j        ],
 [-12.5+17.20477401j,   0\.  +0.j        ,   0\.  +0.j        ],
 [-12.5 +4.0614962j ,   0\.  +0.j        ,   0\.  +0.j        ],
 [-12.5 -4.0614962j ,   0\.  +0.j        ,   0\.  +0.j        ],
 [-12.5-17.20477401j,   0\.  +0.j        ,   0\.  +0.j        ]]) 

numpy.fft.irfft2

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

fft.irfft2(a, s=None, axes=(-2, -1), norm=None)

计算rfft2的逆。

参数：

a类似数组

输入数组

s一组整数，可选

输出实际结果的逆 FFT 的形状。

axes一组整数，可选

要计算逆 fft 的轴。默认为最后两个轴。

norm，可选

版本 1.10.0 中的新内容。

标准化模式（参见numpy.fft）。默认为“backward”。表示前向/后向转换对的哪个方向是缩放的，以及使用哪个标准化因子。

版本 1.20.0 中的新内容：添加了“backward”，“forward”值。

返回：

out数组

逆实际二维 FFT 的结果。

另见

rfft2

实际输入的前向二维 FFT，其中irfft2是其逆。

rfft

实际输入的一维 FFT。

irfft

实际输入的一维 FFT 的逆。

irfftn

计算实际输入的 N 维 FFT 的逆。

注意

这实际上是具有不同默认值的irfftn。有关更多详细信息，请参见irfftn。

例子

>>> a = np.mgrid[:5, :5][0]
>>> A = np.fft.rfft2(a)
>>> np.fft.irfft2(A, s=a.shape)
array([[0., 0., 0., 0., 0.],
 [1., 1., 1., 1., 1.],
 [2., 2., 2., 2., 2.],
 [3., 3., 3., 3., 3.],
 [4., 4., 4., 4., 4.]]) 

numpy.fft.rfftn

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

fft.rfftn(a, s=None, axes=None, norm=None)

计算实输入的 N 维离散傅立叶变换。

此函数通过快速傅立叶变换（FFT）在 M 维实数组中的任意数量的轴上计算 N 维离散傅立叶变换。默认情况下，所有轴都会被转换，实变换在最后一个轴上执行，而其余的转换是复数。

参数：

a类似数组

输入数组，视为实数。

s整数序列，可选

用于从输入中使用的形状（沿每个转换的轴的长度）（s[0]是轴 0，s[1]是轴 1，依此类推）。* s 的最后一个元素对应于rfft(x, n)的n，而对于其余轴，它对应于fft(x, n)的n。沿着任何轴，如果给定的形状小于输入的形状，则截取输入。如果它大于输入，则使用零填充。如果没有给出s，则使用由 axes *指定的轴的形状。

axes整数序列，可选

要计算 FFT 的轴。如果未给出，则使用最后len(s)个轴，或如果未指定s，则使用所有轴。

norm，可选

1.10.0 中的新功能。

标准化模式（参见numpy.fft）。默认为“backward”。指示前向/后向变换对中哪个方向被缩放以及使用何种标准化因子。

1.20.0 的新功能：添加了“backward”、“forward”值。

返回：

out复数数组

截断或零填充的输入，沿着axes指示的轴或由* s 和 a 的组合进行变换，如上面参数部分所述。最后一个转换的轴的长度将为s [-1]//2+1，而其余转换的轴将根据 s *的长度或保持与输入相同。

Raises：

值错误

如果* s 和 axes *长度不同。

索引错误

如果* axes 的元素大于 a *的轴数。

另请参阅

irfftn

rfftn的逆，即实输入的 n 维 FFT 的逆。

fft

一维 FFT，包括所使用的定义和约定。

rfft

实输入的一维 FFT。

fftn

n 维 FFT。

rfft2

实输入的二维 FFT。

注意

对于实数输入的变换是在最后的转换轴上执行的，就像rfft那样，然后剩余轴上的变换像fftn那样执行。输出的顺序与最终转换轴的rfft相同，剩余转换轴的fftn相同。

详情、定义和惯例，请参见fft。

例子

>>> a = np.ones((2, 2, 2))
>>> np.fft.rfftn(a)
array([[[8.+0.j,  0.+0.j], # may vary
 [0.+0.j,  0.+0.j]],
 [[0.+0.j,  0.+0.j],
 [0.+0.j,  0.+0.j]]]) 

>>> np.fft.rfftn(a, axes=(2, 0))
array([[[4.+0.j,  0.+0.j], # may vary
 [4.+0.j,  0.+0.j]],
 [[0.+0.j,  0.+0.j],
 [0.+0.j,  0.+0.j]]]) 

numpy.fft.irfftn

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

fft.irfftn(a, s=None, axes=None, norm=None)

计算 rfftn 的逆变换。

该函数通过快速傅里叶变换（FFT）计算出 M 维数组中任意数量轴上的实数输入的 N 维离散傅里叶变换的逆变换。换句话说，irfftn(rfftn(a), a.shape) 对于数字精度内的 a 是成立的。（与 irfft 相同，a.shape 是必需的，并且是由于相同的原因。）

输入应按与由 rfftn 返回的方式相同的方式进行排序，即对于最终的变换轴应按 irfft 返回的方式进行排序，对于其他所有轴应按 ifftn 的方式进行排序。

参数：

a，数组样式

输入数组。

s，int 的序列，可选

输出的形状（每个转换轴的长度），s[0] 参考轴 0，s[1] 参考轴 1，依此类推。s 同时也是沿着该轴使用的输入点的个数，除了最后一个轴，其使用输入的点数为 s[-1]//2+1。在任何轴上，如果 s 指示的形状比输入的形状小，则输入会被裁剪。如果比输入的形状大，则会用零填充输入。如果没有给出 s，则使用由 axes 指定的轴的输入形状。除了最后一个轴，该轴被认为是 2*(m-1)，其中 m 是该轴输入的长度。

axes，int 的序列，可选

用于计算逆 FFT 的轴。如果未给出，则使用最后 len(s) 个轴，如果也未指定 s，则使用所有轴。在 axes 中重复的索引意味着该轴上的逆变换会多次执行。

norm，{“backward”，“ortho”，“forward”}，可选

在版本 1.10.0 中引入。

规范化模式（参见 numpy.fft

实输入的正向 n 维 FFT，其中ifftn是其逆变换。

fft

一维 FFT，具有用到的定义和惯例。

irfft

实输入的一维 FFT 的逆变换。

irfft2

实输入的二维 FFT 的逆变换。

笔记

有关定义和惯例的内容，请参阅fft。

有关实输入的定义和惯例，请参阅rfft。

正确解释共轭输入取决于原始数据的形状，由s给出。这是因为每个输入形状可能对应于奇数长度信号或偶数长度信号。默认情况下，irfftn 假设偶数输出长度，将最后一个条目放在 Nyquist 频率上；与其对称对应相混。在执行最终的复变到真实变换时，最后一个值因此被视为纯粹的实数。为了避免丢失信息，必须提供正确的真实输入形状。

例子

>>> a = np.zeros((3, 2, 2))
>>> a[0, 0, 0] = 3 * 2 * 2
>>> np.fft.irfftn(a)
array([[[1.,  1.],
 [1.,  1.]],
 [[1.,  1.],
 [1.,  1.]],
 [[1.,  1.],
 [1.,  1.]]]) 

numpy.fft.hfft

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

fft.hfft(a, n=None, axis=-1, norm=None)

计算���有 Hermite 对称性的信号的 FFT，即实谱。

参数：

aarray_like

输入数组。

nint，可选

输出的转换轴的长度。对于 n 个输出点，需要 n//2 + 1 个输入点。如果输入长度超过这个值，则会被截断。如果长度小于这个值，则用零填充。如果没有给出 n，则将其视为 2*(m-1)，其中 m 是由 axis 指定的轴上的输入长度。

axisint，可选

要计算 FFT 的轴。如果未给出，则使用最后一个轴。

norm，可选

1.10.0 版本中的新内容。

标准化模式（参见numpy.fft）。默认为“backward”。指示正向/反向转换对的哪个方向被缩放以及使用什么标准化因子。

1.20.0 版本中的新内容：添加了“backward”、“forward”值。

返回：

outndarray

截断或零填充的输入，沿 axis 指示的轴变换，或者如果未指定 axis，则沿最后一个轴变换。转换轴的长度为 n，或者，如果未给出 n，则为 2*m-2，其中 m 是输入的转换轴的长度。要获得奇数个输出点，必须指定 n，例如在典型情况下指定为 2*m-1，

引发：

索引错误

如果axis不是a的有效轴。

另见

rfft

计算实输入的一维 FFT。

ihfft

hfft的逆。

注意

hfft/ihfft是一对类似于rfft/irfft的函数，但适用于相反的情况：这里信号在时域具有 Hermite 对称性，在频域是实数。所以这里是hfft，你必须提供结果长度（如果长度为奇数）。

• 偶数：ihfft(hfft(a, 2*len(a) - 2)) == a，舍入误差内，

• 奇数：ihfft(hfft(a, 2*len(a) - 1)) == a，舍入误差内。

对 Hermite 输入的正确解释取决于原始数据的长度，由 n 给出。这是因为每个输入形状可以对应于奇数长度或偶数长度信号。默认情况下，hfft假设一个偶数长度的输出，这使得最后一个条目位于 Nyquist 频率处；与其对称对应的混叠。通过 Hermite 对称性，该值因此被视为纯实数。为了避免丢失信息，必须给出全信号的形状。

例子

>>> signal = np.array([1, 2, 3, 4, 3, 2])
>>> np.fft.fft(signal)
array([15.+0.j,  -4.+0.j,   0.+0.j,  -1.-0.j,   0.+0.j,  -4.+0.j]) # may vary
>>> np.fft.hfft(signal[:4]) # Input first half of signal
array([15.,  -4.,   0.,  -1.,   0.,  -4.])
>>> np.fft.hfft(signal, 6)  # Input entire signal and truncate
array([15.,  -4.,   0.,  -1.,   0.,  -4.]) 

>>> signal = np.array([[1, 1.j], [-1.j, 2]])
>>> np.conj(signal.T) - signal   # check Hermitian symmetry
array([[ 0.-0.j,  -0.+0.j], # may vary
 [ 0.+0.j,  0.-0.j]])
>>> freq_spectrum = np.fft.hfft(signal)
>>> freq_spectrum
array([[ 1.,  1.],
 [ 2., -2.]]) 

numpy.fft.ihfft

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

fft.ihfft(a, n=None, axis=-1, norm=None)

计算具有 Hermitian 对称性的信号的逆 FFT。

参数：

a类似数组

输入数组。

nint，可选

反向 FFT 的长度，用于沿输入轴使用的点数。如果n小于输入的长度，则会裁剪输入。如果大于输入，则用零填充。如果未给出n，则使用由axis指定的轴上输入的长度。

axis整数，可选

要计算逆 FFT 的轴。如果未给出，则使用最后一个轴。

norm，可选

自 1.10.0 版新增。

标准化模式（参见numpy.fft）。默认为“backward”。指示前向/后向变换对中的哪个方向被缩放以及使用什么归一化因子。

自 1.20.0 版新增：“backward”，“forward”值。

返回：

out复数数组

截断或填充零的输入，沿着axis指示的轴进行变换，如果未指定axis，则为最后一个轴。变换轴的长度为n//2 + 1。

另请参阅

hfft，irfft

注意事项

hfft/ihfft是一对类似于rfft/irfft的函数，但适用于相反的情况：在这里，信号在时域中具有 Hermitian 对称性，并且在频域中是实数。因此，在这里，如果结果的长度为奇数，则需要使用hfft：

• 偶数情况：ihfft(hfft(a, 2*len(a) - 2)) == a，四舍五入误差内相等。

• 奇数情况：ihfft(hfft(a, 2*len(a) - 1)) == a，四舍五入误差内相等。

示例

>>> spectrum = np.array([ 15, -4, 0, -1, 0, -4])
>>> np.fft.ifft(spectrum)
array([1.+0.j,  2.+0.j,  3.+0.j,  4.+0.j,  3.+0.j,  2.+0.j]) # may vary
>>> np.fft.ihfft(spectrum)
array([ 1.-0.j,  2.-0.j,  3.-0.j,  4.-0.j]) # may vary 

numpy.fft.fftfreq

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

fft.fftfreq(n, d=1.0)

返回离散傅立叶变换的样本频率。

返回的浮点数组f包含以每个采样间距单位的频率箱中心（从零开始）的循环。例如，如果采样间距单位为秒，则频率单位为每秒的循环数。

给定窗口长度n和采样间距d：

f = [0, 1, ...,   n/2-1,     -n/2, ..., -1] / (d*n)   if n is even
f = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n)   if n is odd 

参数：

nint

窗口长度。

dscalar，可选

采样间距（采样率的倒数）。默认为 1。

返回值：

fndarray

长度为n的数组，包含样本频率。

示例

>>> signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5], dtype=float)
>>> fourier = np.fft.fft(signal)
>>> n = signal.size
>>> timestep = 0.1
>>> freq = np.fft.fftfreq(n, d=timestep)
>>> freq
array([ 0\.  ,  1.25,  2.5 , ..., -3.75, -2.5 , -1.25]) 

numpy.fft.rfftfreq

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

fft.rfftfreq(n, d=1.0)

返回离散傅立叶变换的样本频率（用于 rfft、irfft 的用法）。

返回的浮点数组f包含以每个样本间隔单位的频率箱中心（从零开始）。例如，如果样本间隔是以秒为单位，则频率单位是每秒的周期数。

给定窗口长度n和样本间隔d：

f = [0, 1, ...,     n/2-1,     n/2] / (d*n)   if n is even
f = [0, 1, ..., (n-1)/2-1, (n-1)/2] / (d*n)   if n is odd 

与fftfreq不同（但类似于scipy.fftpack.rfftfreq)，奈奎斯特频率分量被视为正值。

参数：

n整数

窗口长度。

d标量，可选

样本间隔（采样率的倒数）。默认为 1。

返回：

f数组

长度为n//2 + 1的数组，其中包含样本频率。

示例

>>> signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5, -3, 4], dtype=float)
>>> fourier = np.fft.rfft(signal)
>>> n = signal.size
>>> sample_rate = 100
>>> freq = np.fft.fftfreq(n, d=1./sample_rate)
>>> freq
array([  0.,  10.,  20., ..., -30., -20., -10.])
>>> freq = np.fft.rfftfreq(n, d=1./sample_rate)
>>> freq
array([  0.,  10.,  20.,  30.,  40.,  50.]) 

numpy.fft.fftshift

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

fft.fftshift(x, axes=None)

将零频率分量移动到频谱的中心。

该函数交换所列轴的一半空间（默认为全部）。注意，如果len(x)是偶数，则y[0]只是奈奎斯特分量。

参数：

x类数组

输入数组。

轴整数或形状元组，可选

要移动的轴。默认为 None，表示移动所有轴。

返回：

y数组

移动后的数组。

另请参阅

ifftshift

fftshift的逆操作。

例子

>>> freqs = np.fft.fftfreq(10, 0.1)
>>> freqs
array([ 0.,  1.,  2., ..., -3., -2., -1.])
>>> np.fft.fftshift(freqs)
array([-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.]) 

仅沿第二轴移动零频率分量：

>>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3)
>>> freqs
array([[ 0.,  1.,  2.],
 [ 3.,  4., -4.],
 [-3., -2., -1.]])
>>> np.fft.fftshift(freqs, axes=(1,))
array([[ 2.,  0.,  1.],
 [-4.,  3.,  4.],
 [-1., -3., -2.]]) 

numpy.fft.ifftshift

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

fft.ifftshift(x, axes=None)

fftshift 的逆操作。虽然对于偶长度的 x 相同，但对于奇长度的x，这两个函数相差一个样本。

参数：

x类似数组

输入数组。

axesint 或形状元组，可选

计算的轴。默认为 None，会将所有轴进行偏移。

返回：

y数组

偏移后的数组。

另请参阅

fftshift

将零频率分量移至频谱的中心。

示例

>>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3)
>>> freqs
array([[ 0.,  1.,  2.],
 [ 3.,  4., -4.],
 [-3., -2., -1.]])
>>> np.fft.ifftshift(np.fft.fftshift(freqs))
array([[ 0.,  1.,  2.],
 [ 3.,  4., -4.],
 [-3., -2., -1.]]) 

函数式编程

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

apply_along_axis(func1d, axis, arr, *args, ...)	在给定轴上对 1-D 切片应用函数。
apply_over_axes(func, a, axes)	在多个轴上重复应用函数。
vectorize([pyfunc, otypes, doc, excluded, ...])	返回一个像 pyfunc 的对象，但以数组作为输入。
frompyfunc(func, /, nin, nout, *[, identity])	接受任意 Python 函数并返回一个 NumPy ufunc。
piecewise(x, condlist, funclist, *args, **kw)	评估分段定义的函数。

numpy.apply_along_axis

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

numpy.apply_along_axis(func1d, axis, arr, *args, **kwargs)

将函数应用于沿指定轴的 1-D 切片。

执行func1d(a, args, **kwargs)，其中func1d操作的是 1-D 数组，而a是arr沿axis*的 1-D 切片。

这等同于（但比使用ndindex和s_更快），它将ii、jj和kk每个设置为索引的元组：

Ni, Nk = a.shape[:axis], a.shape[axis+1:]
for ii in ndindex(Ni):
    for kk in ndindex(Nk):
        f = func1d(arr[ii + s_[:,] + kk])
        Nj = f.shape
        for jj in ndindex(Nj):
            out[ii + jj + kk] = f[jj] 

相同地，消除内部循环，这可以表达为：

Ni, Nk = a.shape[:axis], a.shape[axis+1:]
for ii in ndindex(Ni):
    for kk in ndindex(Nk):
        out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk]) 

参数：

func1dfunction (M,) -> (Nj…)

这个函数应该接受 1-D 数组。它被应用于arr沿指定轴的 1-D 切片。

axisinteger

切片arr的轴。

arrndarray (Ni…, M, Nk…)

输入数组。

argsany

func1d的附加参数。

kwargsany

func1d的其他命名参数。

于 1.9.0 版本中新增。

返回：

outndarray (Ni…, Nj…, Nk…)

输出数组。out的形状与arr的形状相同，只是沿着axis维度。这个维度被移除，并且用func1d的返回值的形状取代。所以如果func1d返回一个标量，out比arr少一维。

另请参阅

apply_over_axes

在多个轴上重复应用函数。

示例

>>> def my_func(a):
...  """Average first and last element of a 1-D array"""
...     return (a[0] + a[-1]) * 0.5
>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> np.apply_along_axis(my_func, 0, b)
array([4., 5., 6.])
>>> np.apply_along_axis(my_func, 1, b)
array([2.,  5.,  8.]) 

对于返回 1-D 数组的函数，outarr中的维数与arr相同。

>>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])
>>> np.apply_along_axis(sorted, 1, b)
array([[1, 7, 8],
 [3, 4, 9],
 [2, 5, 6]]) 

对于返回更高维数组的函数，这些维度被插入到axis维度的位置。

>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> np.apply_along_axis(np.diag, -1, b)
array([[[1, 0, 0],
 [0, 2, 0],
 [0, 0, 3]],
 [[4, 0, 0],
 [0, 5, 0],
 [0, 0, 6]],
 [[7, 0, 0],
 [0, 8, 0],
 [0, 0, 9]]]) 

numpy.apply_over_axes

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

numpy.apply_over_axes(func, a, axes)

多轴上重复应用函数。

func 作为 res = func(a, axis) 调用，其中 axis 是 axes 的第一个元素。函数调用的结果 res 必须与 a 具有相同的维度或者比 a 少一个维度。如果 res 比 a 少一个维度，则在 axis 前插入一个维度。然后，针对 axes 中的每个轴，对 func 进行重复调用，以 res 作为第一个参数。

参数：

funcfunction

该函数必须使用两个参数 func(a, axis)。

aarray_like

输入数组。

axesarray_like

应用 func 的轴；元素必须是整数。

返回：

apply_over_axisndarray

输出数组。维度数与 a 相同，但形状可以不同。这取决于 func 是否改变了其输出相对于其输入的形状。

参见

apply_along_axis

在给定轴上将一个函数应用于数组的 1-D 切片。

注意

此函数等价于保持维度的可重新排序的 ufunc 的元组轴参数，其中 keepdims=True。自 1.7.0 版本起，ufunc 的元组轴参数已经可用。

示例

>>> a = np.arange(24).reshape(2,3,4)
>>> a
array([[[ 0,  1,  2,  3],
 [ 4,  5,  6,  7],
 [ 8,  9, 10, 11]],
 [[12, 13, 14, 15],
 [16, 17, 18, 19],
 [20, 21, 22, 23]]]) 

在轴 0 和 2 上求和。结果的维度数与原始数组相同：

>>> np.apply_over_axes(np.sum, a, [0,2])
array([[[ 60],
 [ 92],
 [124]]]) 

ufunc 的元组轴参数是等价的：

>>> np.sum(a, axis=(0,2), keepdims=True)
array([[[ 60],
 [ 92],
 [124]]]) 

numpy.vectorize

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

class numpy.vectorize(pyfunc=np._NoValue, otypes=None, doc=None, excluded=None, cache=False, signature=None)

返回一个行为类似于 pyfunc 的对象，但以数组作为输入。

定义一个矢量化函数，它将嵌套序列的对象或 numpy 数组作为输入，并返回单个 numpy 数组或 numpy 数组的元组。该矢量化函数评估 pyfunc 在输入数组的连续元组上，就像 python 的 map 函数一样，只是它使用了 numpy 的广播规则。

vectorized的输出数据类型由调用该函数与输入的第一个元素确定。可以通过指定otypes参数来避免这种情况。

参数：

pyfunccallable，可选

一个 python 函数或方法。可以省略以使用关键字参数生成装饰器。

otypesstr 或 dtype 列表，可选

输出数据类型。必须指定为 typecode 字符的字符串或数据类型描述符的列表。每个输出应该有一个数据类型描述符。

docstr，可选

该函数的文档字符串。如果为 None，则文档字符串将为 pyfunc.__doc__。

excludedset，可选

一组字符串或整数，表示函数不会被矢量化的位置参数或关键字参数。这些参数将直接传递给 pyfunc，不做修改。

新版本功能：1.7.0。

cachebool，可选

如果为 True，则缓存第一个函数调用，以确定是否提供 otypes。

新版本功能：1.7.0。

signaturestring，可选

广义通用函数签名，例如 (m,n),(n)->(m) 用于矢量化的矩阵-向量乘法。如果提供，则假定 pyfunc 将使用（并要求返回）数组，其形状由相应的核心维度大小给出。默认情况下，假定 pyfunc 输入和输出为标量。

新版本功能：1.12.0。

返回：

outcallable

如果提供了 pyfunc 则返回一个矢量化函数，否则返回一个装饰器。

另请参阅

frompyfunc

接受任意 Python 函数并返回一个通用函数（ufunc）。

注解

vectorize 函数主要为方便起见而提供，并非用于性能。该实现基本上是一个 for 循环。

如果未指定 otypes，则使用第一个参数调用函数来确定输出的数量。如果 cache 为 True，则此调用的结果将被缓存，以防止两次调用函数。但是，为了实现缓存，必须包装原始函数，这将减慢后续调用的速度，因此只有在函数开销较大时才这样做。

新的关键字参数接口和 excluded 参数支持将进一步降低性能。

参考

[1]

广义通用函数 API

示例

>>> def myfunc(a, b):
...     "Return a-b if a>b, otherwise return a+b"
...     if a > b:
...         return a - b
...     else:
...         return a + b 

>>> vfunc = np.vectorize(myfunc)
>>> vfunc([1, 2, 3, 4], 2)
array([3, 4, 1, 2]) 

文档字符串取自输入函数到vectorize ，除非另有规定：

>>> vfunc.__doc__
'Return a-b if a>b, otherwise return a+b'
>>> vfunc = np.vectorize(myfunc, doc='Vectorized `myfunc`')
>>> vfunc.__doc__
'Vectorized `myfunc`' 

输出类型由评估输入的第一个元素来确定，除非另有规定：

>>> out = vfunc([1, 2, 3, 4], 2)
>>> type(out[0])
<class 'numpy.int64'>
>>> vfunc = np.vectorize(myfunc, otypes=[float])
>>> out = vfunc([1, 2, 3, 4], 2)
>>> type(out[0])
<class 'numpy.float64'> 

排除参数可用于防止对某些参数进行向量化。这在类似多项式系数（例如polyval ）的固定长度的数组参数中非常有用：

>>> def mypolyval(p, x):
...     _p = list(p)
...     res = _p.pop(0)
...     while _p:
...         res = res*x + _p.pop(0)
...     return res
>>> vpolyval = np.vectorize(mypolyval, excluded=['p'])
>>> vpolyval(p=[1, 2, 3], x=[0, 1])
array([3, 6]) 

通过指定其位置，也可以排除位置参数：

>>> vpolyval.excluded.add(0)
>>> vpolyval([1, 2, 3], x=[0, 1])
array([3, 6]) 

signature参数允许对作用于固定长度非标量数组的函数进行向量化。 例如，可以用它进行皮尔逊相关系数及其 p 值的向量化计算：

>>> import scipy.stats
>>> pearsonr = np.vectorize(scipy.stats.pearsonr,
...                 signature='(n),(n)->(),()')
>>> pearsonr([[0, 1, 2, 3]], [[1, 2, 3, 4], [4, 3, 2, 1]])
(array([ 1., -1.]), array([ 0.,  0.])) 

或者用于向量化卷积：

>>> convolve = np.vectorize(np.convolve, signature='(n),(m)->(k)')
>>> convolve(np.eye(4), [1, 2, 1])
array([[1., 2., 1., 0., 0., 0.],
 [0., 1., 2., 1., 0., 0.],
 [0., 0., 1., 2., 1., 0.],
 [0., 0., 0., 1., 2., 1.]]) 

支持装饰器语法。 装饰器可以被调用为一个函数以提供关键字参数。 >>>@np.vectorize …def identity(x): … return x … >>>identity([0, 1, 2]) array([0, 1, 2]) >>>@np.vectorize(otypes=[float]) …def as_float(x): … return x … >>>as_float([0, 1, 2]) array([0., 1., 2.])

方法

__call__(*args, **kwargs)	将自身作为函数调用。

numpy.frompyfunc

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

numpy.frompyfunc(func, /, nin, nout, *[, identity])

采用任意 Python 函数，并返回一个 NumPy ufunc。

例如，可用于对内置 Python 函数添加广播功能（见示例部分）。

参数：

funcPython 函数对象

任意的 Python 函数。

nin整数

输入参数的数量。

nout整数

func返回的对象数量。

identity对象，可选

identity属性的值。如果指定，这相当于设置底层 C 的identity字段为PyUFunc_IdentityValue。如果省略，身份设置为PyUFunc_None。请注意，这并不相当于将身份设置为None，这意味着操作是可重定的。

返回：

outufunc

返回一个 NumPy 通用函数（ufunc）对象。

另请参阅

vectorize

使用 NumPy 的广播规则在输入数组上计算 pyfunc。

注释

返回的 ufunc 始终返回 PyObject 数组。

示例

使用 frompyfunc 来为 Python 函数oct添加广播功能：

>>> oct_array = np.frompyfunc(oct, 1, 1)
>>> oct_array(np.array((10, 30, 100)))
array(['0o12', '0o36', '0o144'], dtype=object)
>>> np.array((oct(10), oct(30), oct(100))) # for comparison
array(['0o12', '0o36', '0o144'], dtype='<U5') 

numpy.piecewise

numpy.org/doc/1.26/reference/generated/numpy.piecewise.html

numpy.piecewise(x, condlist, funclist, *args, **kw)

评估分段定义的函数。

针对一组条件和相应函数，在其条件为真的地方对输入数据进行每个函数的评估。

参数：

x ndarray 或标量

输入域。

condlist 布尔数组或布尔标量的列表

每个布尔数组对应着 funclist 中的一个函数。在 condlist[i] 为真的地方，使用 funclisti 作为输出值。

condlist 中的每个布尔数组选择 x 的一部分，因此应该与 x 的形状相同。

condlist 的长度必须与 funclist 的长度对应。如果提供了一个额外的函数，即如果 len(funclist) == len(condlist) + 1，则该额外函数是默认值，用于所有条件都为假的情况。

funclist 调用函数的列表，f(x,*args,**kw)，或标量

每个函数在对应条件为真的地方对x进行评估。它应该以 1 维数组作为输入，并给出 1 维数组或标量值作为输出。如果提供的不是可调用函数，而是标量，则假定是常数函数（lambda x: scalar）。

args 元组，可选

给piecewise传递的任何其他参数在执行时传递给函数，即如果调用 piecewise(..., ..., 1, 'a')，则每个函数都被调用为 f(x, 1, 'a')。

kw 字典，可选

在调用piecewise时使用的关键字参数在执行时传递给函数，即如果调用 piecewise(..., ..., alpha=1)，则每个函数都被调用为 f(x, alpha=1)。

返回：

out ndarray

输出与 x 的形状和类型相同，并通过调用 funclist 中的函数来找到 x 的适当部分，这由 condlist 中的布尔数组定义。未被任何条件覆盖的部分具有默认值为 0。

另请参见

choose、select、where

注意

这类似于 choose 或 select，不同之处在于函数在满足 condlist 中相应条件的 x 元素上评估。

结果如下：

 |--
      |funclist0
out = |funclist1
      |...
      |funclistn2
      |-- 

示例

定义 sigma 函数，当x < 0时为 -1，x >= 0时为+1。

>>> x = np.linspace(-2.5, 2.5, 6)
>>> np.piecewise(x, [x < 0, x >= 0], [-1, 1])
array([-1., -1., -1.,  1.,  1.,  1.]) 

定义绝对值，当x < 0时为-x，x >= 0时为x。

>>> np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x])
array([2.5,  1.5,  0.5,  0.5,  1.5,  2.5]) 

对标量值应用相同的函数。

>>> y = -2
>>> np.piecewise(y, [y < 0, y >= 0], [lambda x: -x, lambda x: x])
array(2) 

NumPy 特定的帮助函数

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

寻找帮助

lookfor(what[, module, import_modules, ...])	在文档字符串中进行关键字搜索。

阅读帮助

info([object, maxwidth, output, toplevel])	获取数组、函数、类或模块的帮助信息。
source(object[, output])	打印或将 NumPy 对象的源代码写入文件。

寻找帮助

lookfor(what[, module, import_modules, ...])	在文档字符串中进行关键字搜索。

阅读帮助

info([object, maxwidth, output, toplevel])	获取数组、函数、类或模块的帮助信息。
source(object[, output])	打印或将 NumPy 对象的源代码写入文件。

numpy.lookfor

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

numpy.lookfor(what, module=None, import_modules=True, regenerate=False, output=None)

对文档字符串进行关键字搜索。

显示匹配搜索的对象列表，按相关性排序。所有给定的关键字都需要在文档字符串中找到，才能作为结果返回，但顺序无关紧要。

参数：

what字符串

包含要查找的单词的字符串。

module字符串或列表，可选

要查看文档字符串的模块名称。

import_modules布尔值，可选

是否导入包中的子模块。默认为 True。

regenerate布尔值，可选

是否重新生成文档字符串缓存。默认为 False。

output文件样式，可选

类文件对象用于写入输出。如果省略，则使用翻页程序。

另请参阅

source, info

注意

相关性只能粗略地确定，通过检查关键词是否出现在函数名中，是否在文档字符串的开头等。

示例

>>> np.lookfor('binary representation') 
Search results for 'binary representation'
------------------------------------------
numpy.binary_repr
 Return the binary representation of the input number as a string.
numpy.core.setup_common.long_double_representation
 Given a binary dump as given by GNU od -b, look for long double
numpy.base_repr
 Return a string representation of a number in the given base system.
... 

numpy.info

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

numpy.info(object=None, maxwidth=76, output=None, toplevel='numpy')

获取有关数组、函数、类或模块的帮助信息。

参数:

对象对象或字符串，可选

输入对象或名称以获取有关信息。如果对象是一个ndarray实例，则将打印有关数组的信息。如果对象是一个 numpy 对象，则给出其文档字符串。如果是字符串，则搜索匹配对象的可用模块。如果为 None，则返回有关info本身的信息。

最大宽度int，可选

打印宽度。

输出文件类似对象，可选

输出被写入的文件类似对象，默认为None，在这种情况下将使用sys.stdout。该对象必须以‘w’或‘a’模式打开。

顶级str，可选

从这个级别开始搜索。

另请参阅

source, lookfor

笔记

在使用对象与交互时，np.info(obj)相当于在 Python 提示符上使用help(obj)或在 IPython 提示符上使用obj?。

示例

>>> np.info(np.polyval) 
 polyval(p, x)
 Evaluate the polynomial p at x.
 ... 

当使用字符串作为对象时，可能会得到多个结果。

>>> np.info('fft') 
 *** Found in numpy ***
Core FFT routines
...
 *** Found in numpy.fft ***
 fft(a, n=None, axis=-1)
...
 *** Repeat reference found in numpy.fft.fftpack ***
 *** Total of 3 references found. *** 

当参数是一个数组时，将打印有关数组的信息。

>>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64)
>>> np.info(a)
class:  ndarray
shape:  (2, 3)
strides:  (24, 8)
itemsize:  8
aligned:  True
contiguous:  True
fortran:  False
data pointer: 0x562b6e0d2860  # may vary
byteorder:  little
byteswap:  False
type: complex64 

numpy.source

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

numpy.source(object, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)

打印或将 NumPy 对象的源代码写入文件。

仅对使用 Python 编写的对象返回源代码。许多函数和类是用 C 定义的，因此不会返回有用信息。

参数：

objectnumpy 对象

输入对象。这可以是任何对象（函数，类，模块，…）。

output文件对象，可选

如果没有提供output，则源代码将打印到屏幕（sys.stdout）。文件对象必须以写入模式‘w’或追加模式‘a’创建。

另请参见

lookfor, info

示例

>>> np.source(np.interp)                        
In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py
def interp(x, xp, fp, left=None, right=None):
 """.... (full docstring printed)"""
 if isinstance(x, (float, int, number)):
 return compiled_interp([x], xp, fp, left, right).item()
 else:
 return compiled_interp(x, xp, fp, left, right) 

仅对使用 Python 编写的对象返回源代码。

>>> np.source(np.array)                         
Not available for this object. 

输入和输出

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

NumPy 二进制文件（NPY，NPZ）

load(file[, mmap_mode, allow_pickle, ...])	从.npy、.npz或 pickled 文件加载数组或 pickled 对象。
save(file, arr[, allow_pickle, fix_imports])	将数组保存为 NumPy .npy格式的二进制文件。
savez(file, *args, **kwds)	将多个数组保存到一个未压缩的.npz格式文件中。
savez_compressed(file, *args, **kwds)	将多个数组保存到一个压缩的.npz格式文件中。

这些二进制文件类型的格式在numpy.lib.format中有文档记录。

文本文件

loadtxt(fname[, dtype, comments, delimiter, ...])	从文本文件加载数据。
savetxt(fname, X[, fmt, delimiter, newline, ...])	将数组保存到文本文件。
genfromtxt(fname[, dtype, comments, ...])	从文本文件加载数据，并根据指定的方式处理缺失值。
fromregex(file, regexp, dtype[, encoding])	使用正则表达式解析构造数组。
fromstring(string[, dtype, count, like])	从字符串中的文本数据初始化新的一维数组。
ndarray.tofile(fid[, sep, format])	将数组写入文件，可以选择文本或二进制格式（默认）。
ndarray.tolist()	将数组返回为 Python 标量的a.ndim级深度嵌套列表。

原始二进制文件

fromfile(file[, dtype, count, sep, offset, like])	从文本或二进制文件中的数据构造数组。
ndarray.tofile(fid[, sep, format])	将数组写入文件，可以选择文本或二进制格式（默认）。

字符串格式化

array2string(a[, max_line_width, precision, ...])	返回数组的字符串表示形式。
array_repr(arr[, max_line_width, precision, ...])	返回数组的字符串表示形式。
array_str(a[, max_line_width, precision, ...])	返回数组中数据的字符串表示。
format_float_positional(x[, precision, ...])	将浮点标量格式化为十进制数的字符串表示。
format_float_scientific(x[, precision, ...])	将浮点标量格式化为科学计数法的十进制字符串。

内存映射文件

memmap(filename[, dtype, mode, offset, ...])	在磁盘上的二进制文件中创建一个数组的内存映射。
lib.format.open_memmap(filename[, mode, ...])	打开一个 .npy 文件作为内存映射数组。

文本格式选项

set_printoptions([precision, threshold, ...])	设置打印选项。
get_printoptions()	返回当前的打印选项。
set_string_function(f[, repr])	设置要在打印数组时使用的 Python 函数。
printoptions(*args, **kwargs)	用于设置打印选项的上下文管理器。

基于-n 表示

binary_repr(num[, width])	将输入数字的二进制表示作为字符串返回。
base_repr(number[, base, padding])	返回给定基数系统中数字的字符串表示。

数据来源

DataSource([destpath])	通用数据源文件（文件、http、ftp 等）。

二进制格式描述

lib.format	二进制序列化

NumPy 二进制文件（NPY、NPZ）

load(file[, mmap_mode, allow_pickle, ...])	从 .npy、.npz 或 pickle 文件中加载数组或 pickle 对象。
save(file, arr[, allow_pickle, fix_imports])	将数组保存到 NumPy 的二进制文件 .npy 格式中。
savez(file, *args, **kwds)	将多个数组保存到一个未压缩的 .npz 格式文件中。
savez_compressed(file, *args, **kwds)	将多个数组保存到以.npz格式压缩的单个文件中。

这些二进制文件类型的格式在numpy.lib.format中有详细文档。

文本文件

loadtxt(fname[, dtype, comments, delimiter, ...])	从文本文件中加载数据。
savetxt(fname, X[, fmt, delimiter, newline, ...])	将数组保存到文本文件中。
genfromtxt(fname[, dtype, comments, ...])	从文本文件中加载数据，并根据指定方式处理缺失值。
fromregex(file, regexp, dtype[, encoding])	使用正则表达式解析，从文本文件中构建数组。
fromstring(string[, dtype, count, like])	从字符串中的文本数据初始化一个新的 1 维数组。
ndarray.tofile(fid[, sep, format])	将数组以文本或二进制格式（默认为二进制）写入文件。
ndarray.tolist()	将数组作为a.ndim级别的嵌套 Python 标量列表返回。

原始二进制文件

fromfile(file[, dtype, count, sep, offset, like])	从文本或二进制文件中构建数组。
ndarray.tofile(fid[, sep, format])	将数组写入文件，可以选择文本或二进制格式（默认为二进制）。

字符串格式化

array2string(a[, max_line_width, precision, ...])	返回数组的字符串表示形式。
array_repr(arr[, max_line_width, precision, ...])	返回数组的字符串表示形式。
array_str(a[, max_line_width, precision, ...])	返回数组中数据的字符串表示形式。
format_float_positional(x[, precision, ...])	以定点表示法将浮点标量格式化为十进制字符串。
format_float_scientific(x[, precision, ...])	以科学计数法将浮点标量格式化为十进制字符串。

内存映射文件

memmap(filename[, dtype, mode, offset, ...])	创建一个映射到存储在磁盘上的二进制文件中的数组的内存映射。
lib.format.open_memmap(filename[, mode, ...])	打开一个 .npy 文件作为内存映射数组。

文本格式选项

set_printoptions([precision, threshold, ...])	设置打印选项。
get_printoptions()	返回当前打印选项。
set_string_function(f[, repr])	设置在打印数组时使用的 Python 函数。
printoptions(*args, **kwargs)	用于设置打印选项的上下文管理器。

Base-n 表示

binary_repr(num[, width])	将输入数字的二进制表示作为字符串返回。
base_repr(number[, base, padding])	返回给定基本系统中数字的字符串表示。

数据来源

DataSource([destpath])	通用数据源文件（文件，http，ftp，...）。

二进制格式描述

lib.format	二进制序列化

numpy.load

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

numpy.load(file, mmap_mode=None, allow_pickle=False, fix_imports=True, encoding='ASCII', *, max_header_size=10000)

从.npy、.npz或拾取文件中加载数组或拾取对象。

警告

包含对象数组的文件使用pickle模块，该模块不安全，可能导致错误或恶意构造的数据。考虑传递allow_pickle=False来加载已知不包含对象数组的数据，以更安全地处理不受信任的来源。

参数：

file类文件对象，字符串或 pathlib.Path

要读取的文件。类文件对象必须支持seek()和read()方法，并且必须始终以二进制模式打开。已经拾取的文件需要类文件对象也支持readline()方法。

mmap_mode，可选

如果不是 None，则使用给定的模式内存映射文件（查看numpy.memmap以获取模式的详细描述）。内存映射数组保存在磁盘上。但是，它可以像任何 ndarray 一样被访问和切片。内存映射对于在不将整个文件读入内存的情况下访问大文件的小片段特别有用。

allow_pickle布尔型，可选

允许加载存储在 npy 文件中的拾取对象数组。不允许拾取的原因包括安全性，因为加载拾取数据可以执行任意代码。如果不允许拾取，加载对象数组将失败。默认值：False

在版本 1.16.3 中更改：对 CVE-2019-6446 作出默认为 False 的响应。

fix_imports布尔型，可选

仅在 Python 3 上加载 Python 2 生成的拾取文件时才有用，其中包括包含对象数组的 npy/npz 文件。如果fix_imports为 True，pickle 将尝试将旧的 Python 2 名称映射到 Python 3 中使用的新名称。

encoding字符串，可选

读取 Python 2 字符串时要使用的编码。仅在 Python 3 中加载 Python 2 生成的拾取文件时才有用，其中包括包含对象数组的 npy/npz 文件。不允许使用除'latin1'、'ASCII'和'bytes'以外的值，因为它们可能会破坏数值数据。默认值：'ASCII'

max_header_size整数，可选

标头的最大允许大小。大标头可能无法安全加载，因此需要显式传递较大的值。有关详细信息，请参见ast.literal_eval。在传递allow_pickle时，此选项将被忽略。在这种情况下，文件从定义上是受信任的，限制是不必要的。

返回：

result数组，元组，字典等。

文件中存储的数据。对于.npz文件，返回的 NpzFile 类实例必须关闭，以避免泄漏文件描述符。

引发：

OSError

如果输入文件不存在或无法读取。

UnpicklingError

如果allow_pickle=True，但文件无法作为拾取加载。

ValueError

文件包含对象数组，但给定allow_pickle=False。

EOFError

在同一文件句柄上多次调用np.load时，如果所有数据已被读取

参见

save, savez, savez_compressed, loadtxt

memmap

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

lib.format.open_memmap

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

注意

• 如果文件包含 pickle 数据，那么将返回 pickle 中存储的任何对象。

• 如果文件是一个.npy文件，则返回一个单个数组。

• 如果文件是一个.npz文件，那么将返回一个类似字典的对象，包含了存档中每个文件的{文件名: 数组}键值对。

• 如果文件是一个.npz文件，则返回的值支持上下文管理器协议，类似于open函数：

  with load('foo.npz') as data:
      a = data['a'] 
  

  当退出‘with’块时，底层文件描述符将被关闭。

示例

将数据存储到磁盘，然后再次加载它：

>>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]]))
>>> np.load('/tmp/123.npy')
array([[1, 2, 3],
 [4, 5, 6]]) 

将压缩数据存储到磁盘，然后再次加载它：

>>> a=np.array([[1, 2, 3], [4, 5, 6]])
>>> b=np.array([1, 2])
>>> np.savez('/tmp/123.npz', a=a, b=b)
>>> data = np.load('/tmp/123.npz')
>>> data['a']
array([[1, 2, 3],
 [4, 5, 6]])
>>> data['b']
array([1, 2])
>>> data.close() 

内存映射存储的数组，直接从磁盘访问第二行：

>>> X = np.load('/tmp/123.npy', mmap_mode='r')
>>> X[1, :]
memmap([4, 5, 6]) 

numpy.save

numpy.org/doc/1.26/reference/generated/numpy.save.html

numpy.save(file, arr, allow_pickle=True, fix_imports=True)

将数组以 NumPy 的 .npy 格式保存到二进制文件中。

参数：

filefile、str 或 pathlib.Path

要保存数据的文件或文件名。如果文件是文件对象，则文件名保持不变。如果文件是字符串或路径，则如果文件名没有 .npy 扩展名，则会将 .npy 扩展名附加到文件名。

arrarray_like

待保存的数组数据。

allow_picklebool，可选

允许使用 Python pickle 保存对象数组。不允许 pickle 的原因包括安全性（加载 pickle 数据可能执行任意代码）和可移植性（pickle 对象可能无法在不同的 Python 安装中加载，例如，如果存储的对象需要不可用的库，则不是所有的 pickle 数据都兼容 Python 2 和 Python 3）。默认：True

fix_importsbool，可选

只对 Python 3 中强制对象数组中的对象以 Python 2 兼容的方式进行 pickle 有用。如果 fix_imports 为 True，则 pickle 将尝试将新的 Python 3 名称映射到 Python 2 中使用的旧模块名称，以便 pickle 数据流可以在 Python 2 中读取。

另请参见

savez

将多个数组保存到 .npz 存档中

savetxt, load

注释

有关 .npy 格式的描述，请参阅 numpy.lib.format.

保存到文件的任何数据都将追加到文件的末尾。

示例

>>> from tempfile import TemporaryFile
>>> outfile = TemporaryFile() 

>>> x = np.arange(10)
>>> np.save(outfile, x) 

>>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file
>>> np.load(outfile)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 

>>> with open('test.npy', 'wb') as f:
...     np.save(f, np.array([1, 2]))
...     np.save(f, np.array([1, 3]))
>>> with open('test.npy', 'rb') as f:
...     a = np.load(f)
...     b = np.load(f)
>>> print(a, b)
# [1 2] [1 3] 

numpy.savez

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

numpy.savez(file, *args, **kwds)

将多个数组保存到未压缩的.npz格式单个文件中。

提供数组作为关键字参数，以便将它们存储到输出文件中的相应名称下：savez(fn, x=x, y=y)。

如果数组作为位置参数指定，即savez(fn, x, y)，它们的名称将是arr_0、arr_1等。

参数：

file：字符串或文件

文件名（字符串）或打开的文件（类文件对象），其中数据将被保存。如果文件是字符串或 Path，且文件名还未包含.npz扩展名，则会将.npz扩展名添加到文件名上。

args：参数，可选

要保存到文件的数组。请使用关键字参数（见下面的kwds）为数组指定名称。作为参数指定的数组将被命名为“arr_0”、“arr_1”等。

kwds：关键字参数，可选

要保存到文件的数组。每个数组将与其对应的关键字名称一起保存到输出文件中。

返回:

无

另请参见

save

将单个数组以 NumPy 格式保存到二进制文件中。

savetxt

将数组以纯文本形式保存到文件中。

savez_compressed

将多个数组保存到压缩的.npz存档中

注释

.npz文件格式是以其包含的变量命名的文件的压缩存档。存档未经压缩，存档中的每个文件都包含.npy格式中的一个变量。有关.npy格式的描述，请参见numpy.lib.format。

使用load打开保存的.npz文件时，将返回一个NpzFile对象。这是一种类似于字典的对象，可以查询其数组列表（使用.files属性）以及数组本身。

在kwds中传递的键将用作 ZIP 存档内的文件名。因此，键应该是有效的文件名；例如，要避免以/开头或包含.的键。

使用关键字参数命名变量时，无法将变量命名为file，因为这将导致在调用savez时直接出现两次file参数定义。

示例

>>> from tempfile import TemporaryFile
>>> outfile = TemporaryFile()
>>> x = np.arange(10)
>>> y = np.sin(x) 

使用args和savez，将使用默认名称保存数组。

>>> np.savez(outfile, x, y)
>>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file
>>> npzfile = np.load(outfile)
>>> npzfile.files
['arr_0', 'arr_1']
>>> npzfile['arr_0']
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 

使用savez和kwds，数组将使用关键字名称保存。

>>> outfile = TemporaryFile()
>>> np.savez(outfile, x=x, y=y)
>>> _ = outfile.seek(0)
>>> npzfile = np.load(outfile)
>>> sorted(npzfile.files)
['x', 'y']
>>> npzfile['x']
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 

numpy.savez_compressed

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

numpy.savez_compressed(file, *args, **kwds)

将多个数组保存到压缩的.npz格式的单个文件中。

使用关键字参数提供数组以在输出文件中将它们存储在相应的名称下：savez(fn, x=x, y=y)。

如果数组被指定为位置参数，即savez(fn, x, y)，它们的名称将是arr_0、arr_1等。

参数：

filestr 或文件

要么文件名（字符串），要么数据将被保存的已打开文件（类似文件的对象）。如果文件是字符串或路径，如果文件名尚未存在，将在文件名后附加.npz扩展名。

args参数，可选

要保存到文件中的数组。请使用关键字参数（参见下面的kwds）为数组指定名称。作为参数指定的数组将被命名为“arr_0”、“arr_1”等。

kwds关键字参数，可选

要保存到文件中的数组。每个数组将以其对应的关键字名称保存到输出文件中。

返回：

无

另请参阅

numpy.save

将单个数组保存为 NumPy 格式的二进制文件。

numpy.savetxt

将数组保存为纯文本文件。

numpy.savez

将多个数组保存到未压缩的.npz文件格式中。

numpy.load

加载由 savez_compressed 创建的文件。

注意

.npz文件格式是一个以包含的变量命名的文件压缩存档。存档使用zipfile.ZIP_DEFLATED进行压缩，存档中的每个文件都以.npy格式包含一个变量。有关.npy格式的描述，请参阅numpy.lib.format。

使用load打开保存的.npz文件时，将返回一个NpzFile对象。这是一个类似字典的对象，可以查询它的数组列表（使用.files属性），以及数组本身。

示例

>>> test_array = np.random.rand(3, 2)
>>> test_vector = np.random.rand(4)
>>> np.savez_compressed('/tmp/123', a=test_array, b=test_vector)
>>> loaded = np.load('/tmp/123.npz')
>>> print(np.array_equal(test_array, loaded['a']))
True
>>> print(np.array_equal(test_vector, loaded['b']))
True 

numpy.loadtxt

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

numpy.loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes', max_rows=None, *, quotechar=None, like=None)

从文本文件加载数据。

参数：

fname 文件，str，pathlib.Path，str 列表，生成器

用于读取的文件、文件名、列表或生成器。如果文件名扩展名为.gz或.bz2，则首先解压缩文件。请注意，生成器必须返回字节或字符串。列表中的字符串或生成器生成的字符串将被视为行。

dtype 数据类型，可选

结果数组的数据类型；默认为 float。如果这是一个结构化数据类型，则结果数组将是 1 维的，并且每行将被解释为数组的一个元素。在这种情况下，使用的列数必须与数据类型中字段的数量匹配。

comments 字符串或字符串序列或 None，可选

用于指示注释开始的字符或字符列表。None 表示没有注释。为了向后兼容，字节字符串将解码为‘latin1’。默认值为‘#’。

delimiter 字符串，可选

用于分隔值的字符。为了向后兼容，字节字符串将解码为‘latin1’。默认为空格。

版本 1.23.0 中的更改：仅支持单个字符分隔符。不能使用换行符作为分隔符。

converters 字典或可调用函数，可选

转换函数用于自定义值解析。如果 converters 是可调用函数，则该函数将应用于所有列，否则必须是将列号映射到解析函数的字典。详细信息请参见示例。默认值：None。

版本 1.23.0 中的更改：添加了将单个可调用函数传递给所有列的功能。

skiprows 整数，可选

跳过第skiprows行，包括注释；默认为 0。

usecols 整数或序列，可选

要读取的列，从 0 开始计数。例如， usecols = (1,4,5) 将提取第 2、第 5 和第 6 列。默认值 None 将导致读取所有列。

版本 1.11.0 中的更改：当必须读取单个列时，可以使用整数来代替元组。例如 usecols = 3 将读取第四列，就像 usecols = (3,) 一样。

unpack 布尔值，可选

如果为 True，则返回的数组将被转置，以便可以使用x, y, z = loadtxt(...)拆包参数。与结构化数据类型一起使用时，将为每个字段返回数组。默认值为 False。

ndmin 整数，可选

返回的数组将至少有 ndmin 维。否则将压缩单维轴。合法值：0（默认）、1 或 2。

版本 1.6.0 中的新功能。

encoding 字符串，可选

用于解码输入文件的编码方式。不适用于输入流。特殊值'bytes'启用了向后兼容的解决方案，以确保如果可能的话您收到字节数组作为结果，并将'latin1'编码的字符串传递给转换器。覆盖此值以接收 Unicode 数组，并将字符串作为输入传递给转换器。如果设置为 None，则使用系统默认值。默认值为'bytes'。

新功能在版本 1.14.0 中引入。

max_rows：int，可选

在跳过skiprows行后，读取max_rows行内容。默认是读取所有行。请注意，不包含任何数据的空行，如空行和注释行，不计入max_rows，而这些行是在skiprows中计算的。

新功能在版本 1.16.0 中引入。

在版本 1.23.0 中更改：不包含任何数据的行，包括注释行（例如，以'#'开头的行或通过comments指定的行），不计入max_rows。

quotechar：Unicode 字符或 None，可选

用于标识引号项的起始和结束的字符。在引号项中忽略定界符或注释字符的出现。默认值为quotechar=None，这意味着引号支持被禁用。

如果在引号字段内找到两个连续的quotechar实例，则第一个将被视为转义字符。请参考示例。

新功能在版本 1.23.0 中引入。

like：array_like，可选

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

新功能在版本 1.20.0 中引入。

返回：

out：ndarray

从文本文件读取的数据。

另请参阅

load，fromstring，fromregex

genfromtxt

加载处理了缺失值的数据。

scipy.io.loadmat

读取 MATLAB 数据文件。

注意事项

该函数旨在成为用于简单格式文件的快速读取器。genfromtxt函数提供了更复杂的处理方式，例如处理具有缺失值的行。

为了能够读取所有值，输入文本文件中的每一行必须具有相同数量的值。如果所有行的值数量不相同，可以通过usecols指定的列来读取最多 n 列的子集（其中 n 是所有行中存在的值的最小数量）。

新功能在版本 1.10.0 中引入。

Python float.hex 方法生成的字符串可以用作浮点数的输入。

示例

>>> from io import StringIO   # StringIO behaves like a file object
>>> c = StringIO("0 1\n2 3")
>>> np.loadtxt(c)
array([[0., 1.],
 [2., 3.]]) 

>>> d = StringIO("M 21 72\nF 35 58")
>>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),
...                      'formats': ('S1', 'i4', 'f4')})
array([(b'M', 21, 72.), (b'F', 35, 58.)],
 dtype=[('gender', 'S1'), ('age', '<i4'), ('weight', '<f4')]) 

>>> c = StringIO("1,0,2\n3,0,4")
>>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)
>>> x
array([1., 3.])
>>> y
array([2., 4.]) 

converters参数用于指定在解析前对文本进行预处理的函数。converters可以是一个将预处理函数映射到每列的字典。

>>> s = StringIO("1.618, 2.296\n3.141, 4.669\n")
>>> conv = {
...     0: lambda x: np.floor(float(x)),  # conversion fn for column 0
...     1: lambda x: np.ceil(float(x)),  # conversion fn for column 1
... }
>>> np.loadtxt(s, delimiter=",", converters=conv)
array([[1., 3.],
 [3., 5.]]) 

converters可以是一个可调用对象而不是字典，此时它会应用于所有列。

>>> s = StringIO("0xDE 0xAD\n0xC0 0xDE")
>>> import functools
>>> conv = functools.partial(int, base=16)
>>> np.loadtxt(s, converters=conv)
array([[222., 173.],
 [192., 222.]]) 

此示例展示了如何使用converters将带有后缀减号的字段转换为负数。

>>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94')
>>> def conv(fld):
...     return -float(fld[:-1]) if fld.endswith(b'-') else float(fld)
...
>>> np.loadtxt(s, converters=conv)
array([[ 10.01, -31.25],
 [ 19.22,  64.31],
 [-17.57,  63.94]]) 

使用可调用对象作为转换器在处理具有不同格式的值时可以特别有用，例如带下划线的浮点数。

>>> s = StringIO("1 2.7 100_000")
>>> np.loadtxt(s, converters=float)
array([1.e+00, 2.7e+00, 1.e+05]) 

这个想法可以扩展到自动处理以许多不同格式指定的值。

>>> def conv(val):
...     try:
...         return float(val)
...     except ValueError:
...         return float.fromhex(val)
>>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2")
>>> np.loadtxt(s, delimiter=",", converters=conv, encoding=None)
array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00]) 

使用默认的encoding="bytes"时，请注意，转换函数的输入是 latin-1 编码的字节字符串。要在转换之前停用隐式编码，请使用encoding=None。

>>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94')
>>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x)
>>> np.loadtxt(s, converters=conv, encoding=None)
array([[ 10.01, -31.25],
 [ 19.22,  64.31],
 [-17.57,  63.94]]) 

通过quotechar参数启用对带引号字段的支持。当注释和分隔符字符出现在由quotechar界定的带引号项中时，它们会被忽略。

>>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n')
>>> dtype = np.dtype([("label", "U12"), ("value", float)])
>>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"')
array([('alpha, #42', 10.), ('beta, #64',  2.)],
 dtype=[('label', '<U12'), ('value', '<f8')]) 

引用字段可以由多个空格字符分隔。

>>> s = StringIO('"alpha, #42"       10.0\n"beta, #64" 2.0\n')
>>> dtype = np.dtype([("label", "U12"), ("value", float)])
>>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"')
array([('alpha, #42', 10.), ('beta, #64',  2.)],
 dtype=[('label', '<U12'), ('value', '<f8')]) 

在带引号字段中的两个连续引号字符被视为单个转义字符。

>>> s = StringIO('"Hello, my name is ""Monty""!"')
>>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"')
array('Hello, my name is "Monty"!', dtype='<U26') 

当所有行不包含相同数量的值时，读取子列。

>>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20")
>>> np.loadtxt(d, usecols=(0, 1))
array([[ 1.,  2.],
 [ 2.,  4.],
 [ 3.,  9.],
 [ 4., 16.]]) 

numpy.savetxt

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

numpy.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ', encoding=None)

将数组保存到文本文件中。

参数：

fname文件名或文件句柄

如果文件名以.gz结尾，则文件会自动以压缩的 gzip 格式保存。loadtxt能够透明地理解 gzipped 文件。

X1D 或 2D array_like

要保存到文本文件中的数据。

fmtstr 或 str 序列，可选

单个格式（%10.5f），一系列格式，或多格式字符串，例如‘Iteration %d – %10.5f’，在这种情况下delimiter将被忽略。对于复杂的X，fmt的合法选项是：

• 单个说明符，fmt=’%.4e’，得到格式化的数字如‘ (%s+%sj)’ % (fmt, fmt)

• 一个完整的字符串，指定每个实部和虚部，例如‘ %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej’用于 3 列

• 一个说明符列表，每列一个 - 在这种情况下，实部和虚部必须具有单独的说明符，例如[‘%.3e + %.3ej’, ‘(%.15e%+.15ej)’]用于 2 列

delimiterstr，可选

用于分隔列的字符串或字符。

newlinestr，可选

用于分隔行的字符串或字符。

版本 1.5.0 中的新功能。

headerstr，可选

将写入文件开头的字符串。

版本 1.7.0 中的新功能。

footerstr，可选

将写入文件末尾的字符串。

版本 1.7.0 中的新功能。

commentsstr，可选

将作为注释添加到header和footer字符串之前的字符串，以标记它们。默认值为‘# ’，如numpy.loadtxt所预期。

版本 1.7.0 中的新功能。

encoding，可选

用于编码输出文件的编码。不适用于输出流。如果编码不是‘bytes’或‘latin1’，则您将无法在 NumPy 版本 < 1.14 中加载文件。默认为‘latin1’。

版本 1.14.0 中的新功能。

另请参见

save

将数组保存到 NumPy 的二进制文件.npy格式中

savez

将几个数组保存到未压缩的.npz存档中

savez_compressed

将几个数组保存到压缩的.npz存档中

注释

fmt 参数的进一步解释（%[flag]width[.precision]specifier）：

标志：

-：左对齐

+：强制在结果之前加上+或-。

0：左侧用零而不是空格填充数字（参见宽度）。

宽度：

要打印的最小字符数。如果具有更多字符，则不截断该值。

精度：

• 对于整数说明符（例如d,i,o,x），最小位数。

• 对于e, E和f说明符，小数点后要打印的位数。

• 对于g和G，最大有效位数。

• 对于s，要打印的最大字符数。

说明符：

c：字符

d或i：有符号十进制整数

e 或 E：科学计数法，使用 e 或 E。

f：十进制浮点数

g,G：使用 e,E 或 f 中较短的一个

o：有符号八进制

s：字符串

u：无符号十进制整数

x,X：无符号十六进制整数

fmt 的这种解释并不完整，对于详尽的规范，请参阅 [1]。

参考资料

[1]

格式规范微语言，Python 文档。

示例

>>> x = y = z = np.arange(0.0,5.0,1.0)
>>> np.savetxt('test.out', x, delimiter=',')   # X is an array
>>> np.savetxt('test.out', (x,y,z))   # x,y,z equal sized 1D arrays
>>> np.savetxt('test.out', x, fmt='%1.4e')   # use exponential notation 

numpy.genfromtxt

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

numpy.genfromtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, names=None, excludelist=None, deletechars=" !#$%&'()*+, -./:;<=>?@[\\]^{|}~", replace_space='_', autostrip=False, case_sensitive=True, defaultfmt='f%i', unpack=None, usemask=False, loose=True, invalid_raise=True, max_rows=None, encoding='bytes', *, ndmin=0, like=None)

从文件读取数据，并按指定处理缺失值。

第一个skip_header行之后的每一行都在delimiter字符处拆分，并且在comments字符后面的字符都会被丢弃。

参数：

fname file，str，pathlib.Path，str 列表，生成器

要读取的文件、文件名、列表或生成器。如果文件名的扩展名是.gz或.bz2，则首先对文件进行解压缩。请注意，生成器必须返回字节或字符串。列表中的字符串或生成器生成的字符串被视为行。

dtype dtype，可选

结果数组的数据类型。如果为 None，则数据类型将由每列的内容分别确定。

comments str，可选

表示注释开始的字符。注释后出现的所有字符都会被丢弃。

delimiter str，int 或序列，可选

用于分隔值的字符串。默认情况下，任何连续的空白字符都作为分隔符。也可以提供整数或每个字段的宽度的序列。

skiprows int，可选

在 numpy 1.10 版中移除了skiprows。请改用skip_header。

skip_header int，可选

文件开头要跳过的行数。

skip_footer int，可选

文件末尾要跳过的行数。

converters 变量，可选

将列数据转换为值的一组函数。转换器还可用于为缺失数据提供默认值：converters = {3: lambda s: float(s or 0)}。

missing 变量，可选

在 numpy 1.10 版中删除了missing。请改用missing_values。

missing_values 变量，可选

对应缺失数据的一组字符串。

filling_values 变量，可选

数据缺失时要使用的默认值集合。

usecols 序列，可选

要读取的列，其中 0 表示第一列。例如，usecols = (1, 4, 5)将提取第 2、5 和 6 列。

names {None，True，str，sequence}，可选

如果names为 True，则字段名称将从第一个skip_header行之后的第一行读取。此行可以选择由注释分隔符前导。如果names是一个序列或以逗号分隔的单个字符串，那么将使用这些名称来定义结构化 dtype 中的字段名称。如果names为 None，则将使用 dtype 字段的名称（如果有）。

excludelist 序列，可选

要排除的名称列表。此列表会附加到默认列表['return'，'file'，'print']。排除的名称将添加下划线：例如，file将变为file_。

deletechars str，可选

一个字符串，其中包含必须从名称中删除的无效字符。

defaultfmt str，可选

用于定义默认字段名称的格式，如“f%i”或“f_%02i”。

autostripbool，可选

是否自动从变量中去除空格。

replace_spacechar，可选

用于替换变量名称中的空格的字符。默认使用 ‘_’。

case_sensitive，可选

如果为 True，则字段名称区分大小写。如果为 False 或 ‘upper’，则将字段名称转换为大写。如果为 ‘lower’，则将字段名称转换为小写。

unpackbool，可选

如果为 True，则返回的数组为转置数组，因此可以使用 x, y, z = genfromtxt(...) 进行拆包。当与结构化数据类型一起使用时，为每个字段返回数组。默认为 False。

usemaskbool，可选

如果为 True，则返回一个掩码数组。如果为 False，则返回一个常规数组。

loosebool，可选

如果为 True，则不会对无效值引发错误。

invalid_raisebool，可选

如果检测到列数不一致，则引发异常。如果为 False，则发出警告并跳过错误的行。

max_rowsint，可选

要读取的最大行数。不能与 skip_footer 同时使用。如果给定，值必须至少为 1。默认是读��整个文件。

自版本 1.10.0 起新增。

encodingstr，可选

用于解码输入文件的编码。当 fname 是文件对象时不适用。特殊值 ‘bytes’ 启用向后兼容性的解决方案，以确保在可能的情况下接收字节数组并将 latin1 编码的字符串传递给转换器。覆盖此值以接收 Unicode 数组，并将字符串作为转换器的输入。如果设置为 None，则使用系统默认值。默认值为 ‘bytes’。

自版本 1.14.0 起新增。

ndminint，可选

与 loadtxt 相同的参数

自版本 1.23.0 起新增。

likearray_like，可选

允许创建不是 NumPy 数组的数组的参考对象。如果传递给 like 的类似数组支持 __array_function__ 协议，则结果将由其定义。在这种情况下，它确保创建一个与通过该参数传入的数组兼容的数组对象。

自版本 1.20.0 起新增。

返回：

outndarray

从文本文件中读取的数据。如果 usemask 为 True，则这是一个掩码数组。

另请参见

numpy.loadtxt

没有缺失数据时的等效函数。

注意事项

• 当空格用作分隔符，或者没有输入分隔符时，在两个字段之间不能有任何缺失数据。

• 当变量被命名（使用灵活的 dtype 或 names）时，在文件中不能有任何标题（否则会引发 ValueError 异常）。

• 默认情况下，单个值不会去除空格。在使用自定义转换器时，请确保该函数会去除空格。

参考

[1]

NumPy 用户指南，NumPy I/O 部分。

示例

>>> from io import StringIO
>>> import numpy as np 

以混合数据类型为分隔符的逗号分隔文件

>>> s = StringIO(u"1,1.3,abcde")
>>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'),
... ('mystring','S5')], delimiter=",")
>>> data
array((1, 1.3, b'abcde'),
 dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')]) 

使用 dtype = None

>>> _ = s.seek(0) # needed for StringIO example only
>>> data = np.genfromtxt(s, dtype=None,
... names = ['myint','myfloat','mystring'], delimiter=",")
>>> data
array((1, 1.3, b'abcde'),
 dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')]) 

指定 dtype 和 names

>>> _ = s.seek(0)
>>> data = np.genfromtxt(s, dtype="i8,f8,S5",
... names=['myint','myfloat','mystring'], delimiter=",")
>>> data
array((1, 1.3, b'abcde'),
 dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')]) 

具有固定宽度列的示例

>>> s = StringIO(u"11.3abcde")
>>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'],
...     delimiter=[1,3,5])
>>> data
array((1, 1.3, b'abcde'),
 dtype=[('intvar', '<i8'), ('fltvar', '<f8'), ('strvar', 'S5')]) 

展示注释的示例

>>> f = StringIO('''
... text,# of chars
... hello world,11
... numpy,5''')
>>> np.genfromtxt(f, dtype='S12,S12', delimiter=',')
array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')],
 dtype=[('f0', 'S12'), ('f1', 'S12')]) 

numpy.fromregex

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

numpy.fromregex(file, regexp, dtype, encoding=None)

使用正则表达式解析文本文件构建一个数组。

返回的数组始终是一个结构化数组，并由文件中正则表达式的所有匹配构建。正则表达式中的组被转换为结构化数组的字段。

参数：

file路径或文件

要读取的文件名或文件对象。

在版本 1.22.0 中更改：现在接受os.PathLike实现。

regexpstr 或 regexp

用于解析文件的正则表达式。正则表达式中的组对应于 dtype 中的字段。

dtypedtype 或 dtype 列表

用于结构化数组的 Dtype；必须是结构化数据类型。

encodingstr，可选

用于解码输入文件的编码。不适用于输入流。

版本 1.14.0 新增。

返回：

outputndarray

输出数组，包含与regexp匹配的file的内容的一部分。output始终是一个结构化数组。

Raises：

TypeError

当dtype不是结构化数组的有效 dtype 时。

另请参阅

fromstring，loadtxt

注意事项

结构化数组的 Dtype 可以以多种形式指定，但所有形式至少指定数据类型和字段名。有关详细信息，请参阅 basics.rec。

示例

>>> from io import StringIO
>>> text = StringIO("1312 foo\n1534  bar\n444   qux") 

>>> regexp = r"(\d+)\s+(...)"  # match [digits, whitespace, anything]
>>> output = np.fromregex(text, regexp,
...                       [('num', np.int64), ('key', 'S3')])
>>> output
array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')],
 dtype=[('num', '<i8'), ('key', 'S3')])
>>> output['num']
array([1312, 1534,  444])