NumPy 学习第四篇：数组的基本操作

在数组中，用axis(轴)表示维度，对于三维数组，axis参数的取值通常有：

当axis=None时，表示把数组展开为一维数组；
当axis=0时，表示按照行（第一维）进行计算；
当axis=1时，表示按照列（第二维）进行计算；
当axis=2时，表示按照第三维度进行计算。

对NumPy的数组进行操作，可以修改数组的元素，对元素进行滚动，转置数组，和其他数组进行组合。

一，修改元素

数组元素的删除，追加和插入：

numpy.delete(arr, obj, axis=None)

numpy.append(arr, values, axis=None)

numpy.insert(arr, obj, values, axis=None)

参数注释：

obj是slice，是元素的索引

当要删除单个元素时：对于一维数组，是一个标量；对于二维数组，是一个数组。
要删除多个元素时：索引数组

举个例子，对于二维数组arr，axis=0表示按照行来删除，指定行的索引是1，表示把第二行(5,6,7,8)删除

>>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])

>>> arr

array([[ 1,  2,  3,  4],

       [ 5,  6,  7,  8],

       [ 9, 10, 11, 12]])

>>> np.delete(arr, 1, 0)

array([[ 1,  2,  3,  4],

       [ 9, 10, 11, 12]])

二，元素滚动

把数组中的元组滚动指定的偏移，在滚动时，首尾是相连的：

numpy.roll(a, shift, axis=None)

举个例子，把数组向后滚动两个偏移，把数组向前滚动两个偏移：

>>> x = np.arange(10)

>>> np.roll(x, 2)

array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])

>>> np.roll(x, -2)

array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])

三，类转置操作

数组的转置（Transpose）通过ndarray的属性T来获取：

>>> x = np.array([[1.,2.],[3.,4.]])

>>> x

array([[ 1.,  2.],

       [ 3.,  4.]])

>>> x.T

array([[ 1.,  3.],

       [ 2.,  4.]])

1，转置函数

变换数组的维度，对于二维数组，转置是把行坐标和列坐标互换：

numpy.transpose(a, axes=None)

对于多维数组，转置需要指定新转换的维度，比如，对于三维数组，用0、1、2表示各个维度，(1,0,2)表示：把列维度变换为行维度，把行维度变化为列维度，第三维度不变。

>>> x = np.ones((1, 2, 3))

>>> np.transpose(x, (1, 0, 2)).shape

(2, 1, 3)

2，互换维度

把数组的两个维度互换

numpy.swapaxes(a, axis1, axis2)

四，组合数组

一维数组相当于是1行N列的数组，当使用column_stack()时，该一维数组作为一个新列；当使用hstack()函数时，为原始数组新增N列；当使用vstack()函数时，为原始数组新增1行。

1，把一维数组作为列添加到二维数组中

tup是一个列，相当于二维数组新增一列：

numpy.column_stack(tup)

2，水平（按列）顺序堆叠数组

按列对原始数组进行扩展，tup中的每一列都作为原始数组的一列：

numpy.hstack(tup)

3，垂直（按行）顺序堆叠数组

按行对原始数组进行扩展，tup中的每一行都作为原始数组的一行：

numpy.vstack(tup)

举个例子，分别对数组进行列堆叠、水平堆叠和垂直堆叠：

>>> a = np.array((1,2,3))

>>> b = np.array((2,3,4))

>>> np.column_stack((a,b))

array([[1, 2],

       [2, 3],

       [3, 4]])

>>> np.hstack((a,b))

array([1, 2, 3, 2, 3, 4])

>>> np.vstack((a,b))

array([[1, 2, 3],

       [2, 3, 4]])

五，排序和条件逻辑

排序操作是按照特定字段的值进行排序，查找操作是指按照特定的条件对数组元素进行三值运算。

1，排序函数

sort(axis,kind)函数用于对数组进行排序，可以使用类方法numpy.sort()，返回的是数组的已排序的副本，而原始数组并没有改变；也可以使用对象方法ndarray.sort()，对原始数组排序。

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

参数注释：

a：所需排序的数组
axis：数组排序时的轴，axis=0按照行排序；axis=1按列排序，默认值是1
kind：数组排序时使用的方法，其中：kind= ′quicksort ′为快排；kind=′mergesort′ 为归并排序；kind=′heapsort′为堆排
axis指定排序的轴；kind指定排序算法，默认的排序算法是快速排序，np.sort()返回的是数组的已排序的副本，而就是排序则会修改数组本身。

举个例子，对数组进行排序：

a = np.array([[1, 2, 1]

             ,[1,1,0]])

r1=np.sort(a)

r2=np.sort(a,axis=0)

r3=np.sort(a,axis=1)

print('a.sort() = {0}\na.sort(axis=0) = {1}\na.sort(axis=1) ={2}'.format(r1,r2,r3))

2，查找函数

where()函数对每一个元素执行三值运算：当满足condition 时，返回x；否则，返回y

numpy.where(condition[, x, y])

举个例子，对于一维数组，当元素值小于5时，返回原值；当元素值大于5时，乘以10返回：

>>> a = np.arange(10)

>>> a

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> np.where(a < 5, a, 10*a)

array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])

六，获取索引的函数

获取索引的函数名都以arg为前缀，按照值排序，返回的是索引值；按照值获取最大值和最小值，返回索引值等。

1，argsort()函数

argsort()函数返回的是按照数组值从小到大的索引值，即返回的是索引值，索引值是按照元素值从小到大得到的。

x=np.array([1,4,3,-1,6,9])

