NumPy入门基础【2】

通用函数ufunc

一元ufunc举例：

1、abs、fabs：计算绝对值,fabs更快

2、sqrt：计算各元素的平方根，相当于arr0.5

3、square：计算各元素的平方根，相当远arr2

4、exp：计算各元素的指数e的x次方

...

二元ufunc举例：

1、add：将数组中对应的元素想加

2、subtract：从第一个数组中减去第二个数组中的元素

3、multiply：数组元素相乘

4、divide：除法

5、power：对第一个数组中的元素A，根据第二个数组中的相应元素B，计算A的B次方。

利用数组进行数据处理

用数组表达式代替循环的做法，通常被称为矢量化，要比等价的Python方法快上一两个数量级，尤其是数值运算。

np.meshgrid函数的用法，[X,Y] = meshgrid(x,y) 将向量x和y定义的区域转换成矩阵X和Y，这两个矩阵可以用来表示mesh和surf的三维空间点以及两个变量的赋值。其中矩阵X的行向量是向量x的简单复制，而矩阵Y的列向量是向量y的简单复制。举例如下：

import numpy as np
points=np.arange(-5,5,0.01)
xs,ys=np.meshgrid(points,points)
xs

array([[-5.  , -4.99, -4.98, ...,  4.97,  4.98,  4.99],
       [-5.  , -4.99, -4.98, ...,  4.97,  4.98,  4.99],
       [-5.  , -4.99, -4.98, ...,  4.97,  4.98,  4.99],
       ...,
       [-5.  , -4.99, -4.98, ...,  4.97,  4.98,  4.99],
       [-5.  , -4.99, -4.98, ...,  4.97,  4.98,  4.99],
       [-5.  , -4.99, -4.98, ...,  4.97,  4.98,  4.99]])

将条件逻辑表述为数组运算

np.where函数是三元表达式x if condition else y的矢量化版本，举例：

xarr=np.array([1.1,1.2,1.3,1.4,1.5])
yarr=np.array([2.1,2.2,2.3,2.4,2.5])
cond=np.array([True,False,True,True,False])
cond

array([ True, False,  True,  True, False], dtype=bool)

假设我们想根据cond中的值来确定选择xarr还是yarr，使用列表推导式的方法如下：

result=[(x if c else y) for x,y,c in zip(xarr,yarr,cond)]

可以想到，这种方法的处理速度不是很快，无法用于多维数组。使用np.where会更为简单：

result=np.where(cond,xarr,yarr)
result

array([ 1.1,  2.2,  1.3,  1.4,  2.5])

其中where函数的第二三个参数不一定是数组，可以是标量。

cond就是负责判断，生成的数组与cond的构型一样

排序

sort方法，对于多维数组，可以接收参数，在任何一个轴向上进行排序。

np.sort返回的是数组的已排序副本，arr.sort则会修改数组本省。

例如：

arr=np.random.randn(8)
arr

array([-1.86799618,  1.17907009, -0.17769902,  1.52782505, -1.00578336,
       -0.606077  ,  1.24019255,  0.02054406])

arr.sort()
arr

array([-1.86799618, -1.00578336, -0.606077  , -0.17769902,  0.02054406,
        1.17907009,  1.24019255,  1.52782505])

arr=np.random.randn(5,3)
arr

array([[-0.87890012,  0.83758321,  0.07969702],
       [-1.12805445, -0.32557521, -0.65476785],
       [ 1.33504954,  0.59905743,  3.13774442],
       [-1.07642073,  0.08063416,  0.8242277 ],
       [-0.40929861, -0.14981955, -1.56494243]])

arr.sort(1)
arr

array([[-0.87890012,  0.07969702,  0.83758321],
       [-1.12805445, -0.65476785, -0.32557521],
       [ 0.59905743,  1.33504954,  3.13774442],
       [-1.07642073,  0.08063416,  0.8242277 ],
       [-1.56494243, -0.40929861, -0.14981955]])

numpy.sort(a, axis=-1, kind='quicksort', order=None)

返回数组的排序副本。

参数：

a：array_like

数组要排序。

axis：int或None，可选

要排序的轴。如果为“无”，则在排序之前将数组展平。默认值为-1，沿最后一个轴排序。

kind：{'quicksort'，'mergesort'，'heapsort'}，可选

排序算法。默认值为“quicksort”。

order：str或str的列表，可选

