初识数据分析之NumPy 笔记四利用数组进行数据处理

来源：《利用Python进行数据分析·第2版》

NumPy数组使你可以将许多种数据处理任务表述为简洁的数组表达式（否则需要编写循环）。用数组表达式代替循环的做法，通常被称为矢量化。一般来说，矢量化数组运算要比等价的纯Python方式快上一两个数量级（甚至更多），尤其是各种数值计算。在后面内容中（见附录A）我将介绍广播，这是一种针对矢量化计算的强大手段。

作为简单的例子，假设我们想要在一组值（网格型）上计算函数sqrt(x^2+y^2)。np.meshgrid函数接受两个一维数组，并产生两个二维矩阵（对应于两个数组中所有的(x,y)对）：

In [32]: points = np.arange(-5, 5, 0.01)

In [33]: xs, ys = np.meshgrid(points, points)

In [34]: xs
Out[34]:
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]])

In [35]: z = np.sqrt(xs ** 2 + ys ** 2)

In [36]: z
Out[36]:
array([[7.07106781, 7.06400028, 7.05693985, ..., 7.04988652, 7.05693985,
        7.06400028],
       [7.06400028, 7.05692568, 7.04985815, ..., 7.04279774, 7.04985815,
        7.05692568],
       [7.05693985, 7.04985815, 7.04278354, ..., 7.03571603, 7.04278354,
        7.04985815],
       ...,
       [7.04988652, 7.04279774, 7.03571603, ..., 7.0286414 , 7.03571603,
        7.04279774],
       [7.05693985, 7.04985815, 7.04278354, ..., 7.03571603, 7.04278354,
        7.04985815],
       [7.06400028, 7.05692568, 7.04985815, ..., 7.04279774, 7.04985815,
        7.05692568]])

作为第9章的先导，我用matplotlib创建了这个二维数组的可视化：

In [42]: plt.imshow(z, cmap=plt.cm.gray); plt.colorbar();plt.title("Image plot of $\sqrt{x^2 + y^2}$ for a grid of valu
    ...: es")
Out[42]: Text(0.5, 1.0, 'Image plot of $\\sqrt{x^2 + y^2}$ for a grid of values')

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

numpy.where函数是三元表达式x if condition else y的矢量化版本。假设我们有一个布尔数组和两个值数组：

In [43]: xarray = np.array([1.1, 1.2, 1.3, 1.4, 1.5])

In [44]: yarray = np.array([2.1, 2.2, 2.3, 2.4, 2.5])

In [45]: barray = np.array([True, False, True, True, False])

假设我们想要根据barray中的值选取xarray和yarray的值：当barray中的值为True时，选取xarray的值，否则从yarray中选取。列表推导式的写法应该如下所示：

In [46]: result = [(x if c else y) for x, y, c in zip(xarray, yarray, barray)]

In [47]: result
Out[47]: [1.1, 2.2, 1.3, 1.4, 2.5]

这有几个问题。第一，它对大数组的处理速度不是很快（因为所有工作都是由纯Python完成的）。第二，无法用于多维数组。若使用np.where，则可以将该功能写得非常简洁：

In [48]: result = np.where(barray, xarray, yarray)

In [49]: result
Out[49]: array([1.1, 2.2, 1.3, 1.4, 2.5])

np.where的第二个和第三个参数不必是数组，它们都可以是标量值。在数据分析工作中，where通常用于根据另一个数组而产生一个新的数组。假设有一个由随机数据组成的矩阵，你希望将所有正值替换为2，将所有负值替换为－2。若利用np.where，则会非常简单：

In [52]: arr = np.random.randn(4, 4)

In [53]: arr > 0
Out[53]:
array([[False, False,  True, False],
       [ True,  True,  True,  True],
       [ True, False, False, False],
       [False,  True,  True, False]])

In [54]: np.where(arr > 0, 2, -2)
Out[54]:
array([[-2, -2,  2, -2],
       [ 2,  2,  2,  2],
       [ 2, -2, -2, -2],
       [-2,  2,  2, -2]])

使用np.where，可以将标量和数组结合起来。例如，我可用常数2替换arr中所有正的值：

In [55]: np.where(arr > 0, 2, arr)
Out[55]:
array([[-0.64868774, -0.68561237,  2.        , -0.44420915],
       [ 2.        ,  2.        ,  2.        ,  2.        ],
       [ 2.        , -1.24072253, -0.72606515, -1.30994285],
       [-0.10950203,  2.        ,  2.        , -0.84251097]])

传递给where的数组大小可以不相等，甚至可以是标量值。

数学和统计方法

可以通过数组上的一组数学函数对整个数组或某个轴向的数据进行统计计算。sum、mean以及标准差std等聚合计算（aggregation，通常叫做约简（reduction））既可以当做数组的实例方法调用，也可以当做顶级NumPy函数使用。

这里，我生成了一些正态分布随机数据，然后做了聚类统计：

In [56]: arr = np.random.randn(5, 4)

In [57]: arr
Out[57]:
array([[-0.13698683, -0.68898683, -1.57694868, -0.84437504],
       [ 0.0503132 , -0.53795413, -1.43021798, -0.71806937],
       [-2.07696464,  0.40763558,  0.0700437 ,  0.6469811 ],
       [ 0.26435637, -0.82612876,  1.1631518 , -0.86294485],
       [ 2.11892756,  1.14215785, -0.89275197,  0.83300835]])

In [58]: arr.mean()
Out[58]: -0.19478767772310776

In [59]: np.mean(arr)
Out[59]: -0.19478767772310776

In [60]: arr.sum()
Out[60]: -3.8957535544621553

mean和sum这类的函数可以接受一个axis选项参数，用于计算该轴向上的统计值，最终结果是一个少一维的数组

In [61]: arr.mean(axis=1)
Out[61]: array([-0.81182435, -0.65898207, -0.23807606, -0.06539136,  0.80033545])

In [62]: arr.mean(axis=0)
Out[62]: array([ 0.04392913, -0.10065526, -0.53334462, -0.18907996])

这里，arr.mean(1)是“计算行的平均值”，arr.sum(0)是“计算每列的和”。

其他如cumsum和cumprod之类的方法则不聚合，而是产生一个由中间结果组成的数组：

In [63]: arr = np.array([0, 1, 2, 3, 4, 5, 6, 7])

In [65]: arr.cumsum()
Out[65]: array([ 0,  1,  3,  6, 10, 15, 21, 28], dtype=int32)

在多维数组中，累加函数（如cumsum）返回的是同样大小的数组，但是会根据每个低维的切片沿着标记轴计算部分聚类：

In [66]: arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])

