numpy利用数组进行数据处理

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

numpy.where()是一个三目运算的表达式

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

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

In [36]: condi = np.array([True,False,True,True,False])

假设有上面三个数组，当condi中的值为True的时候，从xarr中选取值，否则从yarr中选取值，组成一个新的数组。利用普通的列表推导式如下：

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

但是这种方式有缺点：在进行大量数据处理的时候，速度并不快（速度慢就是python的“特色”）。无法运用到多维数组中。

用where方法就简单好多了

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

numpy.where的第二个和第三个参数，不一定非得是数组，它们也可以是标量。

假设我们希望根据condi生成一个新的数组，如果condi中的值为True时，选择数字1，否则为数字0。

In [41]: res = np.where(condi,1,0)

In [42]: res
Out[42]: array([1, 0, 1, 1, 0])

在一个多维数组中，用“+”代替正数，“-”代替负数

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

In [47]: arr
Out[47]:
array([[-0.33641281, -0.56924078,  0.25727917, -0.35087934],
       [-0.00734107, -0.47985579, -1.35289703, -1.31366566],
       [-0.71342875, -0.21957414, -1.25596815,  0.0859283 ],
       [-0.93246019, -0.61227975, -0.87573005,  1.4124276 ]])

In [48]: np.where(arr>0,"+","-")
Out[48]:
array([['-', '-', '+', '-'],
       ['-', '-', '-', '-'],
       ['-', '-', '-', '+'],
       ['-', '-', '-', '+']], dtype='<U1')

where还可以实现多条件运算

In [51]: np.where(cond1 &cond2 ,0, np.where(cond1,1,np.where(cond2,2,3)))

#类似于
li=[]
for x,y in zip(cond1,cond2):
    if x and y:
        li.append(0)
    elif x :
        li.append(1)
    elif y:
        li.append(2)
    else:
        li.append(3)

数学和统计方法

sum、mean、std 既可以作为数组的方法调用，也可以作为NumPy的顶级函数调用。

In [63]: arr = np.arange(15).reshape(3,5)

In [64]: arr
Out[64]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
#作为数组的方法调用
In [65]: arr.sum()
Out[65]: 105
In [67]: arr.mean()
Out[67]: 7.0
#作为numpy的顶级方法调用
In [68]: np.mean(arr)
Out[68]: 7.0

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

In [69]: arr = np.arange(60).reshape(3,4,5)

In [70]: arr
Out[70]:
array([[[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14],
        [15, 16, 17, 18, 19]],

       [[20, 21, 22, 23, 24],
        [25, 26, 27, 28, 29],
        [30, 31, 32, 33, 34],
        [35, 36, 37, 38, 39]],

       [[40, 41, 42, 43, 44],
        [45, 46, 47, 48, 49],
        [50, 51, 52, 53, 54],
        [55, 56, 57, 58, 59]]])

In [71]: arr.sum(axis = 1)#参数的值为shape的索引，不了解shape可以去看一下numpy基础知识那一篇blog
Out[71]:
array([[ 30,  34,  38,  42,  46],
       [110, 114, 118, 122, 126],
       [190, 194, 198, 202, 206]])

sum（axis=1）将指定的维度的数组进行聚合求和

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

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

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

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

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

In [76]: arr.cumsum(1)
Out[76]:
array([[ 0,  1,  3],
       [ 3,  7, 12],
       [ 6, 13, 21]], dtype=int32)

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

作为顶级函数的用法

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

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

用于布尔型数组的方法：sum、any和all

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

In [83]: bools.sum()
Out[83]: 3

In [84]:

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

In [85]: bools.all()
Out[85]: False
#顶级函数
In [86]: np.all(bools)
Out[86]: False

In [87]: np.sum(bools)
Out[87]: 3

In [88]:

排序

方法基本跟python的list一样

In [93]: arr = np.random.randn(8)

In [94]: arr
Out[94]:
array([-2.97429771,  0.37645009, -0.04291609, -0.61994895, -0.26251303,
       -1.1557209 , -0.19910847, -0.11393288])

In [95]: arr.sort()

In [96]: arr
Out[96]:
array([-2.97429771, -1.1557209 , -0.61994895, -0.26251303, -0.19910847,
       -0.11393288, -0.04291609,  0.37645009])

对于多维数组，可以指定axis参数，用于任意一个轴向上排序

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