当a是定义了字段的数组时，此参数指定首先，第二等比较哪些字段。单个字段可以指定为字符串，并且不是所有字段都需要指定，但是未指定的字段仍将按照它们在dtype中出现的顺序使用，以断开关系。

返回：

sorted_array：ndarray

数组的类型和形状与a相同。

用于数组的文件输入输出

1、二进制格式保存

np.save和np.load是读写数据的两个主要函数。

2、文本文件

np.loadtxt或更为专业的np.genfromtxt函数将文本数据加载到普通的Numpy数组中

np.savetxt保存文本。

线性代数

常用的函数说明：

diag，以一维数组的形式返回方针的对角线（或对角线）元素，或将一组数组转换成方阵。

numpy.diag(v, k=0)

参数：

v：array_like

如果v是2-D数组，则返回其k对角线的副本。如果v是1-D数组，则在k对角线上返回具有v的2-D数组。

k：int，可选

有问题的对角线。默认值为0。对于主对角线上方的对角线使用k> 0，对于主对角线下方的对角线使用k 。

返回：

out：ndarray

提取的对角线或构造的对角数组。

x=np.arange(9).reshape(3,3)
np.diag(x)

array([0, 4, 8])

np.diag(x,k=1)

array([1, 5])

np.diag(x,k=-1)

array([3, 7])

np.diag(np.diag(x))

array([[0, 0, 0],
       [0, 4, 0],
       [0, 0, 8]])

numpy.dot(a, b, out=None)

两个数组的点积。

对于2-D数组，其等效于矩阵乘法，对于1-D数组等效于向量的内积（无共轭复数）。对于N维，它是a的最后一个轴和b的倒数第二个轴的积的和：

dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])

参数：

a：array_like

第一个参数。

b：array_like

第二个参数。

out：ndarray，可选

输出参数。如果没有使用，返回必须有确切的类型。特别地，它必须具有正确的类型，必须是C连续的，并且其dtype必须是dot(a,b)将返回的dtype。这是一个性能特性。因此，如果不满足这些条件，则引发异常，而不是试图灵活。

返回：

输出：ndarray

返回a和b的点积。如果a和b都是标量或都是1-D数组，则返回标量；否则返回一个数组。如果给出out，则返回。

引发：

ValueError

如果a的最后一个维度大小与b的倒数第二个维度的大小不同。

numpy.trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)

沿数组的对角线返回总和。

如果a是2-D，则返回具有给定偏移的沿其对角线的和，即对于所有i，元素a[i,i+offset]

如果a有两个以上的尺寸，则由axis1和axis2指定的轴用于确定返回其轨迹的2-D子数组。所得数组的形状与移除axis1和axis2的a的形状相同。

参数：

a：array_like

输入数组，从中获取对角线。

offset：int，可选

对角线与主对角线的偏移。可以是正面和负面。默认为0。

axis1，axis2：int，可选

轴将被用作应从中获取对角线的2-D子阵列的第一和第二轴。默认值是a的前两个轴。

dtype：dtype，可选

确定返回的数组和累加器元素的累加器的数据类型。如果dtype具有值None且a是小于默认整数精度的整数类型的精度，则使用缺省整数精度。否则，精度与a的精度相同。

out：ndarray，可选

数组，其中放置输出。它的类型被保留，并且它必须是保持输出的正确形状。

返回：

sum_along_diagonals：ndarray

如果a是2-D，则返回沿对角线的和。如果a具有较大的维，则返回沿对角线的和的数组。

还有几个其他的，比如：

det，计算矩阵行列式

inv，计算矩阵的逆

lstsq，计算Ax=B的最小二乘解

随机数的生成

numpy.random模块增加了一些 高效生成多种概率分布的样本值的函数，比如normal，可以得到一个标准正太分布的数组：

samples=np.random.normal(size=(4,4))
samples

array([[ 0.05362618, -1.44096904, -0.59506811, -1.14913339],
       [-0.82946896, -2.47470801, -0.25017015, -0.50970962],
       [-0.28899863,  0.98025628,  0.36890152, -0.26948141],
       [ 0.87736262,  1.43316428, -0.28441972,  0.81287675]])

还有其他的一些函数，比如：

rand，产生均匀分布的样本值

randint，从给定的上下限范围内随机选取整数

randn，产生正态分布（平均值为0，标准差为1）的样本。

如果您觉得感兴趣的话，可以添加我的微信公众号：一步一步学Python