第十二篇 pandas⾼級應⽤

前⾯部分關注於不一樣類型的數據規整流程和NumPy、pandas與其它庫的特色。隨着時間的發展，pandas發展出了更多適合⾼級⽤戶的功能。本篇就深⼊學習pandas的⾼級功能。

1、分類數據
接下來要說的是pandas的分類類型。經過使⽤它，可提⾼性能和內存的使⽤率。後面還會介紹⼀些在統計和機器學習中使⽤分類數據的⼯具。

一、背景和⽬的
表中的⼀列一般會有重複的包含不一樣值的⼩集合的狀況。前面已經學過了unique和value_counts，它們能夠從數組提取出不一樣的值，並分別計算頻率：
import numpy as np; import pandas as pd
values = pd.Series(['apple', 'orange', 'apple', 'apple'] *2 )
values                  # 輸出以下：
0      apple
1    orange
2      apple
3      apple
4      apple
5    orange
6      apple
7      apple
dtype: object
pd.unique(values)       # 輸出以下：惟一值
array(['apple', 'orange'], dtype=object)

pd.value_counts(values)             # 輸出以下：計數
apple      6
orange    2
dtype: int64

許多數據系統（數據倉庫、統計計算或其它應⽤）都發展出了特定的表徵重複值的⽅法，以進⾏⾼效的存儲和計算。在數據倉庫中，最好的⽅法是使⽤所謂的包含不一樣值的維表(Dimension Table)，將主要的參數存儲爲引⽤維表整數鍵：
values = pd.Series([0, 1, 0, 0] * 2)
dim = pd.Series(['apple', 'orange'])
values                  # 輸出以下：
0    0
1    1
2    0
3    0
4    0
5    1
6    0
7    0
dtype: int64
dim                     # 輸出以下：
0      apple
1    orange
dtype: object
能夠使⽤take⽅法存儲原始的字符串Series：
dim.take(values)                    # 輸出以下：apple對應0，orange對應1
0      apple
1    orange
0      apple
0      apple
0      apple
1    orange
0      apple
0      apple
dtype: object

這種⽤整數表示的⽅法稱爲分類或字典編碼表示法。不一樣值的數組稱爲分類、字典或數據級。在這裏，咱們使⽤分類的說法。表示分類的整數值稱爲分類編碼或簡單地稱爲編碼。

分類表示能夠在進⾏分析時⼤⼤的提⾼性能。你也能夠在保持編碼不變的狀況下，對分類進⾏轉換。⼀些相對簡單的轉變例⼦包括：
             重命名分類。
             加⼊⼀個新的分類，不改變已經存在的分類的順序或位置。

二、pandas的分類類型
pandas有⼀個特殊的分類類型，⽤於保存使⽤整數分類表示法的數據。看⼀個以前的Series例⼦：
fruits = ['apple', 'orange', 'apple', 'apple'] * 2
N = len(fruits)
df = pd.DataFrame({'fruit': fruits,
                                  'basket_id': np.arange(N),
                                  'count': np.random.randint(3, 15, size=N),
                                  'weight': np.random.uniform(0, 4, size=N)},
                                   columns=['basket_id', 'fruit', 'count', 'weight'])
df          # 輸出以下：
      basket_id      fruit  count     weight
0                0    apple         5  2.508993
1                1  orange         5  0.287797
2                2    apple       14  2.049163
3                3    apple       12  1.112467
4                4    apple         7  2.525591
5                5  orange         7  3.651966
6                6    apple         5  1.222066
7                7    apple       14  0.769359

這⾥，df['fruit']是⼀個Python字符串對象的數組。咱們能夠經過調⽤它，將它轉變爲分類：
fruit_cat = df['fruit'].astype('category')      # 使用astype設置類型
fruit_cat           # 輸出以下：
0      apple
1    orange
2      apple
3      apple
4      apple
5    orange
6      apple
7      apple
Name: fruit, dtype: category
Categories (2, object): [apple, orange]
fruit_cat的值不是NumPy數組，⽽是⼀個pandas.Categorical實例：
c = fruit_cat.values
type(c)                 # 輸出：pandas.core.arrays.categorical.Categorical