y=np.argsort(x)

#output

array([3, 0, 2, 1, 4, 5], dtype=int64)

元素-1的值是最小的，其索引是3，因此，argsort()的返回列表中是第一个item。

argsort()函数是将x中的元素从小到大排列，提取其对应的index(索引)，然后输出到y，按照降序排序：

y=np.argsort(-x)

按照升序排序：

y=np.argsort(x)

2，最大值或最小值的索引

计算数组中最大值和最小值的索引：

argmax(axis)：返回最大值的索引
argmin(axis)：返回最小值的索引

举个例子，返回数组中最小值的索引：

a = np.array([[1, 2, 1]

             ,[1,1,0]])

r1=a.argmin()

r2=a.argmin(axis=0)

r3=a.argmin(axis=1)

print('a.argmin() = {0}\na.argmin(axis=0) = {1}\na.argmin(axis=1) ={2}'.format(r1,r2,r3))

3，argwhere()函数

返回非0数组元素的索引，

numpy.argwhere(a)

举个例子，对于一维数组，返回数组中非0元素的位置：

>>> x = np.arange(6).reshape(2,3)

>>> x

array([[0, 1, 2],

       [3, 4, 5]])

>>> np.argwhere(x>1)

array([[0, 2],

       [1, 0],

       [1, 1],

       [1, 2]])

4，返回非0值元素的索引

对于二维数组，nonzero()函数返回的是两个数组：第一个数组是列索引，第二个数组是行索引：

>>> x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])

>>> x

array([[3, 0, 0],

       [0, 4, 0],

       [5, 6, 0]])

>>> np.nonzero(x)

(array([0, 1, 2, 2]), array([0, 1, 0, 1]))

七，抽取元素

返回满足条件的数据元素，当参数condition为True，返回该位置的元素：

numpy.extract(condition, arr)

举个例子，extract()函数和掩码索引数组的功能相同：

>>> arr = np.arange(12).reshape((3, 4))

>>> arr

array([[ 0,  1,  2,  3],

       [ 4,  5,  6,  7],

       [ 8,  9, 10, 11]])

>>> condition = np.mod(arr, 3)==0

>>> condition

array([[ True, False, False,  True],

       [False, False,  True, False],

       [False,  True, False, False]])

>>> np.extract(condition, arr)

array([0, 3, 6, 9])

If condition is boolean:

>>>

>>> arr[condition]

array([0, 3, 6, 9])

八，数学和统计方法

NumPy内置数据分析常用的统计量：

mean()：计算元素的均值
median()：计算中位数
var()：计算元素的方差
std() ：计算元素标准差
max()：计算元素的最大值
min()：计算元素的最小值
ptp()：计算元素的取值范围，即最大值和最小值的差值
percentile()：计算百分位
quantile()：计算分为数
count_nonzero()：计数
cumsum：计算所有元素的累计和
cumprod：计算所有元素的累计积

1，求和

举个例子，创建一个二维数组，按照行和列分别求和：

a = np.array([[0, 2, 1]

              ,[0,1,0]])

r1=a.sum()

r2=a.sum(axis=0)

r3=a.sum(axis=1)

print('a.sum() = {0}\na.sum(axis=0) = {1}\na.sum(axis=1) ={2}'.format(r1,r2,r3))

2，求积

举个例子，创建一个二维数组，按照行和列分别求乘积：

a = np.array([[1, 2, 1]

             ,[1,1,0]])

r1=a.prod()

r2=a.prod(axis=0)

r3=a.prod(axis=1)

print('a.prod() = {0}\na.prod(axis=0) = {1}\na.prod(axis=1) ={2}'.format(r1,r2,r3))

3，计算数组的均值

计算数组的均值，或者某一个维度的均值：

a = np.array([[1, 2, 1]

             ,[1,1,0]])

r1=a.mean()

r2=a.mean(axis=0)

r3=a.mean(axis=1)

print('a.mean() = {0}\na.mean(axis=0) = {1}\na.mean(axis=1) ={2}'.format(r1,r2,r3))

4，统计非0元素的个数

作为示例，考虑只包含1和0的一维向量中，统计从0 到 1 转换的数量，在矢量化形式中，没有明确的for循环或直接引用各个元素：

>>> np.count_nonzero(x[:-1] < x[1:])

九，vectorize 向量化和 apply函数

1，vectorize

numpy.vectorize()函数定义一个向量化函数，它以序列或numpy数组作为输入，对numpy数组做向量化操作。函数输出的数据类型是由otypes参数确定的，如果otypes=None，那么输出的数据类型是通过使用输入的第一个元素调用函数来确定的，该函数返回一个函数对象。

numpy.vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False, signature=None)

参数注释：

pyfunc：函数对象
otype：输出数据的类型（putput data type）

使用vectorize()定义一个向量化函数，对数组做向量化操作：

def myfunc(a, b):

    return a-b if a>b else a+b

vfunc = np.vectorize(myfunc)

vfunc([1, 2, 3, 4], 2)

#output array([3, 4, 1, 2])

2，apply

沿着特定的维度，在一维数组切片上应用函数：

numpy.apply_along_axis(func1d, axis, arr, *args, **kwargs)

举个例子，传递的一维数组是列，按照列值计算两个端点的均值：

>>> def my_func(a):

...     """Average first and last element of a 1-D array"""

...     return (a[0] + a[-1]) * 0.5

>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])

>>> np.apply_along_axis(my_func, 0, b)

array([4., 5., 6.])

参考文档：

Numpy参考手册

NumPy 数组操作