NumPy参考
数组创建
零 和 一
empty(shape[, dtype, order])：返回给定形状和类型的新数组，而不初始化条目
empty_like(prototype[, dtype, order, subok])：返回一个与给定数组具有相同形状和类型的新数组.
eye(N[, M, k, dtype, order])：返回一个二维数组，其中对角线为1,零点为零.
identity(n[, dtype])：返回标识数组.
ones(shape[, dtype, order])：返回一个给定形状和类型的新数组，用一填充
ones_like(a[, dtype, order, subok])：返回与给定数组具有相同形状和类型的数组.
zeros(shape[, dtype, order])：返回给定形状和类型的新数组，用零填充
zeros_like(a[, dtype, order, subok])：返回与给定数组具有相同形状和类型的零数组
full(shape, fill_value[, dtype, order])：返回给定形状和类型的新数组，填充fill_value
full_like(a, fill_value[, dtype, order, subok])：返回与给定数组具有相同形状和类型的完整数组.
现有数据来源
array(object[, dtype, copy, order, subok, ndmin])：创建一个数组.
asarray(a[, dtype, order])：将输入转换为数组.
asanyarray(a[, dtype, order])：将输入转换为ndarray，但通过ndarray子类.
ascontiguousarray(a[, dtype])：在内存中返回一个连续的数组（C顺序）.
asmatrix(data[, dtype])：将输入解释为矩阵.
copy(a[, order])：返回给定对象的数组副本.
frombuffer(buffer[, dtype, count, offset])：将缓冲区解释为一维数组.
fromfile(file[, dtype, count, sep])：根据文本或二进制文件中的数据构造数组.
fromfunction(function, shape, **kwargs)：通过在每个坐标上执行函数来构造数组
fromiter(iterable, dtype[, count])：从可迭代对象创建新的1维数组.
fromstring(string[, dtype, count, sep])：从字符串中的文本数据初始化的新1-D数组.
loadtxt(fname[, dtype, comments, delimiter, …])：从文本文件加载数据.
创建记录数组 (numpy.rec)
numpy.rec是首选的别名 numpy.core.records
core.records.array(obj[, dtype, shape, …])：从各种各样的对象构造记录数组.
core.records.fromarrays(arrayList[, dtype, …])：从（平面）数组列表创建一个记录数组
core.records.fromrecords(recList[, dtype, …])：从文本形式的记录列表中创建一个重新排列
core.records.fromstring(datastring[, dtype, …])：从包含在中的二进制数据创建（只读）记录数组
core.records.fromfile(fd[, dtype, shape, …])：从二进制文件数据创建数组
创建字符数组 (numpy.char)
numpy.char是首选的别名 numpy.core.defchararray。
core.defchararray.array(obj[, itemsize, …])：创建一个chararray
core.defchararray.asarray(obj[, itemsize, …])：将输入转换为a chararray，仅在必要时复制数据.
数值范围
arange([start,] stop[, step,][, dtype])：在给定间隔内返回均匀间隔的值.
linspace(start, stop[, num, endpoint, …])：在指定的间隔内返回均匀间隔的数字.
logspace(start, stop[, num, endpoint, base, …])：返回在对数刻度上均匀间隔的数字.
geomspace(start, stop[, num, endpoint, dtype])：返回在对数刻度上均匀间隔的数字（几何级数）.
meshgrid(*xi, **kwargs)：从坐标向量返回坐标矩阵.
mgrid：nd_grid实例，它返回一个密集的多维“meshgrid”
ogrid：nd_grid实例，它返回一个开放的多维“meshgrid”
构建矩阵
diag(v[, k])：提取对角线或构造对角线阵列..
diagflat(v[, k])：使用展平输入创建二维数组作为对角线.
tri(N[, M, k, dtype])：一个数组，其中包含给定对角线和低于给定对角线的数字，其他地方为零.
tril(m[, k])：数组的下三角形.
triu(m[, k])：数组的上三角形.
vander(x[, N, increasing])：生成Vandermonde矩阵.
矩阵类型
mat(data[, dtype])：将输入解释为矩阵.
bmat(obj[, ldict, gdict])：从字符串，嵌套序列或数组构建矩阵对象.
数组操作
基本操作
copyto(dst, src[, casting, where])：将值从一个数组复制到另一个数组，并根据需要进行广播.
改变数组形状
reshape(a, newshape[, order])：为数组提供新形状而不更改其数据.
ravel(a[, order])：返回一个连续的扁平数组.
ndarray.flat：数组上的一维迭代器.
ndarray.flatten([order]) ：将折叠的数组的副本返回到一个维度 .类似转置的操作
moveaxis(a, source, destination)：将阵列的轴移动到新位置.
rollaxis(a, axis[, start])：向后滚动指定的轴，直到它位于给定位置
swapaxes(a, axis1, axis2)：交换阵列的两个轴
ndarray.T：与self.transpose()相同，只是如果self.ndim <2则返回self
transpose(a[, axes])：转置数组的维度.
更改维数
atleast_1d(*arys)：将输入转换为至少具有一个维度的数组.
atleast_2d(*arys)：将输入视为具有至少两个维度的数组.
atleast_3d(*arys)：将输入视为具有至少三维的数组.
broadcast：制作一个模仿广播的对象.
broadcast_to(array, shape[, subok])：将数组广播到新形状.
broadcast_arrays(*args, **kwargs)：相互广播任意数量的数组.
expand_dims(a, axis)：展开数组的形状.
squeeze(a[, axis])：从数组的形状中删除一维条目.
改变数组的种类
asarray(a[, dtype, order])：将输入转换为数组.
asanyarray(a[, dtype, order])：将输入转换为ndarray，但通过ndarray子类.
asmatrix(data[, dtype])：将输入解释为矩阵.
asfarray(a[, dtype])：返回转换为float类型的数组.
asfortranarray(a[, dtype])：返回在内存中以Fortran顺序布局的数组.
ascontiguousarray(a[, dtype])：在内存中返回一个连续的数组（C顺序）.
asarray_chkfinite(a[, dtype, order])：将输入转换为数组，检查NaN或Infs.
asscalar(a)：将大小为1的数组转换为标量等效数组.
require(a[, dtype, requirements])：返回满足要求的提供类型的ndarray.
连接数组
concatenate((a1, a2, …)[, axis, out])：沿现有轴加入一系列数组.
stack(arrays[, axis, out])：沿新轴加入一系列数组.
column_stack(tup)：将1-D阵列作为列堆叠成2-D阵列.
dstack(tup)：按顺序深度堆叠阵列（沿第三轴）.
hstack(tup)：按顺序堆叠数组（列式）.
vstack(tup)：垂直堆叠数组（行方式）.
block(arrays)：从嵌套的块列表中组装nd数组.拆分数组
split(ary, indices_or_sections[, axis])：将数组拆分为多个子数组.
array_split(ary, indices_or_sections[, axis])：将数组拆分为多个子数组.
dsplit(ary, indices_or_sections)：沿第3轴（深度）将数组拆分为多个子阵列.
hsplit(ary, indices_or_sections)：将数组水平拆分为多个子数组（按列）.
vsplit(ary, indices_or_sections)：将数组垂直拆分为多个子数组（逐行）
平铺数组
tile(A, reps)：通过重复A重复给出的次数来构造数组.
repeat(a, repeats[, axis])：重复数组的元素.添加和删除元素
delete(arr, obj[, axis])：返回一个新数组，其子轴数组沿轴被删除.
insert(arr, obj, values[, axis])：在给定索引之前沿给定轴插入值.
append(arr, values[, axis])：将值附加到数组的末尾.
resize(a, new_shape)：返回具有指定形状的新数组.
trim_zeros(filt[, trim])：从1-D数组或序列中修剪前导和/或尾随零.
unique(ar[, return_index, return_inverse, …])：找到数组的唯一元素.重新排列元素
flip(m[, axis])：沿给定轴反转数组中元素的顺序.
fliplr(m)：向左/向右翻转阵列.
flipud(m)：向上/向下翻转阵列.
reshape(a, newshape[, order])：为数组提供新形状而不更改其数据.
roll(a, shift[, axis])：沿给定轴滚动数组元素.
rot90(m[, k, axes])：在轴指定的平面中将数组旋转90度二进制运算
元素位操作
bitwise_and(x1, x2, /[, out, where, …])：逐个元素地计算两个数组的逐位AND.
bitwise_or(x1, x2, /[, out, where, casting, …])：逐个元素地计算两个数组的逐位OR.
bitwise_xor(x1, x2, /[, out, where, …])：计算两个数组的逐位XOR元素.
invert(x, /[, out, where, casting, order, …])：按位元素计算逐位反转或逐位NOT.
left_shift(x1, x2, /[, out, where, casting, …])：将整数位移到左侧.
right_shift(x1, x2, /[, out, where, …])：将整数位移到右侧.位打包
packbits(myarray[, axis])：将二进制值数组的元素打包到uint8数组中的位中.
unpackbits(myarray[, axis])：将uint8数组的元素解包为二进制值输出数组.输出格式
binary_repr(num[, width])：将输入数字的二进制表示形式返回为字符串.字符串操作
此模块为类型numpy.string_或类型的数组提供一组矢量化字符串操作numpy.unicode_。所有这些都基于Python标准库中的字符串方法
String operations
add(x1, x2)：返回两个str或unicode数组的逐元素字符串连接.
multiply(a, i)：返回（a * i），即字符串多个连接，逐个元素.
mod(a, values)：返回（a％i），即Python之前的2.6字符串格式化（iterpolation），元素方式为str或unicode的一对array_likes.
capitalize(a)：返回的拷贝一个只有资本的每个元素的第一个字符.
center(a, width[, fillchar])：返回的拷贝一与在长度的字符串居中其元素宽度.
decode(a[, encoding, errors])：以元素方式调用str.decode.
encode(a[, encoding, errors])：以元素方式调用str.encode.
join(sep, seq)：返回一个字符串，它是序列seq中字符串的串联.
ljust(a, width[, fillchar])：返回与元素的数组一个左对齐的长度的字符串宽度.
lower(a)：返回一个数组，其元素转换为小写.
lstrip(a[, chars])：对于每一个元素一个，去除了主角返回副本.
partition(a, sep)：将每个元素分成一个周围的sep.
replace(a, old, new[, count])：对于每一个元素一个，返回字符串的副本串中出现的所有旧的换成新的
rjust(a, width[, fillchar])：返回与元素的数组一个右对齐的长度的字符串宽度.
rpartition(a, sep)：对最右边的分隔符周围的每个元素进行分区（拆分）.
rsplit(a[, sep, maxsplit])：在每个元件一个，返回的词的列表字符串中，使用月作为分隔符串.
rstrip(a[, chars])：在每个元件一个，返回与除去尾部字符的副本.
split(a[, sep, maxsplit])：在每个元件一个，返回的词的列表字符串中，使用月作为分隔符串.
splitlines(a[, keepends])：在每个元件一个，返回行的列表中的元素，在断裂线边界.
strip(a[, chars])：在每个元件一个，其中移除了前缘和后字符返回副本.
swapcase(a)：返回元素的字符串副本，大写字符转换为小写，反之亦然.
title(a)：返回元素字符串的字符串或unicode的版本.
translate(a, table[, deletechars])：对于每一个元素一个，返回其中可选的参数中出现的所有字符的字符串拷贝deletechars被删除，而剩余的字符已经通过给定的转换表映射.
upper(a)：返回一个数组，其元素转换为大写.
zfill(a, width)：返回左边用零填充的数字字符串比较
与标准的numpy比较运算符不同，char 模块中的那些运算符在执行比较之前剥离尾随空白字符.
equal(x1, x2)：以元素方式返回（x1 == x2）.
not_equal(x1, x2)：以元素方式返回（x1！= x2）.
greater_equal(x1, x2)：以元素方式返回（x1> = x2）.
less_equal(x1, x2)：以元素方式返回（x1 <= x2）.
greater(x1, x2)：以元素方式返回（x1> x2）.
less(x1, x2)：以元素方式返回（x1字符串信息
count(a, sub[, start, end])：返回一个数组，其中包含[ start，end ] 范围内substring sub的非重叠出现次数
find(a, sub[, start, end])：对于每个元素，返回找到substring sub的字符串中的最低索引.
index(a, sub[, start, end])：比如find，但是当找不到子字符串时会引发ValueError.
isalpha(a)：如果字符串中的所有字符都是字母并且至少有一个字符，则返回每个元素的true，否则返回false.
isdecimal(a)：对于每个元素，如果元素中只有十进制字符，则返回True.
isdigit(a)：如果字符串中的所有字符都是数字并且至少有一个字符，则返回每个元素的true，否则返回false.
islower(a)：如果字符串中的所有外壳字符都是小写且至少有一个外壳字符，则为每个元素返回true，否则返回false.
isnumeric(a)：对于每个元素，如果元素中只有数字字符，则返回True
isspace(a)：如果字符串中只有空格字符并且至少有一个字符，则为每个元素返回true，否则返回false
istitle(a)：如果元素是一个带有标题的字符串并且至少有一个字符，则为每个元素返回true，否则返回false.
isupper(a)：如果字符串中的所有外壳字符都是大写且至少有一个字符，则返回每个元素的true，否则返回false.
rfind(a, sub[, start, end])：在每个元件一个，在字符串中返回指数最高，其中子子被发现，使得子包含[内开始，结束.
rindex(a, sub[, start, end])：比如rfind，但是当找不到子字符串sub时会引发ValueError.
startswith(a, prefix[, start, end])：返回一个布尔数组是真正的地方在字符串元素一个开头前缀，否则假
便利类
chararray(shape[, itemsize, unicode, …])：提供有关字符串和unicode值数组的便捷视图.日期时间支持功能
datetime_as_string(arr[, unit, timezone, …])：将日期时间数组转换为字符串数组.
datetime_data(dtype, /)：Get information about the step size of a date or time type
工作日功能
busdaycalendar([weekmask, holidays])：工作日日历对象，可有效存储定义busday系列函数的有效天数的信息.
is_busday(dates[, weekmask, holidays, …])：计算哪个给定日期是有效日期，哪些日期不是.
busday_offset(dates, offsets[, roll, …])：首先根据规则将日期调整为有效日期roll，然后将偏移应用于有效日期内计算的给定日期.
busday_count(begindates, enddates[, …])：计算begindates和enddates之间的有效天数，不包括enddates的日期.
数据类型
can_cast(from_, to[, casting])：如果根据强制转换规则在数据类型之间进行转换，则返回True.
promote_types(type1, type2)：返回与最小的尺寸和最小的标样的数据类型，其两者type1并type2可以安全地投.
min_scalar_type(a)：对于标量a，返回具有最小大小和最小标量类型的数据类型，该类型可以保存其值.
result_type(*arrays_and_dtypes)：回将NumPy类型提升规则应用于参数所产生的类型
common_type(*arrays)：返回输入数组常用的标量类型.
obj2sctype(rep[, default])：返回对象的Python类型的标量dtype或NumPy等价物
创建数据类型
dtype(obj[, align, copy])：创建数据类型对象.
format_parser(formats, names, titles[, …])：用于将格式，名称，标题描述转换为dtype的类数据类型信息
finfo(dtype)：浮点类型的机器限制.
iinfo(type)：整数类型的机器限制.
MachAr([float_conv, int_conv, …])：诊断机器参数.数据类型测试
issctype(rep)：确定给定对象是否表示标量数据类型.
issubdtype(arg1, arg2)：如果第一个参数是类型层次结构中较低/相等的类型代码，则返回True
issubsctype(arg1, arg2)：确定第一个参数是否是第二个参数的子类.
issubclass_(arg1, arg2)：确定类是否是第二个类的子类.
find_common_type(array_types, scalar_types)：根据标准强制规则确定常见类型
杂项
typename(char)：返回给定数据类型代码的描述.
sctype2char(sctype)：返回标量dtype的字符串表示形式.
mintypecode(typechars[, typeset, default])：返回最小尺寸类型的字符，可以安全地转换给定类型.
可选Scipy加速例程（numpy.dual）
Scipy可能加速的函数的别名。
可以构建Scipy以使用加速或其他改进的库来进行FFT，线性代数和特殊函数。此模块允许开发人员在scipy可用时透明地支持这些加速功能，但仍支持仅安装了NumPy的用户
线性代数
cholesky(a)：Cholesky分解.
det(a)：计算数组的行列式.
eig(a)：计算正方形阵列的特征值和右特征向量.
eigh(a[, UPLO])：返回Hermitian或对称矩阵的特征值和特征向量
eigvals(a)：计算一般矩阵的特征值.
eigvalsh(a[, UPLO])：计算Hermitian或实对称矩阵的特征值.
inv(a)：计算矩阵的（乘法）逆.
lstsq(a, b[, rcond])：将最小二乘解返回到线性矩阵方程
norm(x[, ord, axis, keepdims])：矩阵或矢量规范.
pinv(a[, rcond])：计算矩阵的（Moore-Penrose）伪逆.
solve(a, b)：求解线性矩阵方程或线性标量方程组.
svd(a[, full_matrices, compute_uv])：奇异值分解.
FFT
fft(a[, n, axis, norm])：计算一维离散傅立叶变换.
fft2(a[, s, axes, norm])：计算二维离散傅立叶变换
fftn(a[, s, axes, norm])：计算N维离散傅立叶变换.
ifft(a[, n, axis, norm])：计算一维离散傅里叶逆变换.
ifft2(a[, s, axes, norm])：计算二维逆离散傅立叶变换.
ifftn(a[, s, axes, norm])：计算N维逆离散傅立叶变换.
Other
i0(x)：修改了第一类贝塞尔函数，阶数为0具有自动域（numpy.emath）的数学函数
注意
numpy.emath是导入numpy.lib.scimath后可用的首选别名numpy
包装器用于更加用户友好地调用某些数学函数，这些函数的输出数据类型与输入的某些域中的输入数据类型不同。
例如，对于像log分支切割这样的函数，此模块中的版本在复杂平面中提供数学上有效的答案：
>>> import math
>>> from numpy.lib import scimath
>>> scimath.log(-math.exp(1)) == (1+1j*math.pi)
True
类似地，正确处理sqrt其他基本对数power和trig函数。有关具体示例，请参阅各自的文档字符串.
浮点错误处理
设置和获取错误处理
seterr([all, divide, over, under, invalid])：设置如何处理浮点错误.
geterr()：获取当前处理浮点错误的方法
seterrcall(func)：设置浮点错误回调函数或日志对象.
geterrcall()：返回用于浮点错误的当前回调函数.
errstate(**kwargs)：用于浮点错误处理的上下文管理器.
内部功能
seterrobj(errobj)：设置定义浮点错误处理的对象.
geterrobj()：返回定义浮点错误处理的当前对象离散傅立叶变换（numpy.fft）
标准 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维逆离散傅立叶变换.
实际 FFTs
rfft(a[, n, axis, norm])：计算一维离散傅立叶变换用于实际输入.
irfft(a[, n, axis, norm])：计算实际输入的n点DFT的倒数.
rfft2(a[, s, axes, norm])：计算实数组的二维FFT.
irfft2(a[, s, axes, norm])：计算实数组的二维逆FFT.
rfftn(a[, s, axes, norm])：为实际输入计算N维离散傅立叶变换
irfftn(a[, s, axes, norm])：计算实际输入的N维FFT的逆
Hermitian FFTs
hfft(a[, n, axis, norm])：计算具有厄米对称性的信号的FFT，即实际频谱.
ihfft(a[, n, axis, norm])：计算具有厄米对称性的信号的逆FFT.
Helper routines
fftfreq(n[, d]) ：返回离散傅立叶变换采样频率 .rfftfreq(n[, d])：返回离散傅里叶变换采样频率（用于rfft，irfft）
fftshift(x[, axes])：将零频率分量移到频谱中心
ifftshift(x[, axes])：逆的fftshift
财务职能
简单的财务功能
fv(rate, nper, pmt, pv[, when])：计算未来价值.
pv(rate, nper, pmt[, fv, when])：计算现值.
npv(rate, values)：返回现金流序列的NPV（净现值）.
pmt(rate, nper, pv[, fv, when])：计算贷款本金和利息的付款.
ppmt(rate, per, nper, pv[, fv, when])：计算贷款本金的付款.
ipmt(rate, per, nper, pv[, fv, when])：计算付款的利息部分.
irr(values)：返回内部收益率（IRR）.
mirr(values, finance_rate, reinvest_rate)：修改内部收益率.
nper(rate, pmt, pv[, fv, when])：计算定期付款的数量.
rate(nper, pmt, pv, fv[, when, guess, tol, …])：计算每个期间的利率
功能编程
apply_along_axis(func1d, axis, arr, *args, …)：将函数应用于沿给定轴的1-D切片.
apply_over_axes(func, a, axes)：在多个轴上重复应用功能.
vectorize(pyfunc[, otypes, doc, excluded, …])：广义函数类.
frompyfunc(func, nin, nout)：采用任意Python函数并返回NumPy ufunc.
piecewise(x, condlist, funclist, *args, **kw)：评估分段定义的函数.
NumPy特定的帮助功能
Reading help
info([object, maxwidth, output, toplevel])：获取函数，类或模块的帮助信息.
source(object[, output]) ：将文件打印或写入NumPy对象的源代码 .索引
生成索引数组
c_：将切片对象转换为沿第二轴的连接.
r_：将切片对象转换为沿第一轴的连接.
s_：为数组构建索引元组的更好方法.
nonzero(a)：返回非零元素的索引.
where(condition, [x, y])：返回元素，可以是x或y，具体取决于条件.
indices(dimensions[, dtype])：返回表示网格索引的数组.
ix_(*args)：从多个序列构造一个开放网格.
ogrid：nd_grid实例，它返回一个开放的多维“meshgrid”.
ravel_multi_index(multi_index, dims[, mode, …])：将索引数组的元组转换为平面索引数组，将边界模式应用于多索引.
unravel_index(indices, dims[, order])：将平面索引或平面索引数组转换为坐标数组的元组.
diag_indices(n[, ndim])：返回索引以访问数组的主对角线.
diag_indices_from(arr)：返回索引以访问n维数组的主对角线.
mask_indices(n, mask_func[, k])：给定掩蔽函数，将索引返回到访问（n，n）数组.
tril_indices(n[, k, m])：返回（n，m）数组的下三角形的索引.
tril_indices_from(arr[, k])：返回arr的下三角形的索引.
triu_indices(n[, k, m])：返回（n，m）数组的上三角形的索引.
triu_indices_from(arr[, k])：返回arr上三角的索引.
类似索引的操作
take(a, indices[, axis, out, mode])：从轴上获取数组中的元素
take_along_axis(arr, indices, axis)：通过匹配1d索引和数据切片从输入数组中获取值.
choose(a, choices[, out, mode])：从索引数组和一组数组构造一个数组以供选择.
compress(condition, a[, axis, out])：沿给定轴返回数组的选定切片.
diag(v[, k])：提取对角线或构造对角线阵列.
diagonal(a[, offset, axis1, axis2])：返回指定的对角线.
select(condlist, choicelist[, default])：返回从选择列表中的元素绘制的数组，具体取决于条件.
lib.stride_tricks.as_strided(x[, shape, …])：使用给定的形状和步幅创建数组视图.
将数据插入数组
place(arr, mask, vals)：根据条件和输入值更改数组的元素.
put(a, ind, v[, mode])：用给定值替换数组的指定元素.
put_along_axis(arr, indices, values, axis)：通过匹配1d索引和数据切片将值放入目标数组.
putmask(a, mask, values)：根据条件和输入值更改数组的元素.
fill_diagonal(a, val[, wrap])：填充任何维度的给定数组的主对角线.
迭代数组
nditer：用于迭代数组的高效多维迭代器对象.
ndenumerate(arr)：多维索引迭代器.
ndindex(*shape)：用于索引数组的N维迭代器对象.
nested_iters：创建nditers以用于嵌套循环
flatiter：平面迭代器对象迭代数组
lib.Arrayterator(var[, buf_size])：用于大型数组的缓冲迭代器.
输入和输出
NumPy二进制文件(NPY, NPZ)
load(file[, mmap_mode, allow_pickle, …])：从.npy,.npz或pickle文件中加载数组、对象和pickled.
save(file, arr[, allow_pickle, fix_imports])：将数组保存为NumPy .npy格式的二进制文件.
savez(file, *args, **kwds)：将多个数组以未压缩.npz格式保存到单个文件中.
savez_compressed(file, *args, **kwds)：将多个数组以压缩.npz格式保存到单个文件中.
文本文件
loadtxt(fname[, dtype, comments, delimiter, …])：从文本文件加载数据.
savetxt(fname, X[, fmt, delimiter, newline, …])：将数组保存到文本文件.
genfromtxt(fname[, dtype, comments, …])：从文本文件加载数据，并按指定处理缺失值.
fromregex(file, regexp, dtype[, encoding])：使用正则表达式解析从文本文件构造数组.
fromstring(string[, dtype, count, sep])：从字符串中的文本数据初始化的新1-D数组.
ndarray.tofile(fid[, sep, format])：将数组作为文本或二进制写入文件（默认）.
ndarray.tolist()：将数组作为（可能是嵌套的）列表返回
原始二进制文件
fromfile(file[, dtype, count, sep])：根据文本或二进制文件中的数据构造数组.
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：为存储在磁盘上的二进制文件中的数组创建内存映射.
文本格式化选项
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.linalg）
矩阵和矢量积
dot(a, b[, out])：两个数组的乘积.
linalg.multi_dot(arrays)：在单个函数调用中计算两个或多个数组的点积，同时自动选择最快的求值顺序.
vdot(a, b)：返回两个向量的点积.
inner(a, b)：两个数组的内积.
outer(a, b[, out])：计算两个向量的外积.
matmul(a, b[, out])：两个数组的矩阵乘积.
tensordot(a, b[, axes])：对于数组> = 1-D，沿指定轴计算张量点积.
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])：返回Hermitian或对称矩阵的特征值和特征向量.
linalg.eigvals(a)：计算一般矩阵的特征值.
linalg.eigvalsh(a[, UPLO])：计算Hermitian或实对称矩阵的特征值.
规范和其他数字
linalg.norm(x[, ord, axis, keepdims])：矩阵或矢量规范.
linalg.cond(x[, p])：计算矩阵的条件数.
linalg.det(a)：计算数组的行列式.
linalg.matrix_rank(M[, tol, hermitian])：使用SVD方法返回阵列的矩阵等级.
linalg.slogdet(a)：计算数组行列式的符号和（自然）对数.
trace(a[, offset, axis1, axis2, dtype, out])：返回数组对角线的总和.
求解方程和反转矩阵
linalg.solve(a, b)：求解线性矩阵方程或线性标量方程组.
linalg.tensorsolve(a, b[, axes])：求解x 的张量方程。a x = b.
linalg.lstsq(a, b[, rcond])：将最小二乘解返回到线性矩阵方程.
linalg.inv(a)：计算矩阵的（乘法）逆.
linalg.pinv(a[, rcond])：计算矩阵的（Moore-Penrose）伪逆.
linalg.tensorinv(a[, ind])：计算N维数组的“逆”.
Exceptions
linalg.LinAlgError ：由linalg函数引发的通用Python异常派生对象逻辑功能
真值测试
all(a[, axis, out, keepdims])：测试沿给定轴的所有数组元素是否评估为True.
any(a[, axis, out, keepdims])：测试沿给定轴的任何数组元素是否为True.
数组内容
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])：测试元素为负无穷大，返回结果为bool数组.
isposinf(x[, out])：测试元素为正无穷大，返回结果为bool数组.
数组类型测试
iscomplex(x)：返回一个bool数组，如果input元素很复杂，则返回True.
iscomplexobj(x)：检查复杂类型或复数数组.
isfortran(a)：如果数组是Fortran连续但不是 C连续，则返回True.
isreal(x)：返回一个bool数组，如果输入元素是实数，则返回True.
isrealobj(x)：如果x是非复数类型或复数数组，则返回True.
isscalar(num)：如果num的类型是标量类型，则返回True .
逻辑运算
logical_and(x1, x2, /[, out, where, …])：计算x1和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)：如果两个数组具有相同的形状和元素，则为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
less_equal(x1, x2, /[, out, where, casting, …])：以元素方式返回（x1 =
equal(x1, x2, /[, out, where, casting, …])：以元素方式返回（x1 == x2）.
not_equal(x1, x2, /[, out, where, casting, …])：以元素方式返回（x1！= x2）.
掩码数组操作
常数
ma.MaskType：alias of bool_
创建
从现有数据
ma.masked_array：alias of MaskedArray
ma.array(data[, dtype, copy, order, mask, …])：具有可能屏蔽值的数组类.
ma.copy(self, *args, **params) a.copy(order=)：返回数组的副本.
ma.frombuffer(buffer[, dtype, count, offset])：将缓冲区解释为一维数组.
ma.fromfunction(function, shape, **kwargs)：通过在每个坐标上执行函数来构造数组.
ma.MaskedArray.copy([order])：返回数组的副本.
Ones and zeros
ma.empty(shape[, dtype, order])：返回给定形状和类型的新数组，而不初始化条目.
ma.empty_like(prototype[, dtype, order, subok])：返回一个与给定数组具有相同形状和类型的新数组.
ma.masked_all(shape[, dtype])：空蒙面数组，所有元素都被屏蔽.
ma.masked_all_like(arr)：具有现有数组属性的空掩码数组.
ma.ones(shape[, dtype, order])：返回一个给定形状和类型的新数组，用一个填充.
ma.zeros(shape[, dtype, order])：返回给定形状和类型的新数组，用零填充.
检查数组
ma.all(self[, axis, out, keepdims])：如果所有元素都计算为True，则返回True.
ma.any(self[, axis, out, keepdims])：如果任何元素，则返回true 一个评估为True.
ma.count(self[, axis, keepdims])：沿给定轴计算数组的非掩码元素.
ma.count_masked(arr[, axis])：计算沿给定轴的遮罩元素数.
ma.getmask(a)：返回蒙版数组或nomask的掩码.
ma.getmaskarray(arr)：返回掩码数组的掩码，或False的完整布尔数组.
ma.getdata(a[, subok])：将掩码数组的数据作为ndarray返回.
ma.nonzero(self)：返回非零的未屏蔽元素的索引.
ma.shape(obj)：返回数组的形状.
ma.size(obj[, axis])：返回给定轴上的元素数.
ma.is_masked(x)：确定输入是否具有掩码值.
ma.is_mask(m)：如果m是有效的标准掩码，则返回True.
ma.MaskedArray.data：返回当前数据，作为原始基础数据的视图.
ma.MaskedArray.mask：Mask
ma.MaskedArray.recordmask：返回记录的掩码.
ma.MaskedArray.all([axis, out, keepdims])：如果所有元素都计算为True，则返回True.
ma.MaskedArray.any([axis, out, keepdims])：如果任何元素，则返回true 一个评估为True.
ma.MaskedArray.count([axis, keepdims])：沿给定轴计算数组的非掩码元素.
ma.MaskedArray.nonzero()：返回非零的未屏蔽元素的索引.
ma.shape(obj)：返回数组的形状.
ma.size(obj[, axis])：返回给定轴上的元素数.
Manipulating a MaskedArray
改变形状
ma.ravel(self[, order])：作为视图返回self的1D版本.
ma.reshape(a, new_shape[, order])：返回包含具有新形状的相同数据的数组.
ma.resize(x, new_shape)：返回具有指定大小和形状的新蒙版数组.
ma.MaskedArray.flatten([order])：将折叠的数组的副本返回到一个维度.
ma.MaskedArray.ravel([order])：作为视图返回self的1D版本.
ma.MaskedArray.reshape(*s, **kwargs)：为数组赋予新形状而不更改其数据.
ma.MaskedArray.resize(newshape[, refcheck, …])
修改轴
ma.swapaxes(self, *args, …)：返回数组的视图，其中axis1和axis2互换.
ma.transpose(a[, axes])：置换数组的维度.
ma.MaskedArray.swapaxes(axis1, axis2)：返回数组的视图，其中axis1和axis2互换.
ma.MaskedArray.transpose(*axes)：返回轴转置的数组视图.
改变维数
ma.atleast_1d(*arys)：将输入转换为至少具有一个维度的数组.
ma.atleast_2d(*arys)：将输入视为具有至少两个维度的数组.
ma.atleast_3d(*arys)：将输入视为具有至少三维的数组.
ma.expand_dims(x, axis)：展开数组的形状.
ma.squeeze(a[, axis])：从数组的形状中删除一维条目.
ma.MaskedArray.squeeze([axis])：从形状除去单维输入一个.
ma.stack(arrays[, axis, out])：沿新轴加入一系列数组.
ma.column_stack(tup)：将1-D阵列作为列堆叠成2-D阵列.
ma.concatenate(arrays[, axis])：沿给定轴连接一系列数组.
ma.dstack(tup)：按顺序深度堆叠阵列（沿第三轴）.
ma.hstack(tup)：按顺序堆叠数组（列式）.
ma.hsplit(ary, indices_or_sections)：将数组水平拆分为多个子数组（按列）.
ma.mr_：将切片对象转换为沿第一轴的连接.
ma.row_stack(tup)：垂直堆叠数组（行方式）.
ma.vstack(tup)：垂直堆叠数组（行方式）.
连续数组
ma.stack(arrays[, axis, out])：沿新轴加入一系列数组.
ma.column_stack(tup)：将1-D阵列作为列堆叠成2-D阵列.
ma.concatenate(arrays[, axis])：沿给定轴连接一系列数组.
ma.append(a, b[, axis])：将值附加到数组的末尾.
ma.dstack(tup)：按顺序深度堆叠阵列（沿第三轴）.
ma.hstack(tup)：按顺序堆叠数组（列式）.
ma.vstack(tup)：垂直堆叠数组（行方式）.
掩码操作
创建掩码
ma.make_mask(m[, copy, shrink, dtype])：从数组创建布尔掩码.
ma.make_mask_none(newshape[, dtype])：返回给定形状的布尔掩码，填充False.
ma.mask_or(m1, m2[, copy, shrink])：将两个面罩与logical_or操作员组合在一起.
ma.make_mask_descr(ndtype)：从给定的dtype构造一个dtype描述列表.
访问掩码
ma.getmask(a)：返回蒙版数组或nomask的掩码.
ma.getmaskarray(arr)：返回掩码数组的掩码，或False的完整布尔数组.
ma.masked_array.mask：Mask
查找屏蔽数据
ma.flatnotmasked_contiguous(a)：沿给定轴在掩码数组中查找连续的未屏蔽数据.
ma.flatnotmasked_edges(a)：查找第一个和最后一个未屏蔽值的索引.
ma.notmasked_contiguous(a[, axis])：沿给定轴在掩码数组中查找连续的未屏蔽数据.
ma.notmasked_edges(a[, axis])：查找沿轴的第一个和最后一个未屏蔽值的索引.
ma.clump_masked(a)：返回与1-D数组的掩码块对应的切片列表.
ma.clump_unmasked(a)：返回与1-D阵列的未掩蔽块相对应的切片列表.
修改掩码
ma.mask_cols(a[, axis])：屏蔽包含屏蔽值的2D数组的列.
ma.mask_or(m1, m2[, copy, shrink])：将两个面罩与logical_or操作员组合在一起.
ma.mask_rowcols(a[, axis])：屏蔽包含屏蔽值的2D数组的行和/或列.
ma.mask_rows(a[, axis])：屏蔽包含屏蔽值的2D数组的行.
ma.harden_mask(self)：强迫面膜变硬.
ma.soften_mask(self)：强迫面膜变软.
ma.MaskedArray.harden_mask()：强迫面膜变硬.
ma.MaskedArray.soften_mask()：强迫面膜变软.
ma.MaskedArray.shrink_mask()：尽可能将遮罩减少到nomask.
ma.MaskedArray.unshare_mask()：复制掩码并将sharedmask标志设置为False.
转换操作
> to a masked array
ma.asarray(a[, dtype, order])：将输入转换为给定数据类型的掩码数组.
ma.asanyarray(a[, dtype])：将输入转换为掩码数组，保留子类.
ma.fix_invalid(a[, mask, copy, fill_value])：返回带有无效数据的输入，并用填充值替换.
ma.masked_equal(x, value[, copy])：屏蔽一个等于给定值的数组.
ma.masked_greater(x, value[, copy])：屏蔽大于给定值的数组.
ma.masked_greater_equal(x, value[, copy])：屏蔽大于或等于给定值的数组.
ma.masked_inside(x, v1, v2[, copy])：在给定间隔内屏蔽数组.
ma.masked_invalid(a[, copy])：屏蔽出现无效值的数组（NaN或infs）.
ma.masked_less(x, value[, copy])：屏蔽小于给定值的数组.
ma.masked_less_equal(x, value[, copy])：屏蔽小于或等于给定值的数组.
ma.masked_not_equal(x, value[, copy])：