分類對象有categories和codes屬性：
c.categories            # 輸出：Index(['apple', 'orange'], dtype='object')
c.codes                 # 輸出：array([0, 1, 0, 0, 0, 1, 0, 0], dtype=int8)

你可將DataFrame的列經過分配轉換結果，轉換爲分類：
df['fruit'] = df['fruit'].astype('category')
df.fruit           # 輸出以下：（將fruit列轉換爲分類）
0      apple
1    orange
2      apple
3      apple
4      apple
5    orange
6      apple
7      apple
Name: fruit, dtype: category
Categories (2, object): [apple, orange]

你還能夠從其它Python序列直接建立pandas.Categorical：
my_categories = pd.Categorical(['foo', 'bar', 'baz', 'foo', 'bar'])
my_categories           # 輸出以下：
[foo, bar, baz, foo, bar]
Categories (3, object): [bar, baz, foo]

若是你已經從其它源得到了分類編碼，你還可使⽤from_codes構造器：
categories = ['foo', 'bar', 'baz']
codes = [0, 1, 2, 0, 0, 1]
my_cats_2 = pd.Categorical.from_codes(codes, categories)
my_cats_2               # 輸出以下：
[foo, bar, baz, foo, foo, bar]
Categories (3, object): [foo, bar, baz]

與顯式指定不一樣，分類變換不認定指定的分類順序。所以取決於輸⼊數據的順序，categories數組的順序會不一樣。當使⽤from_codes或其它的構造器時，你能夠指定分類⼀個有意義的順序：
ordered_cat = pd.Categorical.from_codes(codes, categories, ordered=True)
ordered_cat              # 輸出以下：
[foo, bar, baz, foo, foo, bar]
Categories (3, object): [foo < bar < baz]
輸出[foo < bar < baz]指明‘foo’位於‘bar’的前⾯，以此類推。⽆序的分類實例能夠經過as_ordered排序：
my_cats_2.as_ordered()              # 輸出以下：經過as_ordered()方法排序
[foo, bar, baz, foo, foo, bar]
Categories (3, object): [foo < bar < baz]

最後要注意，分類數據不須要字符串，儘管這裏僅僅展現了字符串的例⼦。分類數組能夠包括任意不可變類型。

三、⽤分類進⾏計算
與⾮編碼版本（⽐如字符串數組）相⽐，使⽤pandas的Categorical有些相似。某些pandas組件，⽐如groupby函數，更適合進⾏分類。還有⼀些函數可使⽤有序標誌位。

來看⼀些隨機的數值數據，使⽤pandas.qcut⾯元函數。它會返回pandas.Categorical，咱們以前使⽤過pandas.cut，但沒解釋分類是如何⼯做的：
np.random.seed(12345)
draws = np.random.randn(1000)
draws[:5]               # 輸出：array([-0.2047,  0.4789, -0.5194, -0.5557,  1.9658])

計算這個數據的分位⾯元，提取⼀些統計信息：
bins = pd.qcut(draws, 4)        # 平均分紅4個面元
bins                    # 輸出以下：
[(-0.684, -0.0101], (-0.0101, 0.63], (-0.684, -0.0101], (-0.684, -0.0101], (0.63, 3.928], ..., (-0.0101, 0.63], (-0.684, -0.0101], (-2.95, -0.684], (-0.0101, 0.63], (0.63, 3.928]]
Length: 1000
Categories (4, interval[float64]): [(-2.95, -0.684] < (-0.684, -0.0101] < (-0.0101, 0.63] < (0.63, 3.928]]

