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的集合函数