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变体说明intint8、int16、int32、int64整数类型uintuint8、uint16、uint32、uint64无符号(非负)整数类型boolBool布尔类型(True或False)floatfloat16、float32、float64、float128浮点类型complexcomplex64、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]​

NumPy_一维数组

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.向量化表达式

  • 广播:将两个数组广播成相同形状和大小的数组。规则,一个二维数组和一个一维数组,必须有一个维度相同,且一维数组只能是一维数组,并向缺失维度方向广播。

NumPy_python_02

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进行聚合

NumPy_数据类型_03

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

对表示向量的两个数组进行外积