雖然有⽤，確切的樣本分位數與分位的名稱相⽐，不利於⽣成彙總。咱們能夠使⽤qcut的labels參數，實現⽬的：
bins = pd.qcut(draws, 4, labels=['Q1', 'Q2', 'Q3', 'Q4'])   # 指定各個面元的標籤
bins                    # 輸出以下：
[Q2, Q3, Q2, Q2, Q4, ..., Q3, Q2, Q1, Q3, Q4]
Length: 1000
Categories (4, object): [Q1 < Q2 < Q3 < Q4]
bins.codes[:10]         # 輸出：array([1, 2, 1, 1, 3, 3, 2, 2, 3, 3], dtype=int8)

加上標籤的⾯元分類不包含數據⾯元邊界的信息，所以可使⽤groupby提取⼀些彙總信息：
bins = pd.Series(bins, name='quartile')
results = (pd.Series(draws)
                  .groupby(bins)
                  .agg(['count', 'min', 'max'])
                  .reset_index())
results                 # 輸出以下：
   quartile  count           min          max
0       Q1      250 -2.949343 -0.685484
1       Q2      250 -0.683066 -0.010115
2       Q3      250 -0.010032  0.628894
3       Q4      250  0.634238  3.927528
分位數列保存了原始的⾯元分類信息，包括排序：
results['quartile']                 # 輸出以下：
0    Q1
1    Q2
2    Q3
3    Q4
Name: quartile, dtype: category
Categories (4, object): [Q1 < Q2 < Q3 < Q4]