In [98]: arr
Out[98]:
array([[-0.78510617, -0.02370449, -0.12615757, -0.15039283, -1.00503264],
       [ 0.24344011, -1.91231612,  0.80572501, -0.6740432 , -1.62471378],
       [-0.09096377,  1.79134715, -0.28566318, -0.8119145 , -0.20454602],
       [ 0.02648784,  0.57795444, -0.53447708, -0.74497177, -0.04684859]])

In [99]: arr.sort(1)

In [100]: arr
Out[100]:
array([[-1.00503264, -0.78510617, -0.15039283, -0.12615757, -0.02370449],
       [-1.91231612, -1.62471378, -0.6740432 ,  0.24344011,  0.80572501],
       [-0.8119145 , -0.28566318, -0.20454602, -0.09096377,  1.79134715],
       [-0.74497177, -0.53447708, -0.04684859,  0.02648784,  0.57795444]])

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

In [102]: arr
Out[102]:
array([[-0.99257127,  0.36384095,  1.14265096,  0.23094948,  1.42900315],
       [ 0.07606583,  1.53456921,  1.15069057, -0.78014895, -0.24934741],
       [ 0.63191444,  0.23237672,  0.4590821 ,  0.01904812,  1.63680472],
       [-1.24936364, -0.44730791, -0.30612594, -1.05307121,  1.28685507]])

In [103]: arr.sort(0)

In [104]: arr
Out[104]:
array([[-1.24936364, -0.44730791, -0.30612594, -1.05307121, -0.24934741],
       [-0.99257127,  0.23237672,  0.4590821 , -0.78014895,  1.28685507],
       [ 0.07606583,  0.36384095,  1.14265096,  0.01904812,  1.42900315],
       [ 0.63191444,  1.53456921,  1.15069057,  0.23094948,  1.63680472]])

需要注意的是顶级排序函数，返回的数组以排序的副本，而就地排序则会修改数组本身。

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

In [106]: arr_repeat=np.sort(arr,axis =1)

In [107]: arr_repeat
Out[107]:
array([[-0.64056336,  0.14082859,  0.44317426,  0.60988308,  0.77472024],
       [-1.63521891,  0.39869871,  0.55635461,  0.58039867,  0.59073797],
       [-1.62714899, -0.66642289, -0.16457651,  0.09046719,  0.5139126 ],
       [-0.79493979,  0.12287039,  0.50570075,  1.08870126,  1.34838367]])

In [108]: arr
Out[108]:
array([[ 0.60988308,  0.44317426,  0.14082859,  0.77472024, -0.64056336],
       [ 0.59073797,  0.55635461,  0.58039867, -1.63521891,  0.39869871],
       [-0.16457651, -1.62714899, -0.66642289,  0.5139126 ,  0.09046719],
       [ 0.50570075,  1.34838367,  0.12287039,  1.08870126, -0.79493979]])

sort还有两个参数kind和order，kind是指定排序的算法，默认是快排，还有堆排序和归并排序 【quicksort,mergesort,heapsort】。order：一个字符串或列表，可以设置按照某个属性进行排序

import numpy as np
>>> dtype = [('Name', 'S10'), ('Height', float), ('Age', int)]
>>> values = [('Li', 1.8, 41), ('Wang', 1.9, 38),('Duan', 1.7, 38)]
>>> a = np.array(values, dtype=dtype)
>>> np.sort(a, order='Height')  # 按照属性Height进行排序,此时参数为字符串                      
array([('Duan', 1.7, 38), ('Li', 1.8, 41),('Wang', 1.9, 38)],
      dtype=[('Name', '|S10'), ('Height', '<f8'), ('Age', '<i4')])
>>> np.sort(a, order=['Age', 'Height']) 
# 先按照属性Age排序,如果Age相等，再按照Height排序，此时参数为列表        
array([('Duan', 1.7, 38), ('Wang', 1.9, 38),('Li', 1.8, 41)],
      dtype=[('Name', '|S10'), ('Height', '<f8'), ('Age', '<i4')])

唯一化以及其他的一些集合逻辑运算

唯一化其实就是去重。ufunc是 numpy.unique()

In [119]: my_list = np.array([1,3,4,6,7,4,3,1,2])

In [120]: np.unique(my_list)
Out[120]: array([1, 2, 3, 4, 6, 7])

注意：数组本身没有unique方法。

numpy的集合函数