In [67]: arr
Out[67]:
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

In [68]: arr.cumsum(0)
Out[68]:
array([[ 0,  1,  2],
       [ 3,  5,  7],
       [ 9, 12, 15]], dtype=int32)

In [69]: arr.cumprod(1)
Out[69]:
array([[  0,   0,   0],
       [  3,  12,  60],
       [  6,  42, 336]], dtype=int32)

表4-5列出了全部的基本数组统计方法。后续章节中有很多例子都会用到这些方法。

用于布尔型数组的方法

在上面这些方法中，布尔值会被强制转换为1（True）和0（False）。因此，sum经常被用来对布尔型数组中的True值计数：

In [70]: arr = np.random.randn(100)

In [72]: (arr > 0).sum()
Out[72]: 47

另外还有两个方法any和all，它们对布尔型数组非常有用。any用于测试数组中是否存在一个或多个True，而all则检查数组中所有值是否都是True：

In [75]: bools = np.array([False, False, True, False])

In [77]: bools.any()
Out[77]: True

In [78]: bools.all()
Out[78]: False

这两个方法也能用于非布尔型数组，所有非0元素将会被当做True。

排序

跟Python内置的列表类型一样，NumPy数组也可以通过sort方法就地排序：

In [79]: arr = np.random.randn(6)

In [81]: arr
Out[81]:
array([ 0.63427572,  0.04814447, -1.13207785, -0.42835625,  0.61697646,
        0.09989434])

In [82]: arr.sort()

In [83]: arr
Out[83]:
array([-1.13207785, -0.42835625,  0.04814447,  0.09989434,  0.61697646,
        0.63427572])

多维数组可以在任何一个轴向上进行排序，只需将轴编号传给sort即可：

In [84]: arr = np.random.randn(5, 3)

In [85]: arr
Out[85]:
array([[-0.28343119,  0.49895658,  1.65050701],
       [ 1.24277025, -1.38272319,  2.47883728],
       [-1.13165737,  0.87023973, -0.69990792],
       [-0.96779917,  1.35065476,  0.18175059],
       [-0.45450932,  0.44279422,  1.08453099]])

In [86]: arr.sort(1)

In [87]: arr
Out[87]:
array([[-0.28343119,  0.49895658,  1.65050701],
       [-1.38272319,  1.24277025,  2.47883728],
       [-1.13165737, -0.69990792,  0.87023973],
       [-0.96779917,  0.18175059,  1.35065476],
       [-0.45450932,  0.44279422,  1.08453099]])

顶级方法np.sort返回的是数组的已排序副本，而就地排序则会修改数组本身。计算数组分位数最简单的办法是对其进行排序，然后选取特定位置的值：（分位数（Quantile），亦称分位点，是指将一个随机变量的概率分布范围分为几个等份的数值点，常用的有中位数（即二分位数）、四分位数、百分位数等。）

In [88]: large_arr = np.random.randn(1000)

In [89]: large_arr.sort()

In [90]: large_arr[int(0.05 * len(large_arr))]
Out[90]: -1.6206549154167182

唯一化以及其它的集合逻辑

NumPy提供了一些针对一维ndarray的基本集合运算。最常用的可能要数np.unique了，它用于找出数组中的唯一值并返回已排序的结果：

In [91]: names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])

In [93]: np.unique(names)
Out[93]: array(['Bob', 'Joe', 'Will'], dtype='<U4')

In [94]: ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])

In [95]: np.unique(ints)
Out[95]: array([1, 2, 3, 4])

另一个函数np.in1d用于测试一个数组中的值在另一个数组中的成员资格，返回一个布尔型数组：

In [96]: values = np.array([6, 0, 0, 3, 2, 5, 6])

In [98]: np.in1d(values, [2, 3, 6])
Out[98]: array([ True, False, False,  True,  True, False,  True])

NumPy中的集合函数请参见表4-6。