大數(shù)據(jù)一般是在“云”上玩的，但“云”都是要錢的，而且數(shù)據(jù)上上下下的也比較麻煩。所以，在本地電腦上快速處理數(shù)據(jù)的技能還是要的。

pandas

在比賽中學(xué)到的一個工具，本地可以在億級別的數(shù)據(jù)上進行聚合等操作。內(nèi)部的數(shù)據(jù)包括：
? Series：一維數(shù)組，每個元素有一個標(biāo)簽
? DataFrame：二維表格，可以看做Series的集合
? Panel：三維數(shù)據(jù)

數(shù)據(jù)的初始化

我們可以通過構(gòu)造函數(shù)來初始化，從下面的代碼中可以想象得到數(shù)據(jù)是樣子：

            
from pandas import Series, DataFrame

s = Series(data=[1, 2, 3], index=['a', 'b', 'c'])

df = DataFrame(
  data=[
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
  ],
  index=['i1', 'i2', 'i3'],
  columns=['c1', 'c2', 'c3']
)


          

如果源數(shù)據(jù)是格式比較好的CSV（或者是自己加工生成的中間數(shù)據(jù)），可以直接讀取：
df = pandas.read_csv("../volume.csv", header=0)

數(shù)據(jù)的更新

更新結(jié)構(gòu)

在定義完成之后可以對行、列進行增減（增減數(shù)據(jù)、修改結(jié)構(gòu)）：
? 增加列： ? df.insert(3, 'new_column', [4, 7, 10])
? df['c4'] = [4, 7, 10]

? 刪除列 ? df.pop('c1')
? df = df.drop('c1', axis=1)

? 增加行：一般不要動態(tài)的增加行，據(jù)說新能不高 ? df.loc['i4'] = [10, 11, 12]
? df.loc['i4'] = {'c1': 10, 'c2': 11, 'c3': 12}

? 刪除行： ? df = df.drop('i1', axis=0)

更新數(shù)據(jù)

我們可以精確修改單個位置的值：
? df['c1']['i1'] = 77
? df.ix[1, 2] = 66

合并數(shù)據(jù)

數(shù)據(jù)很多時候分布在不同的DataFrame中，要使用需要將他們進行合并，第一種方式是concat（基礎(chǔ)方法）：

            
import pandas as pd

df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
          'B': ['B0', 'B1', 'B2', 'B3'],
          'C': ['C0', 'C1', 'C2', 'C3'],
          'D': ['D0', 'D1', 'D2', 'D3']},
          index=[0, 1, 2, 3])

df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
          'B': ['B4', 'B5', 'B6', 'B7'],
          'C': ['C4', 'C5', 'C6', 'C7'],
          'D': ['D4', 'D5', 'D6', 'D7']},
          index=[4, 5, 6, 7])

result = pd.concat([df1, df2])


          

合并完的結(jié)果為：

            
  A  B  C  D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7

          

其參數(shù)含義如下：
? objs ：合并的數(shù)據(jù)（Series、DataFrame）
? axis ：合并軸方向，行(0)、列(1)
? join ：關(guān)聯(lián)類型（inner、outer）
? join_axes ：結(jié)果行，eg: pd.concat([df1, df2], axis=1, join_axes=[pd.Int64Index([1, 2, 3])])
? ignore_index ：是否忽略objs中傳入的索引
? keys ：來自不同表的index，每個表一個（ignore_index=True時不管用）
? levels ：不同層次的索引
? names ：不同層次的索引的名字
? verify_integrity ：檢查是否包含重復(fù)項（有一定的代價）
? copy ：是否賦值數(shù)據(jù)

另一個相對簡化點的操作是append（簡化版，好像沒啥特別的）：
result = df1.append(df2)

接著來看重點方法merge（將兩個表的數(shù)據(jù)進行融合）：

            
import pandas as pd

left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
           'A': ['A0', 'A1', 'A2', 'A3'],
           'B': ['B0', 'B1', 'B2', 'B3']})

right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
           'C': ['C0', 'C1', 'C2', 'C3'],
           'D': ['D0', 'D1', 'D2', 'D3']})

result = pd.merge(left, right, on='key')

print(result)


          

結(jié)果為（注意觀察與concat不一樣的地方）：?

            
  A  B key  C  D
0 A0 B0 K0 C0 D0
1 A1 B1 K1 C1 D1
2 A2 B2 K2 C2 D2
3 A3 B3 K3 C3 D3

          