四、⽤分類提⾼性能
若是你是在⼀個特定數據集上作⼤量分析，將其轉換爲分類能夠極⼤地提⾼效率。DataFrame列的分類使⽤的內存一般少的多。來看⼀些包含⼀千萬元素的Series，和⼀些不一樣的分類：
N = 10000000
draws = pd.Series(np.random.randn(N))
labels = pd.Series(['foo', 'bar', 'baz', 'qux'] * (N // 4))
如今，將標籤轉換爲分類：
categories = labels.astype('category')
這時，能夠看到標籤使⽤的內存遠⽐分類多：
labels.memory_usage()               # 標籤使用內存，輸出：80000080
categories.memory_usage()           # 分類使用內存，輸出：10000272

轉換爲分類不是沒有代價的，但這是⼀次性的代價：
%time _ = labels.astype('category')             # 輸出：Wall time: 562 ms
GroupBy操做明顯⽐分類快，是由於底層的算法使⽤整數編碼數組，⽽不是字符串數組。

五、分類⽅法
包含分類數據的Series有⼀些特殊的⽅法，相似於Series.str字符串⽅法。它還提供了⽅便的分類和編碼的使⽤⽅法。看下⾯的Series：
s = pd.Series(['a', 'b', 'c', 'd'] * 2)
cat_s = s.astype('category')
cat_s                   # 輸出以下：
0    a
1    b
2    c
3    d
4    a
5    b
6    c
7    d
dtype: category
Categories (4, object): [a, b, c, d]
特別的cat屬性提供了分類⽅法的⼊⼝：
cat_s.cat.codes
0    0
1    1
2    2
3    3
4    0
5    1
6    2
7    3
dtype: int8
cat_s.cat.categories                # 輸出：Index(['a', 'b', 'c', 'd'], dtype='object')

假設咱們知道這個數據的實際分類集，超出了數據中的四個值。咱們可使⽤set_categories⽅法改變它們：
actual_categories = ['a', 'b', 'c', 'd', 'e']        # 實際分類集
cat_s2 = cat_s.cat.set_categories(actual_categories)
cat_s2                  # 輸出以下：
0    a
1    b
2    c
3    d
4    a
5    b
6    c
7    d
dtype: category
Categories (5, object): [a, b, c, d, e]

雖然數據看起來沒變，新的分類將反映在它們的操做中。例如，若是有的話，value_counts表示分類：
cat_s.value_counts()    # 統計每一個分類的數量，輸出以下：
d    2
c    2
b    2
a    2
dtype: int64
cat_s2.value_counts()   # 輸出以下：
d    2
c    2
b    2
a    2
e    0
dtype: int64

在大數據集中，分類常常做爲節省內存和⾼性能的便捷⼯具。過濾完⼤DataFrame或Series以後，許多分類可能不會出如今數據中。咱們可使⽤remove_unused_categories⽅法刪除沒看到的分類：
cat_s3 = cat_s[cat_s.isin(['a', 'b'])]
cat_s3      # 輸出以下：
0    a
1    b
4    a
5    b
dtype: category
Categories (4, object): [a, b, c, d]
cat_s3.cat.remove_unused_categories()            # 輸出以下：（注意cat是入口）
0    a
1    b
4    a
5    b
dtype: category
Categories (2, object): [a, b]

表12-1列出了可⽤的分類⽅法。
表12-1 pandas的Series的分類⽅法（cat是這些方法的入口）
方法                                            說明
add_categories                          在已存在的分類後面添加新的（未使用的）分類
as_ordered                                 使分類有序
as_unordered                             使分類無序
remove_categories                    移除分類，設置任何被移除的值爲null
remove_unused_categories       移除任意不出如今數據中的分類值
rename_categories                     用指定的新分類的名字替換分類；不能改變分類的數目
reorder_categories                     與rename_categories很像，可是能夠改變結果，使分類有序
set_categories                            用指定的新分類的名字撿的分類；能夠添加或刪除分類

六、爲建模建立虛擬變量
當你使⽤統計或機器學習⼯具時，一般會將分類數據轉換爲虛擬變量，也稱爲one-hot編碼。這包括建立⼀個不一樣
類別的列的DataFrame；這些列包含給定分類的1s，其它爲0。

看前⾯的例⼦：
cat_s = pd.Series(['a', 'b', 'c', 'd'] * 2, dtype='category')
前⾯的第7篇提到過，pandas.get_dummies函數能夠轉換這個分類數據爲包含虛擬變量的DataFrame：
pd.get_dummies(cat_s)
     a  b  c  d
0  1  0  0  0
1  0  1  0  0
2  0  0  1  0
3  0  0  0  1
4  1  0  0  0
5  0  1  0  0
6  0  0  1  0
7  0  0  0  1

2、GroupBy⾼級應⽤
儘管在第10篇已經深度學習了Series和DataFrame的Groupby⽅法，還有⼀些⽅法也是頗有⽤的。

在第10篇，在分組操做中學習了apply⽅法，進⾏轉換。還有另⼀個transform⽅法，它與apply很像，可是對使
⽤的函數有⼀定限制：
             它能夠產⽣向分組形狀⼴播標量值
             它能夠產⽣⼀個和輸⼊組形狀相同的對象
             它不能修改輸⼊
來看⼀個簡單的例⼦：
df = pd.DataFrame({'key': ['a', 'b', 'c'] * 4,
                                  'value': np.arange(12.)})
df          # 輸出以下：
    key  value
0    a    0.0
1    b    1.0
2    c    2.0
3    a    3.0
4    b    4.0
5    c    5.0
6    a    6.0
7    b    7.0
8    c    8.0
9    a    9.0
10   b   10.0
11   c   11.0

按鍵進⾏分組平均：
g = df.groupby('key').value         # 將df數據按key列進行分組，值是value列
g.mean()
key
a    4.5
b    5.5
c    6.5
Name: value, dtype: float64

假設咱們想產⽣⼀個和df['value']形狀相同的Series，但值替換爲按鍵分組的平均值。咱們能夠傳遞函
數lambda x: x.mean()進⾏轉換：
g.transform(lambda x: x.mean())     # 輸出以下：
0     4.5
1     5.5
2     6.5
3     4.5
4     5.5
5     6.5
6     4.5
7     5.5
8     6.5
9     4.5
10    5.5
11    6.5
Name: value, dtype: float64

對於內置的聚合函數，咱們能夠傳遞⼀個字符串假名做爲GroupBy的agg⽅法：
g.transform('mean')     # 輸出以下：
0     4.5
1     5.5
2     6.5
3     4.5
4     5.5
5     6.5
6     4.5
7     5.5
8     6.5
9     4.5
10    5.5
11    6.5
Name: value, dtype: float64

與apply相似，transform的函數會返回Series，可是結果必須與輸⼊⼤⼩相同。舉個例⼦，咱們能夠⽤
lambda函數將每一個分組乘以2：
g.transform(lambda x: x * 2)        # 參數x對應每一個分組中的元素，輸出以下：
0      0.0
1      2.0
2      4.0
3      6.0
4      8.0
5     10.0
6     12.0
7     14.0
8     16.0
9     18.0
10    20.0
11    22.0
Name: value, dtype: float64

可進一步對不一樣分組的元素乘以不一樣的數字：
g.transform(lambda x: x * 2 if x.name == 'a' else x * 3 if x.name == 'b' else x * 4)    # 輸出以下：
0      0.0
1      3.0
2      8.0
3      6.0
4     12.0
5     20.0
6     12.0
7     21.0
8     32.0
9     18.0
10    30.0
11    44.0
Name: value, dtype: float64
上面的一行式代碼不便於閱讀，可定義一個函數實現相同的功能，函數定義以下：
def by(x):
         if x.name == 'a':
              return x * 2
         elif x.name == 'b':
              return x * 3
         elif x.name == 'c':
              return x * 4
g.transform(by)         # 輸出以下：輸出的結果與一行式代碼的結果同樣
0      0.0
1      3.0
2      8.0
3      6.0
4     12.0
5     20.0
6     12.0
7     21.0
8     32.0
9     18.0
10    30.0
11    44.0
Name: value, dtype: float64

再舉⼀個複雜的例⼦，咱們能夠計算每一個分組的降序排名：
g.transform(lambda x: x.rank(ascending=False))              # 輸出以下：
0     4.0
1     4.0
2     4.0
3     3.0
4     3.0
5     3.0
6     2.0
7     2.0
8     2.0
9     1.0
10    1.0
11    1.0
Name: value, dtype: float64

看⼀個由簡單聚合構造的分組轉換函數：
def normalize(x):
        return (x - x.mean()) / x.std()
咱們⽤transform或apply能夠得到等價的結果：
g.transform(normalize)              # 輸出以下：
0    -1.161895
1    -1.161895
2    -1.161895
3    -0.387298
4    -0.387298
5    -0.387298
6     0.387298
7     0.387298
8     0.387298
9     1.161895
10    1.161895
11    1.161895
Name: value, dtype: float64
g.apply(normalize)      # 輸出以下：
0    -1.161895
1    -1.161895
2    -1.161895
3    -0.387298
4    -0.387298
5    -0.387298
6     0.387298
7     0.387298
8     0.387298
9     1.161895
10    1.161895
11    1.161895
Name: value, dtype: float64

內置的聚合函數，⽐如mean或sum，一般⽐apply函數快，也⽐transform快。這容許咱們進⾏⼀個所謂的
解封（unwrapped）分組操做：
g.transform('mean')     # 輸出以下：
0     4.5
1     5.5
2     6.5
3     4.5
4     5.5
5     6.5
6     4.5
7     5.5
8     6.5
9     4.5
10    5.5
11    6.5
Name: value, dtype: float64

normalized = (df['value'] - g.transform('mean')) / g.transform('std')
normalized              # 輸出以下：與g.transform(normalize)的輸出同樣
0    -1.161895
1    -1.161895
2    -1.161895
3    -0.387298
4    -0.387298
5    -0.387298
6     0.387298
7     0.387298
8     0.387298
9     1.161895
10    1.161895
11    1.161895
Name: value, dtype: float64
解封分組操做可能包括多個分組聚合，可是⽮量化操做仍是會帶來收益。

二、分組的時間重採樣
對於時間序列數據，resample⽅法從語義上是⼀個基於內在時間的分組操做。下⾯是⼀個示例表：
N = 15
times = pd.date_range('2017-05-20 00:00', freq='1min', periods=N)
df = pd.DataFrame({'time': times, 'value': np.arange(N)})
df                      # 輸出以下：
                               time  value
0  2017-05-20 00:00:00      0
1  2017-05-20 00:01:00      1
2  2017-05-20 00:02:00      2
3  2017-05-20 00:03:00      3
4  2017-05-20 00:04:00      4
5  2017-05-20 00:05:00      5
6  2017-05-20 00:06:00      6
7  2017-05-20 00:07:00      7
8  2017-05-20 00:08:00      8
9  2017-05-20 00:09:00      9
10 2017-05-20 00:10:00     10
11 2017-05-20 00:11:00     11
12 2017-05-20 00:12:00     12
13 2017-05-20 00:13:00     13
14 2017-05-20 00:14:00     14

這⾥，咱們能夠⽤time做爲索引，而後重採樣：
df.set_index('time').resample('5min').count()   # 輸出以下：set_index()方法重設行索引
                                     value
time
2017-05-20 00:00:00      5
2017-05-20 00:05:00      5
2017-05-20 00:10:00      5

假設DataFrame包含多個時間序列，⽤⼀個額外的分組鍵的列進⾏標記：
df2 = pd.DataFrame({'time': times.repeat(3),
                                    'key': np.tile(['a', 'b', 'c'], N),
                                    'value': np.arange(N * 3.)})
times.repeat(3)方法對times列表中的每一個元素重複3次，np.tile(['a', 'b', 'c'], N)至關於['a', 'b', 'c'] * N
df2[:7]                 # 前7行輸出以下：
                              time key  value
0 2017-05-20 00:00:00   a    0.0
1 2017-05-20 00:00:00   b    1.0
2 2017-05-20 00:00:00   c    2.0
3 2017-05-20 00:01:00   a    3.0
4 2017-05-20 00:01:00   b    4.0
5 2017-05-20 00:01:00   c    5.0
6 2017-05-20 00:02:00   a    6.0

要對每一個key值進⾏相同的重採樣，咱們引⼊pandas.TimeGrouper對象：
time_key = pd.TimeGrouper('5min')
而後咱們設定時間索引，⽤key和time_key分組，而後聚合：
resampled = (df2.set_index('time')
                         .groupby(['key', time_key])
                         .sum())
resampled               # 輸出以下：
                                              value
key   time
a       2017-05-20 00:00:00   30.0
          2017-05-20 00:05:00  105.0
          2017-05-20 00:10:00  180.0
b       2017-05-20 00:00:00   35.0
          2017-05-20 00:05:00  110.0
          2017-05-20 00:10:00  185.0
c       2017-05-20 00:00:00   40.0
          2017-05-20 00:05:00  115.0
          2017-05-20 00:10:00  190.0
resampled.reset_index()             # 重設爲默認行索引
   key                          time  value
0   a 2017-05-20 00:00:00   30.0
1   a 2017-05-20 00:05:00  105.0
2   a 2017-05-20 00:10:00  180.0
3   b 2017-05-20 00:00:00   35.0
4   b 2017-05-20 00:05:00  110.0
5   b 2017-05-20 00:10:00  185.0
6   c 2017-05-20 00:00:00   40.0
7   c 2017-05-20 00:05:00  115.0
8   c 2017-05-20 00:10:00  190.0
使⽤TimeGrouper的限制是時間必須是Series或DataFrame的索引。

3、鏈式編程技術
當對數據集進⾏⼀系列變換時，你可能發現建立的多個臨時變量其實並無在分析中⽤到。看下⾯的例⼦：
df = load_data()
df2 = df[df['col2'] < 0]
df2['col1_demeaned'] = df2['col1'] - df2['col1'].mean()
result = df2.groupby('key').col1_demeaned.std()

雖然這⾥沒有使⽤真實的數據，這個例⼦卻指出了⼀些新⽅法。⾸先，DataFrame.assign⽅法是⼀個df[k] = v形式的函數式的列分配⽅法。它不是就地修改對象，⽽是返回新的修改過的DataFrame。所以，下⾯的語句是等價的：
# Usual non-functional way
df2 = df.copy()
df2['k'] = v
# Functional assign way
df2 = df.assign(k=v)
就地分配可能會⽐assign快，可是assign能夠⽅便地進⾏鏈式編程：
result = (df2.assign(col1_demeaned=df2.col1 - df2.col2.mean())
                .groupby('key')
                .col1_demeaned.std())
這裏使⽤外括號，這樣便於添加換⾏符。

使⽤鏈式編程時要注意，你可能會須要涉及臨時對象。在前⾯的例⼦中，咱們不能使⽤load_data的結果，直到它被賦值給臨時變量df。爲了這麼作，assign和許多其它pandas函數能夠接收相似函數的參數，即可調⽤對象（callable）。爲了展現可調⽤對象，看⼀個前⾯例⼦的⽚段：
df = load_data()
df2 = df[df['col2'] < 0]
它能夠重寫爲：
df = (load_data()
          [lambda x: x['col2'] < 0])
這⾥，load_data的結果沒有賦值給某個變量，所以傳遞到[ ]的函數在這⼀步被綁定到了對象。

咱們能夠把整個過程寫爲⼀個單鏈表達式：
result = (load_data()
                [lambda x: x.col2 < 0]
                .assign(col1_demeaned=lambda x: x.col1 - x.col1.mean())
                .groupby('key')
                .col1_demeaned.std())
是否將代碼寫成這種形式只是習慣⽽已，將它分開成若⼲步能夠提⾼可讀性。

一、管道⽅法
能夠⽤Python內置的pandas函數和⽅法，⽤帶有可調⽤對象的鏈式編程作許多⼯做。可是，有時你須要使⽤⾃⼰的函數，或是第三⽅庫的函數。這時就要⽤到管道⽅法。

看下⾯的函數調⽤：
a = f(df, arg1=v1)
b = g(a, v2, arg3=v3)
c = h(b, arg4=v4)
當使⽤接收、返回Series或DataFrame對象的函數式，你能夠調⽤pipe將其重寫：
result = (df.pipe(f, arg1=v1)
                .pipe(g, v2, arg3=v3)
                .pipe(h, arg4=v4))
f(df)和df.pipe(f)是等價的，可是pipe使得鏈式聲明更容易。

pipe的另⼀個有⽤的地⽅是提煉操做爲可復⽤的函數。看⼀個從列減去分組⽅法的例⼦：
g = df.groupby(['key1', 'key2'])
df['col1'] = df['col1'] - g.transform('mean')       # 注意先分組後纔可調用transform()方法

假設你想轉換多列，並修改分組的鍵。另外，你想⽤鏈式編程作這個轉換。下⾯就是⼀個⽅法：
def group_demean(df, by, cols):
        result = df.copy()
        g = df.groupby(by)
        for c in cols:
              result[c] = df[c] - g[c].transform('mean')
        return result
而後能夠寫爲：
result = (df[df.col1 < 0]
                .pipe(group_demean, ['key1', 'key2'], ['col1']))

4、總結： pandas和其它開源項目同樣，在不斷的變化和進步中，這裏重點是放在接下來幾年不會發生什麼改變且穩定的功能。進一步學習pandas，能夠閱讀官方文檔，並閱讀開發團隊發佈的更新文檔。 pandas官網：http://pandas.pydata.org/