NumPy

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	变体	说明
int	int8、int16、int32、int64	整数类型
uint	uint8、uint16、uint32、uint64	无符号（非负）整数类型
bool	Bool	布尔类型（True或False）
float	float16、float32、float64、float128	浮点类型
complex	complex64、complex128、complex256	复数浮点型

代码示例：（使用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	对表示向量的两个数组进行外积

posted @ 2021-07-29 12:48 Budcs 阅读(235) 评论(0) 收藏举报

刷新页面返回顶部

Budcs

NumPy

1.导入模块

2.NumPy Array对象

2.1NumPy类的属性

2.2数据类型

3.创建数组

3.1从列表和其他数组对象创建数组

3.2以常量填充的数组

3.3以增量序列填充的数值

3.4以等比数列填充的数组

3.5Meshgrid数组

3.6创建未初始化的数组

3.7使用其他数组的属性创建数组

3.8创建矩阵数组

4.索引和切片

4.1一维数组

4.2多维数组

4.3视图

4.4花式索引和布尔索引

5.调整形状和大小

6.向量化表达式

6.1算术运算

6.2逐个元素进行操作的函数

6.3 聚合函数

6.4布尔数组和条件表达式

6.5集合运算

6.6数组运算

7.矩阵和向量运算

公告