NumPy 基础：函数总结
文章目录
-
- 1 NumPy - 数组生成函数
- 2 NumPy - 数组的一些基本属性
- 3 NumPy - 修改数组的形状
- 4 NumPy - 数组元素的添加/删除
- 5 NumPy - 数组的连接/分割函数
- 6 NumPy - 通用函数
- 7 NumPy - 字符串函数
- 8 NumPy - 排序函数
- 9 NumPy - 统计函数
- 10 NumPy - 线性代数
- 11 NumPy - 伪随机数生成函数
最近重新学习发现，NumPy 中有很多很多的函数，以下根据个人和结合官网对函数的理解，整理了一些关于NumPy 中常用的一些基础函数。本文仅供参考，如有错误请予以批评指正，如需转载请标记出处。
1 NumPy - 数组生成函数
Numpy 中最常规的就是利用array函数来生成一个新的包含传递数据的NumPy 数组。array函数，参数如下：
import numpy as np
array1=np.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
| 参数 | 描述 |
|---|---|
object |
传入的数据，可以使列表（list）、集合（set）、元组（tuple）、字符串（str）等 |
dtype |
数组的所需数据类型，默认为空，可选,如：dtype=np.float64等 |
copy |
对象是否需要复制，默认为True |
oder |
C(按行)、F(按列)、A(任意，默认) |
subok |
默认情况下，返回的数组被强制为基类数组。 如果为True，则返回子类 |
ndmin |
指定返回数组的维数,如ndmin=2。 |
除了array函数以外，还有以下一些生成函数，只是参数或多或少发生改变：
| 生成函数 | 描述 |
|---|---|
array |
传入的数据x(可以是列表、集合、元组、字符串等)转换为ndarray，具体参数如上表 |
asarray |
array和asarray作用相同，但是主要区别就是当数据源是ndarray时，array仍然会copy出一个副本，占用新的内存，但asarray不会。numpy.asarray(a, dtype=None, order=None) |
empty |
它创建指定形状和dtype的未初始化数组。 它使用以下构造函数：numpy.empty(shape, dtype = float, order = 'C') |
zeros |
返回特定大小，以 0 填充的新数组: numpy.zeros(shape, dtype = float, order = 'C') |
ones |
返回特定大小，以 1 填充的新数组: numpy.ones(shape, dtype = None, order = 'C') |
eye |
创建一个N * N的单位矩阵（对角线为1，其余为0）: numpy.eye(N, M=None, k=0, dtype= |
arange |
这个函数返回ndarray对象，包含给定范围内的等间隔值:numpy.arange(start, stop, step, dtype) |
linspace |
此函数类似于arange()函数。 在此函数中，指定了范围之间的均匀间隔数量，而不是步长。 此函数的用法如下：numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) |
logspace |
此函数返回一个ndarray对象，其中包含在对数刻度上均匀分布的数字。 刻度的开始和结束端点是某个底数的幂，通常为 10:numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None) |
*注：
shape空数组的形状，整数或整数元组；dtype所需的输出数组类型，可选；order'C’为按行的 C 风格数组，'F’为按列的order'C’为按行的 C 风格数组，'F’为按列的Fortran 风格数组；start序列的起始值；stop序列的终止值，如果endpoint为true，该值包含于序列中；num要生成的等间隔样例数量，默认为50；retstep如果为true，返回样例，以及连续数字之间的步长；base对数空间的底数，默认为10*
例如：
import numpy as np
ndarray = np.empty((4,4))
print("4x4主对角为1的empty矩阵")
print(ndarray)
ndarray1 = np.ones((4,4))
print("4x4元素全为1矩阵")
print(ndarray1)
ndarray2 = np.zeros((4,4))
print("4x4元素全为0矩阵")
print(ndarray2)
ndarray3 = np.eye(4)
print("4x4单位矩阵")
print(ndarray3)
ndarray4 = np.linspace(0,100,num=11)
print("0-100，生成11个数")
print(ndarray4)
ndarray5 = np.logspace(0,100,num=11)
print("0-100,生成11个对数")
print(ndarray5)
输出：
4x4主对角为1的empty矩阵
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]
4x4元素全为1矩阵
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
4x4元素全为0矩阵
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
4x4单位矩阵
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]
0-100，生成11个数
[ 0. 10. 20. 30. 40. 50. 60. 70. 80. 90. 100.]
0-100,生成11个对数
[1.e+000 1.e+010 1.e+020 1.e+030 1.e+040 1.e+050 1.e+060 1.e+070 1.e+080
1.e+090 1.e+100]
2 NumPy - 数组的一些基本属性
NumPy 数组的维数称为秩（rank），秩就是轴的数量，即数组的维度，一维数组的秩为 1，二维数组的秩为 2，以此类推。
import numpy as np
#生成一个5*5的单位矩阵
ndarray = np.ones((5,5))
#输出数组 ndarray 的维度
print(ndarray.shape)
#输出数组 ndarray 的总个数
print(ndarray.size)
#输出数组 ndarray 中每个元素的大小
print(ndarray.itemsize)
输出结果为：
(5, 5)
25
8
NumPy 的数组中比较重要 ndarray 对象属性有：
| 函数 | 描述 |
|---|---|
ndarray.ndim |
秩，即轴的数量或维度的数量 |
ndarray.shape |
数组的维度，对于矩阵，n 行 m 列 |
ndarray.size |
数组元素的总个数，相当于 .shape 中 n*m 的值 |
ndarray.dtype |
ndarray 对象的元素类型 |
ndarray.itemsize |
ndarray 对象中每个元素的大小，以字节为单位 |
ndarray.flags |
ndarray 对象的内存信息 |
ndarray.real |
ndarray元素的实部 |
ndarray.imag |
ndarray 元素的虚部 |
ndarray.data |
包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。 |
3 NumPy - 修改数组的形状
| 函数 | 描述 |
|---|---|
ndarray.reshape |
在不改变数据的条件下修改形状，格式如下： ndarray.reshape(shape, order='C')或者numpy.reshape(arr, newshape, order='C') |
ndarray.flat |
将数组转换为1-D的迭代器ndarray.flat |
ndarray.flatten |
将多维数组将为一维数组，返回一份数组拷贝，对拷贝所做的修改不会影响原始数组ndarray.flatten(order='C') |
numpy.ravel |
将多维数组将为一维数组，返回的是视图修改会影响原始数组，numpy.ravel(a, order='C') |
例如：
import numpy as np
ndarray = np.ones((4,4))
print(ndarray)
print(ndarray.shape)
ndarray1 = ndarray.reshape(2,8)
print(ndarray1)
print(ndarray1.shape)
print(ndarray.flatten())
输出结果为：
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
(4, 4)
[[1. 1. 1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1. 1. 1.]]
(2, 8)
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
4 NumPy - 数组元素的添加/删除
| 函数 | 描述 |
|---|---|
resize |
返回指定形状的新数组,如果新数组大小大于原始大小，则包含原始数组中的元素的副本。：numpy.resize(arr, shape) |
append |
将值添加到数组末尾,输入数组的维度必须匹配否则将生成ValueError。numpy.append(arr, values, axis=None) |
insert |
沿指定轴将值插入到指定下标之前。numpy.insert(arr, obj, values, axis) |
delete |
删掉某个轴的子数组，并返回删除后的新数组。Numpy.delete(arr, obj, axis) |
unique |
查找数组内的唯一元素,函数用于去除数组中的重复元素：numpy.unique(arr, return_index, return_inverse, return_counts) |
- 注：axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）
例如：
import numpy as np
ndarray2 = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(ndarray2)
print("----------------")
ndarray3 = np.resize(ndarray2,(4,3))
print(ndarray3)
print("----------------")
ndarray4 = np.append(ndarray2,[0,0,0])
ndarray5 = np.append(ndarray2,[[0,0,0]],axis=0)
print(ndarray4)
print("----------------")
print(ndarray5)
ndarray6 = np.delete(ndarray2,2,axis=0)
print("----------------")
print(ndarray6)
输出：
[[1 2 3]
[4 5 6]
[7 8 9]]
----------------
[[1 2 3]
[4 5 6]
[7 8 9]
[1 2 3]]
----------------
[1 2 3 4 5 6 7 8 9 0 0 0]
----------------
[[1 2 3]
[4 5 6]
[7 8 9]
[0 0 0]]
----------------
[[1 2 3]
[4 5 6]]
5 NumPy - 数组的连接/分割函数
NumPy 中的数组连接和分割函数，Python 和本身并无太大差别，以下简单示例。
| 函数 | 描述 |
|---|---|
concatenate |
函数用于沿指定轴连接相同形状的两个或多个数组。 该函数接受以下参数：numpy.concatenate((a1, a2, ...), axis=0) |
stack |
此函数将相同形状的数组序列，沿指定轴来堆叠。numpy.stack(arrays, axis=0) |
hstack |
stack函数的变体，通过堆叠来生成水平的单个数组。 |
vstack |
stack函数的变体，通过堆叠来生成竖直的单个数组。 |
split |
该函数沿特定的轴将数组分割为子数组。函数接受三个参数：numpy.split(ary, indices_or_sections, axis=0) |
hsplit |
hsplit是split()函数的特例，其中轴为 1 表示水平分割，无论输入数组的维度是什么。numpy.hsplit(ary, indices_or_sections) |
vsplit |
vsplit是split()函数的特例，其中轴为 0 表示竖直分割，无论输入数组的维度是什么。numpy.vsplit(ary, indices_or_sections) |
*注：
indices_or_sections：可以是整数，表明要从输入数组创建的，等大小的子数组的数量。 如果此参数是一维数组，则其元素表明要创建新子数组的点。
例如：
import numpy as np
ndarray1 = np.ones((4,4))
print("4x4元素全为1矩阵")
print(ndarray1)
ndarray2 = np.zeros((4,4))
print("4x4元素全为0矩阵")
print(ndarray2)
ndarray3 = np.eye(4)
print("4x4单位矩阵")
print(ndarray3)
ndarray_concatenate = np.concatenate((ndarray1,ndarray2),axis=0)
print("沿指定轴连接")
print(ndarray_concatenate)
ndarray_stack = np.stack((ndarray1,ndarray2),axis=0)
print("沿指定轴堆叠")
print(ndarray_stack)
print("堆叠后的维度是不同的")
print(ndarray_stack.shape)
ndarray_split = np.split(ndarray_concatenate,indices_or_sections=8, axis=0)
print("沿特定的轴将数组分割为子数组")
print(ndarray_split)
输出：
4x4元素全为1矩阵
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
4x4元素全为0矩阵
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
4x4单位矩阵
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]
沿指定轴连接
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
沿指定轴堆叠
[[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]]
堆叠后的维度是不同的
(2, 4, 4)
沿特定的轴将数组分割为子数组
[array([[1., 1., 1., 1.]]), array([[1., 1., 1., 1.]]), array([[1., 1., 1., 1.]]), array([[1., 1., 1., 1.]]), array([[0., 0., 0., 0.]]), array([[0., 0., 0., 0.]]), array([[0., 0., 0., 0.]]), array([[0., 0., 0., 0.]])]
6 NumPy - 通用函数
通用函数（即ufunc）是一种对ndarray中的数据执行元素级运算的函数。你可以将其看做简单函数（接受一个或多个标量值，并产生一个或多个标量值）的矢量化包装器。
一元通用函数
一元通用函数只接受一个数组，并返回一个结果数组。
| 函数 | 描述 |
|---|---|
abs(x)、fabs(x) |
计算数组各元素的绝对值 |
sqrt(x) |
计算数组各元素的平方根 |
square(x) |
计算数组各元素的平方 |
exp(x) |
计算各元素的自然指数值e^x |
sign(x) |
计算各元素的符号值：1（正）、0（0）、-1（负） |
ceil(x) |
计算大于等于给定值的最小整数值 |
floor(x) |
计算大于等于给定值的最大整数值 |
rint(x) |
四舍五入到最近的整数，保留dtype |
modf(x) |
将数组的小数和整数部分以两个独立的数组方式返回 |
log(x)、log10(x)、log2(x) |
计算自然对数、底为10的log、底为2的log |
isnan(x) |
返回一个判断是否是NaN的bool型数组 |
isfinite(x) |
返回一个判断是否是无穷的bool型数组 |
isinf(x) |
计算大于等于给定值的最小整数值 |
cos、cosh、sin、sinh、tan、tanh |
普通型和双曲型三角函数 |
arccos、arccosh、arcsin、arcsinh、arctan、arctanh |
反三角函数和双曲型反三角函数 |
例如：
import numpy as np
ndarray = np.array([[1,2,3],[4,5,6],[7,8,9]])
print("生成一个3x3的矩阵：")
print(ndarray)
ndarray_sqrt = np.sqrt(ndarray)
print("平方根：")
print(ndarray_sqrt)
ndarray_exp = np.exp(ndarray)
print("指数：")
print(ndarray_exp)
ndarray_log = np.log10(ndarray)
print("10为底的对数：")
print(ndarray_log)
ndarray_tan = np.tan(ndarray)
print("正切：")
print(ndarray_tan)
输出：
生成一个3x3的矩阵：
[[1 2 3]
[4 5 6]
[7 8 9]]
平方根：
[[1. 1.41421356 1.73205081]
[2. 2.23606798 2.44948974]
[2.64575131 2.82842712 3. ]]
指数：
[[2.71828183e+00 7.38905610e+00 2.00855369e+01]
[5.45981500e+01 1.48413159e+02 4.03428793e+02]
[1.09663316e+03 2.98095799e+03 8.10308393e+03]]
10为底的对数：
[[0. 0.30103 0.47712125]
[0.60205999 0.69897 0.77815125]
[0.84509804 0.90308999 0.95424251]]
正切：
[[ 1.55740772 -2.18503986 -0.14254654]
[ 1.15782128 -3.38051501 -0.29100619]
[ 0.87144798 -6.79971146 -0.45231566]]
二元通用函数
二元通用函数接受两个数组，并返回一个结果数组。
| 函数 | 描述 |
|---|---|
add(x,y) |
数组的对应元素相加x+y |
subtract(x,y) |
数组的对应元素相减x-y |
multiply(x,y) |
数组的对应元素相乘x*y |
divide(x,y) |
数组的对应元素相除x/y |
floor_divide(x,y) |
数组的对应元素整除（舍去余数） |
power(x,y) |
次方（以x为准，y的次方） |
mod(x,y) |
求模（取余数） |
maximum(x,y),minimun(x,y) |
求最大值,最小值 |
fmax(x,y),fmin(x,y) |
求最大值,最小值（忽略NaN） |
copysign(x,y) |
修改符号，将x的符号值改为y的符号值 |
greater、greater_equal、less、less_equal、equal、not_equal |
同>、>=、<、<=、==、!= |
7 NumPy - 字符串函数
以下函数用于对dtype为numpy.string_或numpy.unicode_的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。
| 函数 | 描述 |
|---|---|
numpy.char.add() |
函数执行按元素的字符串连接。 |
numpy.char.multiply() |
返回按元素多重连接后的字符串 |
numpy.char.center() |
此函数返回所需宽度的数组，以便输入字符串位于中心，并使用fillchar在左侧和右侧进行填充。 |
umpy.char.capitalize() |
函数返回字符串的副本，其中第一个字母大写 |
numpy.char.title() |
返回输入字符串的按元素标题转换版本，其中每个单词的首字母都大写。 |
numpy.char.lower() |
函数返回一个数组，其元素转换为小写。它对每个元素调用str.lower。 |
numpy.char.upper() |
函数返回一个数组，其元素转换为大写。它对每个元素调用str.upper。 |
numpy.char.split() |
函数返回输入字符串中的单词列表。 默认情况下，空格用作分隔符。 否则，指定的分隔符字符用于分割字符串（sep）。 |
numpy.char.splitlines() |
函数返回数组中元素的单词列表，以换行符分割。 |
numpy.char.strip() |
函数返回数组的副本，其中元素移除了开头或结尾处的特定字符。 |
numpy.char.join() |
这个函数返回一个字符串，其中单个字符由特定的分隔符连接。 |
numpy.char.replace() |
函数返回字符串副本，其中所有字符序列的出现位置都被另一个给定的字符序列取代。 |
numpy.char.decode() |
这个函数在给定的字符串中使用特定编码调用str.decode()。 |
numpy.char.encode() |
函数对数组中的每个元素调用str.encode函数。 默认编码是utf_8，可以使用标准 Python 库中的编解码器。 |
8 NumPy - 排序函数
| 函数 | 描述 |
|---|---|
sort |
sort()函数返回一个新数组，不改变原始数组(类似于python中自带的sorted函数，但numpy中没有sorted函数，参数也不一样)。 它有以下参数：numpy.sort(a, axis=1, kind='quicksort', order=None) |
argsort |
函数对输入数组沿给定轴执行间接排序。numpy.argsort(a, axis=1, kind='quicksort', order=None) |
lexsort |
函数使用键序列执行间接排序。numpy.argsort(a, axis=-1, kind='quicksort', order=None) |
9 NumPy - 统计函数
NumPy 有很多有用的统计函数，用于从数组中给定的元素中查找最小，最大，百分标准差和方差等。
| 函数 | 描述 |
|---|---|
amin、amax |
这些函数从给定数组中的元素沿指定轴返回最小值和最大值。amax(a, axis=None） |
sum |
求和。sum(a, axis=None, dtype=None） |
cumsum |
从0开始元素累积和。cumsum(a, axis=None, dtype=None） |
cumprod |
从1开始元素累积积 cumprod(a, axis=None, dtype=None) |
ptp |
函数返回沿轴的值的范围（最大值 - 最小值）。 ptp(a, axis=None） |
percentile |
百分位数是统计中使用的度量，表示小于这个值得观察值占某个百分比。percentile(a, q, axis=None) |
median |
中位数。median(a, axis=None） |
mean |
函数返回数组中元素的算术平均值。mean(a, axis=None, dtype=None） |
average |
函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。verage(a, axis=None, weights=None, returned=False) |
std |
标准差。std(a, axis=None, dtype=None) |
var |
方差。var(a, axis=None, dtype=None) |
10 NumPy - 线性代数
NumPy 包包含numpy.linalg模块，提供线性代数所需的所有功能。 此模块中的一些重要功能如下表所述。
| 函数 | 描述 |
|---|---|
numpy.linalg.det() |
计算矩阵的行列式 |
numpy.linalg.eig() |
计算方阵的特征值和特征向量 |
numpy.linalg.inv() |
计算方阵的逆,它乘以原始矩阵，则得到单位矩阵。 |
numpy.linalg.pinv() |
计算方阵的Moore-Penrose伪逆 |
numpy.linalg.qr() |
计算QR分解 |
numpy.linalg.svd() |
算奇异值分解(SVD) |
numpy.linalg.solve(a,b) |
求解x的线性方程组Ax = b，其中A为方阵 |
numpy.linalg.lstsq(lstsq(a, b, rcond='warn')) |
计算Ax=b的最小二乘解 |
11 NumPy - 伪随机数生成函数
设置随机种子
import numpy as np
np.random.seed(1234)#设置随机种子为1234
简单随机数
| 函数 | 描述 |
|---|---|
rand(d0, d1, …, dn) |
产生均匀分布的随机数。dn为第n维数据的维度 |
randn(d0, d1, …, dn) |
产生标准正态分布随机数。dn为第n维数据的维度 |
randint(low[, high, size, dtype]) |
产生随机整数。low：最小值；high：最大值；size：数据个数 |
random([size]) |
在[0,1）内产生随机数。size：随机数的shape，可以为元祖或者列表，[2,3]表示2维随机数，维度为（2,3） |
choice(a[, size, replace, p]) |
从a中随机选择指定数据。a：1维数组 size：返回数据形状 |
bytes(length) |
返回随机位。length：位的长度 |
随机分布
| 函数 | 描述 |
|---|---|
beta(a, b[, size]) |
贝塔分布样本，在 [0, 1]内。 |
binomial(n, p[, size]) |
二项分布的样本。 |
chisquare(df[, size]) |
卡方分布样本。 |
dirichlet(alpha[, size]) |
狄利克雷分布样本。 |
exponential([scale, size]) |
指数分布 |
f(dfnum, dfden[, size]) |
F分布样本。 |
gamma(shape[, scale, size]) |
伽马分布 |
geometric(p[, size]) |
几何分布 |
gumbel([loc, scale, size]) |
耿贝尔分布。 |
hypergeometric(ngood, nbad, nsample[, size]) |
超几何分布样本。 |
laplace([loc, scale, size]) |
拉普拉斯或双指数分布样本 |
logistic([loc, scale, size]) |
Logistic分布样本 |
lognormal([mean, sigma, size]) |
对数正态分布 |
logseries(p[, size]) |
对数级数分布。 |
multinomial(n, pvals[, size]) |
多项分布 |
multivariate_normal(mean, cov[, size]) |
多元正态分布。 |
negative_binomial(n, p[, size]) |
负二项分布 |
noncentral_chisquare(df, nonc[, size]) |
非中心卡方分布 |
noncentral_f(dfnum, dfden, nonc[, size]) |
非中心F分布 |
normal([loc, scale, size]) |
正态(高斯)分布 |
pareto(a[, size]) |
帕累托（Lomax）分布 |
poisson([lam, size]) |
泊松分布 |
standard_cauchy([size]) |
标准柯西分布 |
standard_exponential([size]) |
标准的指数分布 |
standard_gamma(shape[, size]) |
标准伽马分布 |
standard_normal([size]) |
标准正态分布 (mean=0, stdev=1). |
triangular(left, mode, right[, size]) |
三角形分布 |
uniform([low, high, size]) |
均匀分布 |
wald(mean, scale[, size]) |
瓦尔德（逆高斯）分布 |
weibull(a[, size]) |
Weibull 分布 |
zipf(a[, size]) |
齐普夫分布 |
排列
| 函数 | 描述 |
|---|---|
shuffle(x) |
打乱对象x（多维矩阵按照第一维打乱） |
permutation(x) |
打乱并返回该对象（多维矩阵按照第一维打乱） |
于 2019-12-25 再次更新