NumPy基本操作，参考《Numerical Python: Scientific Computing and Data Science Applications with NumPy, SciPy and matploatlib》 ——Second Edition, Robert Johansson
1.导入模块
import numpy as np
2.NumPy Array对象
2.1NumPy类的属性
NumPy库的核心是表示同质数据的多维数组。同质指的是数组中所有元素具有相同的数据类型。NumPy中多维数组的主要数据结构是ndarray类。
- ndarray类的基本属性及说明
属性 | 说明 |
shape | 包含数组每个维度的元素数量（长度）的元组 |
size | 数组中元素的总数 |
ndim | 维度的数量 |
nbytes | 存储数据的字节数 |
dtype | 数组中元素的数据类型 |
代码示例：（其中data是一个3×2的二维数组）
In [2]: data = np.array([[1, 2], [3, 4], [5, 6]])
In [3]: type(data)
Out[3]: numpy.ndarray
In [4]: data
Out[4]:
array([[1, 2],
[3, 4],
[5, 6]])
In [5]: data.ndim
Out[5]: 2
In [6]: data.shape
Out[6]: (3, 2)
In [7]: data.size
Out[7]: 6
In [8]: data.dtype
Out[8]: dtype('int32')
In [9]: data.nbytes
Out[9]: 24
- shape(4,)、shape(1, 2)和shape(2, 1)辨析
In [147]: a = np.array([1, 2])
In [148]: a.shape
Out[148]: (2,)
In [149]: b = np.array([[1, 2]])
In [150]: b.shape
Out[150]: (1, 2)
In [151]: c = np.array([[1], [2]])
In [152]: c.shape
Out[152]: (2, 1)
shpae(x, y)可以理解为第一个[]中有x个元素，第二个[]中有y个元素。
2.2数据类型
标准Python只为整数和浮点数提供一种类型。
- NumPy支持的基本数字类型
代码示例：（使用dtype属性创建整数数组、浮点数数组和复数数组）
In [10]: np.array([1, 2, 3], dtype=np.int)
Out[10]: array([1, 2, 3])
In [11]: np.array([1, 2, 3], dtype=np.float)
Out[11]: array([1., 2., 3.])
In [12]: np.array([1, 2, 3], dtype=np.complex)
Out[12]: array([1.+0.j, 2.+0.j, 3.+0.j])
- NumPy数组dtype的更改
创建完NumPy数组之后，数组的dtype就不能更改了，除非复制数组进行类型转换。
代码示例：
In [13]: data = np.array([1, 2, 3], dtype=np.float)
In [14]: data
Out[14]: array([1., 2., 3.])
In [15]: data.dtype
Out[15]: dtype('float64')
In [16]: data = np.array(data, dtype=np.int)
In [17]: data.dtype
Out[17]: dtype('int32')
In [18]: data
Out[18]: array([1, 2, 3])
也可使用ndarray类的astype方法：
In [19]: data = np.array([1, 2, 3], dtype=np.float)
In [20]: data
Out[20]: array([1., 2., 3.])
In [21]: data.astype(np.int)
Out[21]: array([1, 2, 3])
- NumPy数组进行计算时，数据类型可能会发生转变。
如：浮点数数组和复数数组相加得到的是复数类型。
In [22]: d1 = np.array([1, 2, 3], dtype=float)
In [23]: d2 = np.array([1, 2, 3], dtype=complex)
In [24]: d1 + d2
Out[24]: array([2.+0.j, 4.+0.j, 6.+0.j])
In [25]: (d1 + d2).dtype
Out[25]: dtype('complex128')
- 根据需求，创建数组时指定合适的数据类型，默认数据类型是float
In [26]: np.sqrt(np.array([-1, 0, 1]))
<ipython-input-26-18cc2be45d00>:1: RuntimeWarning: invalid value encountered in sqrt
np.sqrt(np.array([-1, 0, 1]))
Out[26]: array([nan, 0., 1.])
In [27]: np.sqrt(np.array([-1, 0, 1], dtype=complex))
Out[27]: array([0.+1.j, 0.+0.j, 1.+0.j])
- 实部和虚部
不论dtype属性是什么，NumPy数组实例都有real和imag属性。
In [28]: data = np.array([1, 2, 3], dtype=complex)
In [29]: data
Out[29]: array([1.+0.j, 2.+0.j, 3.+0.j])
In [30]: data.real
Out[30]: array([1., 2., 3.])
In [31]: data.imag
Out[31]: array([0., 0., 0.])
3.创建数组
- 用于生成数组的常用函数
函数名 | 数组类型 |
np.array | 使用类数组对象创建数组，例如（嵌套的）Python列表、元组、可迭代序列或其他ndarray实例 |
np.zeros | 创建指定维度和数据类型的数组，以0填充 |
np.ones | 创建指定维度和数据类型的数组，以1填充 |
np.diag | 创建对角数组，指定对角线的值，其他以0填充 |
np.arange | 创建均匀间隔数值的数组，指定开始值、结束值以及增量值 |
np.linspace | 创建均匀间隔数值的数组，指定开始值、结束值以及元素数量 |
np.logspace | 创建等比数列，指定开始值和结束值 |
np.meshgrid | 从一维坐标向量生成坐标矩阵（和高维坐标数组） |
np.fromfunction | 创建一个数组，用给定函数的值进行填充，该函数将针对给定数组大小的每个索引组合进行计算 |
np.fromfile | 借助二进制（或文本）文件中的数据来创建数组。NumPy还提供了对应的函数np.tofile用于将NumPy数组保存到磁盘上，后续可使用np.fromfile进行读取 |
np.genfromtxt，np.loadtxt | 从文本文件（如CSV文件）读取数据以创建数组，np.genfromtxt支持处理缺失值 |
np.random.rand | 创建一个数组，元素来自于0和1之间均匀分布的随机数。也可使用np.random模块中其他的分布，如正态分布np.random.normal。 |
3.1从列表和其他数组对象创建数组
从Python列表创建一维数组：
In [32]: np.array([1, 2, 3, 4])
Out[32]: array([1, 2, 3, 4])
In [33]: data.ndim
Out[33]: 1
从Python列表创建二维数组：
In [35]: np.array([[1, 2], [3, 4]])
Out[35]:
array([[1, 2],
[3, 4]])
3.2以常量填充的数组
函数np.zeros和np.ones分别以0和1填充创建数组。也可以接受dtype参数。
In [37]: np.zeros((2, 3))
Out[37]:
array([[0., 0., 0.],
[0., 0., 0.]])
In [38]: np.ones(4)
Out[38]: array([1., 1., 1., 1.])
也可以接受dtype参数。
In [39]: data = np.ones(4)
In [40]: data.dtype
Out[40]: dtype('float64')
In [41]: data = np.ones(4, dtype=np.int64)
In [42]: data.dtype
Out[42]: dtype('int64')
创建一个以某个特定值填充的数组，可以先创建一个以1填充的数组，或者使用np.full函数。后者更高效，避免了乘法运算。
In [43]: x1 = 5.4 * np.ones(10)
In [44]: x1
Out[44]: array([5.4, 5.4, 5.4, 5.4, 5.4, 5.4, 5.4, 5.4, 5.4, 5.4])
In [46]: x2 = np.full(10, 5.4)
In [47]: x2
Out[47]: array([5.4, 5.4, 5.4, 5.4, 5.4, 5.4, 5.4, 5.4, 5.4, 5.4])
创建好的数组可以使用np.fill进行填充，该函数使用一个数组和一个数值作为参数。(一个是full，一个是full)
In [50]: x1 = np.empty(5) #np.empty函数用于生成一个没有初始化值的数值。
In [52]: x1.fill(3.0)
In [53]: x1
Out[53]: array([3., 3., 3., 3., 3.])
In [54]: x2 = np.full(5, 3.0)
In [55]: x2
Out[55]: array([3., 3., 3., 3., 3.])
3.3以增量序列填充的数值
np.arange第三个参数是增量，np.linspace第三个参数是数组元素个数。
np.arange不包含结束值，np.linspace默认包含结束值。
In [56]: np.arange(0.0, 10, 1)
Out[56]: array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
In [57]: np.linspace(0, 10, 11)
Out[57]: array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
3.4以等比数列填充的数组
np.logspace前两个参数分别是开始值和结束值，参数base可选（默认是10）的幂。
#生成一个在1和100之间以对数形式分布元素的数组，10^0 = 1，10^2 = 100
In [58]: np.logspace(0, 2, 5) #5个元素
Out[58]:
array([ 1., 3.16227766, 10. , 31.6227766 , 100. ])
3.5Meshgrid数组
使用np.meshgrid函数生成二维数组。（X, Y）是二维坐标上的点。
In [59]: x = np.array([-1, 0, 1])
In [60]: y = np.array([-2, 0, 2])
In [61]: X, Y = np.meshgrid(x, y)
In [62]: X
Out[62]:
array([[-1, 0, 1],
[-1, 0, 1],
[-1, 0, 1]])
In [63]: Y
Out[63]:
array([[-2, -2, -2],
[ 0, 0, 0],
[ 2, 2, 2]])
3.6创建未初始化的数组
In [64]: np.empty(3, dtype=np.float)
Out[64]: array([6.95196210e-310, 4.94065646e-324, 4.42517099e+025]) #每次运行结果都不同
3.7使用其他数组的属性创建数组
创建一个与另一个数组拥有相同属性（如shape和dtype）的新数组。NumPy提供了相关的函数：np.ones_like、np.zeros_like、np.full_like和np.empty_like。
def f(x): #x是个数组
y = np.ones_like(x)
return y #数组y和数组x大小、数据类型相同，并用1填充
3.8创建矩阵数组
- np.identity
np.identity生成对角线为1、其他元素为0的方形矩阵。
In [65]: np.identity(4)
Out[65]:
array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
- np.eye
np.eye生成对角线为1的方阵（偏移量是可选参数）
In [66]: np.eye(3, k=1)
Out[66]:
array([[0., 1., 0.],
[0., 0., 1.],
[0., 0., 0.]])
In [67]: np.eye(3, k=-1)
Out[67]:
array([[0., 0., 0.],
[1., 0., 0.],
[0., 1., 0.]])
- np.diag
可用于创建对角线是任意一维数组的矩阵。（偏移量可选）
In [68]: np.diag(np.arange(0, 20, 5))
Out[68]:
array([[ 0, 0, 0, 0],
[ 0, 5, 0, 0],
[ 0, 0, 10, 0],
[ 0, 0, 0, 15]])
4.索引和切片
4.1一维数组
使用整数索引可以选择单个元素，使用切片可以选择某个范围内的元素和序列。
正整数用于从数组开头进行索引（索引开始于0），负整数用于从数组末尾进行索引，最后一个元素的索引是-1，倒数第二个是-2，以此类推。
切片使用符号:，m:n表示选择从m到n-1的元素（不包含第n个元素），m:n:1其中数字1表示m到n之间的每个元素都被选择，m:n:2表示从每两个元素中选一个元素，通式m:n:p。当p为负数时，以逆序形式返回。
- NumPy数组的索引和切片操作
表达式 | 说明 |
a[m] | 选择索引m处的元素，其中m是整数（从0开始计数） |
a[-m] | 从数组末尾选择第m个元素，其中m是整数。 |
a[m:n] | 选择索引为m到n-1的元素（m和n都是整数） |
a[:]和a[0:-1] | 选择指定维的所有元素 |
a[:n] | 选择索引为0到n-1的元素 |
a[m:]或a[m:-1] | 选择索引为m到数组末尾的所有元素 |
a[m:n:p] | 选择索引为m到n（不包含n）、增量为p的所有元素 |
a[::-1]或a[0????-1] | 逆序选择所有元素 |
代码示例：
In [70]: a = np.arange(0,11)
In [71]: a
Out[71]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
In [72]: a[0]
Out[72]: 0
In [73]: a[-1]
Out[73]: 10
In [74]: a[4]
Out[74]: 4
In [75]: a[1:-1]
Out[75]: array([1, 2, 3, 4, 5, 6, 7, 8, 9])
In [76]: a[1:-1:2]
Out[76]: array([1, 3, 5, 7, 9])
In [77]: a[:5]
Out[77]: array([0, 1, 2, 3, 4])
In [78]: a[-5:]
Out[78]: array([ 6, 7, 8, 9, 10])
In [79]: a[::-2]
Out[79]: array([10, 8, 6, 4, 2, 0])
4.2多维数组
对于多维数组的每一维，都可以使用一维数组的方法进行索引和切片。
In [85]: f = lambda m, n: n + 10 * m
In [86]: A = np.fromfunction(f, (6, 6), dtype=int)
In [87]: A
Out[87]:
array([[ 0, 1, 2, 3, 4, 5],
[10, 11, 12, 13, 14, 15],
[20, 21, 22, 23, 24, 25],
[30, 31, 32, 33, 34, 35],
[40, 41, 42, 43, 44, 45],
[50, 51, 52, 53, 54, 55]])
In [88]: A[:, 1] #第二列
Out[88]: array([ 1, 11, 21, 31, 41, 51])
In [89]: A[1, :] #第二行
Out[89]: array([10, 11, 12, 13, 14, 15])
In [90]: A[:3, :3] #左上半对角线子矩阵
Out[90]:
array([[ 0, 1, 2],
[10, 11, 12],
[20, 21, 22]])
In [91]: A[3:, :3] #左下半对角线子矩阵
Out[91]:
array([[30, 31, 32],
[40, 41, 42],
[50, 51, 52]])
In [92]: A[::2, ::2] #从（0，0）开始，从每两个元素中选择一个
Out[92]:
array([[ 0, 2, 4],
[20, 22, 24],
[40, 42, 44]])
In [93]: A[1::2, 1::3] #从（1，1）开始，从每两行中选择一行，从每三列中选择一
...: 列
Out[93]:
array([[11, 14],
[31, 34],
[51, 54]])
4.3视图
使用切片操作从数组中提取的子数组是同一底层数组数据的视图，即引用的是原始数组在内存中的同一份数据，但具有不同的strides设置。因此，视图中元素被赋予新值后，原始数组也会跟着变化。
In [94]: B = A[1:5, 1:5] #A是上个代码块中多维数组
In [95]: B
Out[95]:
array([[11, 12, 13, 14],
[21, 22, 23, 24],
[31, 32, 33, 34],
[41, 42, 43, 44]])
In [96]: B[:, :] = 0
In [97]: A
Out[97]:
array([[ 0, 1, 2, 3, 4, 5],
[10, 0, 0, 0, 0, 15],
[20, 0, 0, 0, 0, 25],
[30, 0, 0, 0, 0, 35],
[40, 0, 0, 0, 0, 45],
[50, 51, 52, 53, 54, 55]])
当需要的数组的副本时，可以使用copy方法：
In [98]: C = B[1:3, 1:3].copy()
In [99]: C
Out[99]:
array([[0, 0],
[0, 0]])
In [100]: C[:, :] = 1
In [101]: C
Out[101]:
array([[1, 1],
[1, 1]])
In [102]: B
Out[102]:
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]])
4.4花式索引和布尔索引
花式索引：一个NumPy数组可以使用另一个NumPy数组、Python列表或整数序列进行索引。
In [103]: A = np.linspace(0, 1, 11)
In [104]: A
Out[104]: array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
In [106]: A[np.array([0, 2, 4])]
Out[106]: array([0. , 0.2, 0.4])
In [107]: A[[0, 2, 4]]
Out[107]: array([0. , 0.2, 0.4])
布尔索引：
In [108]: A > 0.5
Out[108]:
array([False, False, False, False, False, False, True, True, True,
True, True])
In [109]: A[A > 0.5]
Out[109]: array([0.6, 0.7, 0.8, 0.9, 1. ])
使用花式索引和布尔索引得到的数组不是视图，而是新的数组。
In [110]: A = np.arange(10)
In [111]: A
Out[111]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [112]: indices = [2, 4, 6]
In [113]: B = A[indices]
In [114]: B
Out[114]: array([2, 4, 6])
In [115]: B[0] = -1 #不改变A中元素
In [116]: A
Out[116]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [117]: A[indices] = -1 #改变A中元素
In [118]: A
Out[118]: array([ 0, 1, -1, 3, -1, 5, -1, 7, 8, 9])
- 图片概括：
data[row,line]
5.调整形状和大小
对数组进行重新排列以及改变它们的表达方式，如将N×N的矩阵重排成一个长度为\(N^2\)的数组。
- 操作数组大小和形状的NumPy函数
函数方法 | 说明 |
np.reshape和np.ndarray.reshape | 调整N维数组的维度。元素的总数保持不变 |
np.ndarray.flatten | 创建N维数组的副本，并将其折叠成一维数组 |
np.ravel和np.ndarray.ravel | 创建N维数组的视图（不能创建时，创建副本），并将其折叠成一维数组 |
np.squeeze | 删除长度为1的维度 |
np.expand_dims和np.newaxis | 在数组中增加长度为1的新维度，其中np.newaxis用于数组索引 |
np.transpose、np.ndarray.transpose和np.ndarray.T | 对数组进行转置。转置操作对应于数组的轴进行反转。一维数组无法转置 |
np.hstack | 对一组数组进行水平叠加（沿着轴1，即x轴）：例如，给定一组列向量，叠加之后形成矩阵 |
np.vstack | 对一组数组进行垂直叠加（沿着轴0，即y轴）：例如，给定一组行向量，叠加之后形成矩阵 |
np.dstack | 对一组数组进行深度堆叠（沿着轴2，即z轴） |
np.concatenate | 沿着给定轴堆叠数组 |
np.resize | 调整数组的大小。根据给定的大小创建原始数组的副本，如有需要，使用原始数组填充数组 |
np.append | 在数组中添加一个新元素，该操作会创建数组的新副本 |
np.insert | 在数组的给定位置插入一个元素，该操作会创建数组的新副本 |
np.delete | 删除数组中指定位置的元素，该操作会创建数组的新副本 |
代码示例：
- np.reshape和np.ndarray.reshape
np.reshape是一个函数，np.ndarray.reshape是ndarray类的reshape方法。并且重拍数组产生的是视图。
In [119]: data = np.array([[1, 2], [3, 4]])
In [120]: np.reshape(data, (1, 4)) #使用函数
Out[120]: array([[1, 2, 3, 4]])
In [122]: data.reshape(4) #使用ndarray类的方法
Out[122]: array([1, 2, 3, 4])
- np.ravel和np.ndarray.flatten
np.ravel返回视图，np.ndarray.flatten返回副本。
In [123]: data = np.array([[1, 2], [3, 4]])
In [124]: data
Out[124]:
array([[1, 2],
[3, 4]])
In [125]: data.flatten()
Out[125]: array([1, 2, 3, 4])
In [126]: data.ravel()
Out[126]: array([1, 2, 3, 4])
- np.newaxis
对一维数组应使用带一个元素的元素进行索引，但使用具有多个元素的元组进行索引，且元组中有np.newaxis值，则会添加相应的新值。
In [127]: data = np.arange(0, 5)
In [128]: column = data[:, np.newaxis] #增加了轴0，即y轴
In [129]: column
Out[129]:
array([[0],
[1],
[2],
[3],
[4]])
In [131]: row = data[np.newaxis, :] #增加了轴1，即x轴
In [132]: row
Out[132]: array([[0, 1, 2, 3, 4]])
其中，data[:, np.newaxis]等价于np.expand_dims(data, axis=1)，data[np.newaxis, :]等价于np.expand_dims(data, axis=0)，axis参数指定了新轴相对于现有轴需要插入的位置。
- np.hstack、np.vstack和np.concatenate
In [135]: data = np.arange(0, 5)
In [136]: data
Out[136]: array([0, 1, 2, 3, 4])
In [137]: np.vstack((data, data, data))
Out[137]:
array([[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4]])
In [138]: np.hstack((data, data, data))
Out[138]: array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4])
In [139]: a = np.array([[1, 2], [3, 4]])
In [140]: b = np.array([[5, 6]])
In [141]: np.concatenate((a, b), axis=0) #指定在轴0方向堆叠
Out[141]:
array([[1, 2],
[3, 4],
[5, 6]])
In [142]: np.concatenate((a, b.T), axis=1) #指定在轴1方向堆叠，堆叠前需对b转
...: 置
Out[142]:
array([[1, 2, 5],
[3, 4, 6]])
In [143]: np.concatenate((a, b), axis=None)
Out[143]: array([1, 2, 3, 4, 5, 6])
- np.append
In [144]: np.append([1, 2, 3], [[4, 5, 6], [7, 8, 0]]) #一维数组和二维数组的
...: 拼接
Out[144]: array([1, 2, 3, 4, 5, 6, 7, 8, 0])
In [145]: np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0) #两个二维数
...: 组拼接，并指定在轴0方向
Out[145]:
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In[146]: np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0)
Traceback (most recent call last):
...
ValueError: all the input arrays must have same number of dimensions, but
the array at index 0 has 2 dimension(s) and the array at index 1 has 1
dimension(s)
6.向量化表达式
- 广播：将两个数组广播成相同形状和大小的数组。规则，一个二维数组和一个一维数组，必须有一个维度相同，且一维数组只能是一维数组，并向缺失维度方向广播。
6.1算术运算
NumPy数组的标准算术运算是基于元素的运算。即是对应位置元素的加、减、乘和除。
常见算术运算符：+、+=，/、/=，//、//=(整除)，**、**=(指数运算)
In [162]: x = np.array([[1, 2], [3, 4]])
In [163]: y = np.array([[5, 6], [7, 8]])
In [164]: x + y
Out[164]:
array([[ 6, 8],
[10, 12]])
In [165]: y - x
Out[165]:
array([[4, 4],
[4, 4]])
In [166]: x * y #元素之间相乘，并非矩阵乘法
Out[166]:
array([[ 5, 12],
[21, 32]])
In [167]: y / x
Out[167]:
array([[5. , 3. ],
[2.33333333, 2. ]])
标量与数组运算，即标量值与数组的每个元素进行运算：
In [168]: x * 2
Out[168]:
array([[2, 4],
[6, 8]])
In [169]: 2 ** x
Out[169]:
array([[ 2, 4],
[ 8, 16]], dtype=int32)
不兼容大小或形状的数组进行算术运算时，会引发异常。
对于可广播成相同大小的数组，则可进行算术运算，即shape(2, 2)的数组可与shape(2,)、shape(1, 2)或shape(2, 1)的数组进行运算。
In [170]: x = np.array([1, 2, 3, 4]).reshape(2, 2)
In [171]: z = np.array([[2, 4]])
In [172]: z.shape
Out[172]: (1, 2)
In [173]: x / z
Out[173]:
array([[0.5, 0.5],
[1.5, 1. ]])
In [174]: zz = np.concatenate([z, z], axis=0)#等价于z广播成shape(2,2)
In [175]: zz
Out[175]:
array([[2, 4],
[2, 4]])
In [176]: x / zz
Out[176]:
array([[0.5, 0.5],
[1.5, 1. ]])
6.2逐个元素进行操作的函数
NumPy中基本数学函数，都一个数组作为输入，并输出相同形状的数组，如：np.function(array)，函数作用于数组中每一个元素。
- 逐元素计算的基本数学函数
NumPy函数 | 说明 |
np.cos、np.sin、np.tan | 三角函数 |
np.arccos、np.arcsin、np.arctan | 反三角函数 |
np.cosh、np.sinh、np.tanh | 双曲三角函数 |
np.arccosh、np.arcsinh、np.arctanh | 反双曲三角函数 |
np.sqrt | 平方根 |
np.exp | 指数 |
np.log、np.log2、np.log10 | 底为e、2、10的对数 |
代码示例：
In [177]: x = np.linspace(-1, 1, 11)
In [178]: x
Out[178]: array([-1. , -0.8, -0.6, -0.4, -0.2, 0. , 0.2, 0.4, 0.6, 0.8, 1. ])
In [179]: y = np.sin(np.pi * x) #np.pi是常数Π
In [180]: y
Out[180]:
array([-1.22464680e-16, -5.87785252e-01, -9.51056516e-01, -9.51056516e-01,
-5.87785252e-01, 0.00000000e+00, 5.87785252e-01, 9.51056516e-01,
9.51056516e-01, 5.87785252e-01, 1.22464680e-16])
- 其他数学运算的NumPy函数
NumPy函数 | 说明 |
np.add、np.subtract、np.multiply和np.divide | 两个NumPy数组的加、减、乘和除 |
np.power | 将第一个输入参数作为第二个输入参数的幂（逐元素进行） |
np.remainder | 除法运算的余数 |
np.real、np.imag和np.conj | 输入数组中每个元素的实部、虚部和共轭复数 |
np.sign、np.abs | 符号值和绝对值 |
np.floor、np.ceil和np.rint | 转为整数 |
np.round | 四舍五入到指定紧度，接受一个数组参数和一个指定精度 |
也可以根据需求，定义NumPy数组进行逐元素运算的新函数。np.vectorize函数可以将标量函数转变为向量函数。
6.3聚合函数
NumPy的聚合函数，将数组作为输入，返回一个标量。如，计算数组中元素的总和、方差等等。
NumPy中聚合函数，在ndarray类中都有对应的方法，如：np.mean(data)等价于data.mean()
- NumPy中聚合函数
NumPy函数 | 说明 |
np.mean | 计算数组中所有元素的均值 |
np.std | 计算标准差 |
np.var | 就算方差 |
np.sum | 计算总和 |
np.prod | 计算所有元素的乘积 |
np.cumsum | 计算所有元素的累计和。返回一个数组，数组中每一元素是对应元素累计和。 |
np.cumprod | 计算所有元素的累计乘。 |
np.min和np.max | 计算最小值和最大值 |
np.argmin和np.argmax | 计算数组中最小值和最大值的索引 |
np.all | 如果参数数组中所有元素都不为零，则返回True |
np.any | 只要参数数组中任何一个元素不为零，则返回True |
上述函数，可使用关键字axis对指定轴进行聚合。
In [183]: data = np.random.normal(size=(5, 10, 15))
In [184]: data.sum(axis=0).shape
Out[184]: (10, 15)
In [185]: data.sum(axis=(0, 2)).shape
Out[185]: (10,)
In [186]: data.sum()
Out[186]: -18.943015142701654
图片概括：左图对所有轴进行聚合，中图对轴0进行聚合，右图对轴1进行聚合
6.4布尔数组和条件表达式
NumPy数组提供了常用的比较运算符，如：>、<、>=、<=、==、!=
In [187]: a = np.array([1, 2, 3, 4])
In [188]: b = np.array([4, 3, 2, 1])
In [189]: a < b
Out[189]: array([ True, True, False, False])
数组比较运算的结果常用于if语句，也会np.all和np.any结合使用。
In [190]: np.all(a < b)
Out[190]: False
In [191]: np.any(a < b)
Out[191]: True
布尔值数组在算术表达式中与标量或另一种数值类型的NumPy数组出现时，布尔值数组转换为数值类型，即True和False分布转为1和0
In [192]: x = np.array([-2, -1, 0, 1, 2])
In [193]: x > 0
Out[193]: array([False, False, False, True, True])
In [194]: 1 * (x > 0)
Out[194]: array([0, 0, 0, 1, 1])
- NumPy中条件和逻辑运算函数
函数 | 说明 |
np.where | 根据条件数组的值从两个参数数组中选值 |
np.choose | 根据给定的索引数组中值从数组列表中选值 |
np.select | 根据条件列表从数组列表中国选值 |
np.nonzero | 返回非零元素的索引 |
np.logical_and和np.logical_not | 逐元素进行AND/NOT操作 |
np.logical_or和np.logical_xor | 逐元素进行OR/XOR操作 |
- np.where
第一个参数是布尔值数组，第二、三个参数是数组。条件数组中元素为True时，选第二个参数数组的值，为False时，选第三个参数数组的值。
In [195]: x = np.linspace(-4, 4, 9)
In [196]: np.where(x < 0, x**2, x**3)
Out[196]: array([16., 9., 4., 1., 0., 1., 8., 27., 64.])
6.5集合运算
集合：无序唯一序列对象。
- NumPy中的集合操作函数
函数 | 说明 |
np.unique | 创建具有唯一值的新数组，每个元素值出现一次 |
np.in1d | 检查某个数组中的元素是否在另一个元素中(in1d是数字“1”，下同) |
np.intersectld | 以数组形式返回两个数组中都包含的元素 |
np.setdiffld | 以数组形式返回只在第一个数组中出现、但不在第二个数组中出现的元素 |
np.uniold | 以数组形式返回两个数组的所有元素 |
In [198]: a
Out[198]: array([1, 2, 3])
In [199]: b = np.unique([2, 3, 4, 4, 5, 6, 5])
In [200]: b
Out[200]: array([2, 3, 4, 5, 6])
In [202]: np.in1d(a, b)
Out[202]: array([False, True, True])
In [203]: 1 in a #也可使用关键字in来检查元素是否在数组中
Out[203]: True
#判断a是否是b的子集
In [204]: np.all(np.in1d(a, b))
Out[204]: False
6.6数组运算
- NumPy中数组操作函数
函数 | 说明 |
np.transpose、np.ndarray.transpose和np.ndarray.T | 转置 |
np.fliplr/np.fliqud | 反转每行/每列的元素，即左右翻转、上下反转 |
np.rot90 | 沿着前两个轴将元素旋转\(90^0\) |
np.sort和np.ndarray.sort | 沿着指定轴对元素进行排序，默认沿着最后一个轴 |
7.矩阵和向量运算
- NumPy中矩阵操作函数
函数 | 说明 |
np.dot | 对表示向量、数组或张量的两个数组进行矩阵乘法（点积） |
np.inner | 对表示向量的两个数组进行标量乘法（内积），即两数组对应元素相乘之和 |
np.cross | 对表示向量的两个数组进行叉积 |
np.tensordot | 沿着多维数组的某个指定的轴进行点击 |
np.outer | 对表示向量的两个数组进行外积 |