方法的參數(shù)有：
? left、right ：將要進行關(guān)聯(lián)的兩個表
? how ：關(guān)聯(lián)方式（left、right、inner、outer）
? on ：實現(xiàn)關(guān)聯(lián)的列，不傳應(yīng)該是找相同列名
? left_on、right_on ：分別為left、right的關(guān)聯(lián)列，在列名不同時使用
? left_index、right_index ：是否用索引來關(guān)聯(lián)
? sort ：排序
? suffixes ：后綴
? copy ：是否復(fù)制數(shù)據(jù)

對應(yīng)的簡化版本為join方法：

            
import pandas as pd

left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
           'B': ['B0', 'B1', 'B2', 'B3']},
          index=['K0', 'K1', 'K2', 'K3'])

right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],
           'D': ['D0', 'D1', 'D2', 'D3']},
           index=['K0', 'K1', 'K2', 'K3'])

result = left.join(right)

print(result)


          

輸出為：

            
   A  B  C  D
K0 A0 B0 C0 D0
K1 A1 B1 C1 D1
K2 A2 B2 C2 D2
K3 A3 B3 C3 D3

          

數(shù)據(jù)的查詢和分析

基本查詢

精確查看單個位置數(shù)據(jù)的方法：
? df['c1']['i1']
? df.loc['i1']['c1'] （先行后列）
? df.iloc[1] （下標(biāo)操作）
? df.ix['i1'][1] 或 df.ix[0, 2] （隨意使用下標(biāo)或名稱）

通過切片的操作批量取出數(shù)據(jù)：
? df.loc['i1':'i2', ['c1', 'c2']]
? df.iloc[1:3, [1, 2]]
? df.ix[1:3, 0:2]

查看某行或某列：
? 行： df.loc['i1']
? 列： df['c1']

分組

分組（GroupBy）是最最基本的一個分析手段，看個例子：

            
import pandas as pd
import numpy as np

df = pd.DataFrame({'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
          'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
          'C': np.random.randn(8),
          'D': np.random.randn(8)})

result = df.groupby(['A'])

print(result.get_group('foo'))


          

其他分組形式：
? df.groupby('A')
? df.groupby(['A', 'B'])
? df.groupby(group_func, axis=1)
? df.groupby(level=0)
? df.groupby([pd.Grouper(level=0), 'A'])

可以對各組進行遍歷：

            
for name, group in result:
  print(name)
  print(group)

          

對分組的結(jié)果可以過濾：

df.groupby('A').B.filter(lambda x : len(x) > 1)

進一步對各個分組進行計算（結(jié)果太直觀，就不寫了）：
? df.groupby(['A', 'B']).sum()
? df.groupby(['A', 'B']).sum().reset_index()
? df.groupby(['A', 'B']).aggregate(np.sum)
? df.groupby(['A', 'B']).agg(np.sum)
? df.groupby(['A', 'B']).agg([np.sum, np.mean])
? df.groupby(['A', 'B']).agg([np.sum, np.mean]).rename(columns={'sum': 's', 'mean': 'm'})
? df.groupby(['A', 'B']).agg({'C': np.sum, 'D': np.mean})
? df.groupby(['A', 'B']).agg({'C': 'sum', 'D': 'mean'})

利用transform（類似的還有apply）可以對各個分組分別計算：

            
import pandas as pd
import numpy as np

df = pd.DataFrame(data={
  'A': [1, 1, 3],
  'B': [4, 5, 6],
  'C': [7, np.nan, 9]})

print(df.groupby('A')['B'].transform(lambda x : x - x.mean()))


          

輸出結(jié)果為：

            
0  -0.5
1  0.5
2  0.0
Name: B, dtype: float64

          

類似的，可以在分組上使用窗口函數(shù)：
? rolling
? resample
? expanding

條件過濾

用一些常用的構(gòu)造方式，可以有類似SQL的開發(fā)效率??：
? tips[tips['time'] == 'Dinner'].head(5)
? tips[(tips['time'] == 'Dinner') & (tips['tip'] > 5.00)]
? tips[(tips['size'] >= 5) | (tips['total_bill'] > 45)]
? frame[frame['col2'].isnull()]
? frame[frame['col1'].notnull()]

最后，如果想圖形化看在PyCharm里面需要搞個 plt.show() （其他的IDE并不清楚）。

numpy

比較早接觸的numpy，總體上來看處理數(shù)據(jù)比自帶類型方便些：
? np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])
? np.array((5, 6, 7, 8))

主要集中在數(shù)組、矩陣的處理上！是很多工具的基礎(chǔ)。