數據規(guī)整化：清理薪伏、轉化、合并粗仓、重塑

合并數據集

• pandas.merge 可根據一個或多個鍵將不同 DataFrame 中的行連接起來嫁怀。
• pandas.concat 可以沿著一條軸將多個對象堆疊到一起
• 實例方法 combine_first 可以用一個對象中的值填充另一個對象中對應位置的缺失值

數據庫風格的 DataFrame 合并

數據集的合并（merge）和連接（join）運算時通過一個或多個鍵將行鏈接起來的。

df1 = DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
                 'data1': range(7)})
df2 = DataFrame({'key': ['a', 'b', 'd'],
                 'data2': range(3)})
df1
Out:
    data1   key
0   0   b
1   1   b
2   2   a
3   3   c
4   4   a
5   5   a
6   6   b

df2
Out:
    data2   key
0   0   a
1   1   b
2   2   d

pd.merge(df1, df2)
Out:
    data1   key data2
0   0   b   1
1   1   b   1
2   6   b   1
3   2   a   0
4   4   a   0
5   5   a   0

我們并沒有指定要用哪個列進行連接借浊，如果沒有指定塘淑，merge 就會將重疊列的列名當做鍵，但最好還是指定一下：

pd.merge(df1, df2, on='key')

如果兩個對象的列名不同蚂斤，可以分別指定：

df3 = DataFrame({'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
                 'data1': range(7)})
df4 = DataFrame({'rkey': ['a', 'b', 'd'],
                 'data2': range(3)})
pd.merge(df3, df4, left_on='lkey', right_on='rkey')
Out:
    data1   lkey    data2   rkey
0   0   b   1   b
1   1   b   1   b
2   6   b   1   b
3   2   a   0   a
4   4   a   0   a
5   5   a   0   a

默認情況下存捺，merge 做的是 inner 連接；結果中的鍵是交集曙蒸。其他方式還有 left捌治、right 以及 outer。

pd.merge(df1, df2, how='outer')
Out:
    data1   key data2
0   0   b   1
1   0   b   3
2   1   b   1
3   1   b   3
4   5   b   1
5   5   b   3
6   2   a   0
7   2   a   2
8   4   a   0
9   4   a   2
10  3   c   NaN
11  NaN d   4

要根據多個鍵進行合并纽窟，傳入一個由列名組成的列表即可：

left = DataFrame({'key1': ['foo', 'foo', 'bar'],
                  'key2': ['one', 'two', 'one'],
                  'lval': [1, 2, 3]})
right = DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'],
                   'key2': ['one', 'one', 'one', 'two'],
                   'rval': [4, 5, 6, 7]})
pd.merge(left, right, on=['key1', 'key2'], how='outer')
Out:
    key1    key2    lval    rval
0   foo one 1   4
1   foo one 1   5
2   foo two 2   NaN
3   bar one 3   6
4   bar two NaN 7

對于合并運算要考慮的最后一個問題室對重復列名的處理具滴，merge 有一個使用的 suffixes 選項，用于指定附加到左右兩個 DataFrame 對象的重疊列名上的字符串：

pd.merge(left, right, on='key1')
Out:
    key1    key2_x  lval    key2_y  rval
0   foo one 1   one 4
1   foo one 1   one 5
2   foo two 2   one 4
3   foo two 2   one 5
4   bar one 3   one 6
5   bar one 3   two 7

pd.merge(left, right, on='key1', suffixes=('_left', '_right'))
Out:
    key1    key2_left   lval    key2_right  rval
0   foo one         1   one         4
1   foo one         1   one         5
2   foo two         2   one         4
3   foo two         2   one         5
4   bar one         3   one         6
5   bar one         3   two         7

merge 函數的參數

索引上的合并

可以傳入 left_index=True 或 right_index=True 以說明索引應該被用作連接鍵：

left1 = DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'],
                  'value': range(6)})
right1 = DataFrame({'group_val': [3.5, 7]}, index=['a', 'b'])
left
Out:
    key value
0   a   0
1   b   1
2   a   2
3   a   3
4   b   4
5   c   5

right
Out:
    group_val
a   3.5
b   7.0

pd.merge(left1, right1, left_on='key', right_index=True)
Out:
    key value   group_val
0   a   0   3.5
2   a   2   3.5
3   a   3   3.5
1   b   1   7.0
4   b   4   7.0

軸向連接

NumPy 有一個用于合并原始 NumPy 數組的 concatenation 函數：

arr = np.arange(12).reshape((3, 4))
arr
Out:
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

np.concatenate([arr, arr], axis=1)
Out:
array([[ 0,  1,  2,  3,  0,  1,  2,  3],
       [ 4,  5,  6,  7,  4,  5,  6,  7],
       [ 8,  9, 10, 11,  8,  9, 10, 11]])

對于 pandas 對象（如 Seri 和 DataFrame）瘸洛，帶有標簽的軸能夠進一步推廣數組的連接運算揍移。具體來說，需要考慮一下問題：

• 如果各對象其他軸上的索引不同反肋，那些軸應該是做并集還是交集那伐？
• 結果對象中的分組需要各不相同嗎？
• 用于連接的軸重要嗎石蔗？

pandas 的 concat 函數提供了一種能夠解決這些問題的可靠方式罕邀。假設三個沒有重疊索引的 Series：

s1 = Series([0, 1], index=['a', 'b'])
s2 = Series([2, 3, 4], index=['c', 'd', 'e'])
s3 = Series([5, 6], index=['f', 'g'])
pd.concat([s1, s2, s3])

Out:
a    0
b    1
c    2
d    3
e    4
f    5
g    6
dtype: int64

默認情況下，concat 是在 axis = 0 上工作的养距，如果傳入 axis = 1诉探，則結果會變成一個 DataFrame：

pd.concat([s1,s2,s3],axis=1)

Out:
    0   1   2
a   0   NaN NaN
b   1   NaN NaN
c   NaN 2   NaN
d   NaN 3   NaN
e   NaN 4   NaN
f   NaN NaN 5
g   NaN NaN 6

這種情況下，另外一條軸上沒有重疊棍厌，從索引的有序并集上就可以看出來肾胯。傳入 join = 'inner' 即可得到它們的交集：

s4 = pd.concat([s1 * 5, s3])
pd.concat([s1, s4], axis=1)
Out:
    0   1
a   0   0
b   1   5
f   NaN 5
g   NaN 6

pd.concat([s1, s4], axis=1, join='inner')
Out:
    0   1
a   0   0
b   1   5
```
對于 DataFrame 來說：
```python
df1 = DataFrame(np.arange(6).reshape(3, 2), index=['a', 'b', 'c'],
                columns=['one', 'two'])
df2 = DataFrame(5 + np.arange(4).reshape(2, 2), index=['a', 'c'],
                columns=['three', 'four'])
pd.concat([df1, df2], axis=1, keys=['level1', 'level2'])
# 或者 pd.concat({'level1': df1, 'level2': df2}, axis=1)

Out:
    level1  level2
one two three   four
a   0   1   5   6
b   2   3   NaN NaN
c   4   5   7   8
```

> concat 函數的參數

參數 | 說明
--- | ---
objs | 參與連接的 pandas 對象的列表或字典。
axis | 指明連接的軸向定铜，默認為0
join | “inner”阳液、“outer”其中之一，默認為“outer”
join_axes | 指明用于其他 n-1 條軸的索引揣炕，不執(zhí)行并集/交集運算
keys | 與連接對象有關的值帘皿，用于形成連接軸向上的層次索引』福可以是任意值得列表或數組鹰溜、元組數組、數組列表（如果 levels 設置成多級數據的話）
levels | 指定用作層次化級別的名稱丁恭，如果設置了keys和（或）levels的話
verify_integrity | 檢查結果對象新軸上的重復情況曹动，如果發(fā)現則引發(fā)一場。默認（False）允許重復
ignore_index | 不保留連接軸上的索引牲览，產生一組新索引 range(total_length)

### 合并重疊數據

要合并兩個索引全部或部分重疊的數據集墓陈，可以使用 NumPy 的 where 函數，它用于表達一種矢量化的 if-else：
```python
a = Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan],
           index=['f', 'e', 'd', 'c', 'b', 'a'])
b = Series(np.arange(len(a), dtype=np.float64),
           index=['f', 'e', 'd', 'c', 'b', 'a'])
b[-1] = np.nan
a
Out:
f    NaN
e    2.5
d    NaN
c    3.5
b    4.5
a    NaN
dtype: float64
b
Out:
f     0
e     1
d     2
c     3
b     4
a   NaN
dtype: float64

np.where(pd.isnull(a), b, a)
Out:
array([ 0. ,  2.5,  2. ,  3.5,  4.5,  nan])
```
Series 有一個 combine_first 方法，實現的也是一樣的功能贡必，而且會進行數據對齊：
```python
b[:-2].combine_first(a[2:])
Out:
a    NaN
b    4.5
c    3.0
d    2.0
e    1.0
f    0.0
dtype: float64
```
對于 DataFrame兔港，combine_first 也會做同樣的事情。

## 重塑和軸向旋轉

有許多用于重新排列表格型數據的基礎運算仔拟。這些函數也稱作重塑（reshape）或軸向旋轉（pivot）運算衫樊。
### 重塑層次化索引
DataFrame 的層次化重塑：
> - stack：將數據的列“旋轉”為行。
> - unstack：將數據的行“旋轉”為列利花。

```python
data = DataFrame(np.arange(6).reshape((2, 3)),
                 index=pd.Index(['Ohio', 'Colorado'], name='state'),
                 columns=pd.Index(['one', 'two', 'three'], name='number'))
data

Out:
number  one two three
state           
Ohio        0   1   2
Colorado    3   4   5

result = data.stack()
result

Out:
state     number
Ohio      one       0
          two       1
          three     2
Colorado  one       3
          two       4
          three     5
dtype: int32

result.unstack()
Out:
number  one two three
state           
Ohio        0   1   2
Colorado    3   4   5
```
默認情況下科侈，unstack 操作的是最內層（stack 也是），但可以傳入分層級別的編號或名稱即可對其他級別進行 unstack 操作炒事。
如果不是所有的級別值都能在各分組中找到的話臀栈，則 unstack 操作可能會引入缺失數據;而 stack 則會過濾缺失數據：
```
s1 = Series([0, 1, 2, 3], index=['a', 'b', 'c', 'd'])
s2 = Series([4, 5, 6], index=['c', 'd', 'e'])
data2 = pd.concat([s1, s2], keys=['one', 'two'])
data2
Out:
one  a    0
     b    1
     c    2
     d    3
two  c    4
     d    5
     e    6
dtype: int64

data2.unstack()
Out:
    a   b   c   d   e
one 0   1   2   3   NaN
two NaN NaN 4   5   6

data2.unstack().stack()
Out:
one  a    0
     b    1
     c    2
     d    3
two  c    4
     d    5
     e    6
dtype: float64
```
### 將“長格式”旋轉為“寬格式”
所謂的“長格式”如下：
```python
ldata[:10]
Out:
     date         item  value
0   1959-03-31  realgdp 2710.349
1   1959-03-31  infl    0.000
2   1959-03-31  unemp   5.800
3   1959-06-30  realgdp 2778.801
4   1959-06-30  infl    2.340
5   1959-06-30  unemp   5.100
6   1959-09-30  realgdp 2775.488
7   1959-09-30  infl    2.740
8   1959-09-30  unemp   5.300
9   1959-12-31  realgdp 2785.204
```
DataFrame 的 pivot 方法可以轉換成如下的“寬格式”：
```python
pivoted = ldata.pivot('date', 'item', 'value')
pivoted.head()
Out:
item          infl  realgdp unemp
date            
1959-03-31  0.00    2710.349    5.8
1959-06-30  2.34    2778.801    5.1
1959-09-30  2.74    2775.488    5.3
1959-12-31  0.27    2785.204    5.6
1960-03-31  2.31    2847.699    5.2
```
前兩個參數分別用作行和列索引的列名，最后一個參數則是用于填充 DataFrame 的數據列的列名羡洛。假設有兩個需要參與重塑的數據列：
```python
ldata['value2'] = np.random.randn(len(ldata))
ldata[:10]
Out:
    date    item    value   value2
0   1959-03-31  realgdp 2710.349    -0.204708
1   1959-03-31  infl    0.000   0.478943
2   1959-03-31  unemp   5.800   -0.519439
3   1959-06-30  realgdp 2778.801    -0.555730
4   1959-06-30  infl    2.340   1.965781
5   1959-06-30  unemp   5.100   1.393406
6   1959-09-30  realgdp 2775.488    0.092908
7   1959-09-30  infl    2.740   0.281746
8   1959-09-30  unemp   5.300   0.769023
9   1959-12-31  realgdp 2785.204    1.246435
```
如果忽略最后一個參數挂脑，得到的 DataFrame 就會帶有層次化的列：
```python
pivoted = ldata.pivot('date', 'item')
pivoted[:5]
Out:
    value   value2
item    infl    realgdp unemp   infl    realgdp unemp
date                        
1959-03-31  0.00    2710.349    5.8 0.478943    -0.204708   -0.519439
1959-06-30  2.34    2778.801    5.1 1.965781    -0.555730   1.393406
1959-09-30  2.74    2775.488    5.3 0.281746    0.092908    0.769023
1959-12-31  0.27    2785.204    5.6 1.007189    1.246435    -1.296221
1960-03-31  2.31    2847.699    5.2 0.228913    0.274992    1.352917
```
利用 set_index 創(chuàng)建層次化索引，再用 unstack 重塑可以得到同樣的效果：
```python
unstacked = ldata.set_index(['date', 'item']).unstack('item')
unstacked[:5]
Out:
    value   value2
item    infl    realgdp unemp   infl    realgdp unemp
date                        
1959-03-31  0.00    2710.349    5.8 0.478943    -0.204708   -0.519439
1959-06-30  2.34    2778.801    5.1 1.965781    -0.555730   1.393406
1959-09-30  2.74    2775.488    5.3 0.281746    0.092908    0.769023
1959-12-31  0.27    2785.204    5.6 1.007189    1.246435    -1.296221
1960-03-31  2.31    2847.699    5.2 0.228913    0.274992    1.352917
```

## 數據轉換
主要是數據的過濾欲侮、清理以及其他的轉換工作崭闲。
### 移除重復數據
DataFrame 的 duplicated 方法返回一個布爾型 Series，表示各行是否是重復行：
```python
data = DataFrame({'k1': ['one'] * 3 + ['two'] * 4,
                  'k2': [1, 1, 2, 3, 3, 4, 4]})
data
Out:
    k1  k2
0   one 1
1   one 1
2   one 2
3   two 3
4   two 3
5   two 4
6   two 4

data.duplicated()
Out:
0    False
1     True
2    False
3    False
4     True
5    False
6     True
dtype: bool
```
DataFrame 的 drop_duplicates 方法返回一個移除了重復行的 DataFrame：
```python
data.drop_duplicates()
Out:
    k1  k2
0   one 1
2   one 2
3   two 3
5   two 4
```
這兩個方法默認判斷全部列威蕉，也可以指定部分列進行重復項判斷：
```python
data['v1'] = range(7)
data.drop_duplicates(['k1'])
Out:
    k1  k2  v1
0   one 1   0
3   two 3   3
```
duplicated 和 drop_duplicates 默認保留的是第一個出現的值組合刁俭。傳入 keep='last' 則保留最后一個：
```python
data.drop_duplicates(['k1', 'k2'], keep='last')
Out:
    k1  k2  v1
1   one 1   1
2   one 2   2
4   two 3   4
6   two 4   6
```
### 利用函數或映射進行數據轉換
以下是有關肉類的數據：
```python
data = DataFrame({'food': ['bacon', 'pulled pork', 'bacon', 'Pastrami',
                           'corned beef', 'Bacon', 'pastrami', 'honey ham',
                           'nova lox'],
                  'ounces': [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})
data
Out:
    food    ounces
0   bacon   4.0
1   pulled pork 3.0
2   bacon   12.0
3   Pastrami    6.0
4   corned beef 7.5
5   Bacon   8.0
6   pastrami    3.0
7   honey ham   5.0
8   nova lox    6.0
```
如果要添加一列表示該肉類食物來源的動物類型，Series 的 map 方法可以接受一個函數或含有映射關系的字典對象：
```python
meat_to_animal = {
  'bacon': 'pig',
  'pulled pork': 'pig',
  'pastrami': 'cow',
  'corned beef': 'cow',
  'honey ham': 'pig',
  'nova lox': 'salmon'
}
data['animal'] = data['food'].map(str.lower).map(meat_to_animal)
data
Out:
    food    ounces  animal
0   bacon   4.0 pig
1   pulled pork 3.0 pig
2   bacon   12.0    pig
3   Pastrami    6.0 cow
4   corned beef 7.5 cow
5   Bacon   8.0 pig
6   pastrami    3.0 cow
7   honey ham   5.0 pig
8   nova lox    6.0 salmon
```
也可以傳入一個能夠完成全部工作的函數：
```python
data['animal'] = data['food'].map(lambda x: meat_to_animal[x.lower()])
```
### 替換值
利用 fillna 方法填充缺失數據可以看做值替換的一種特殊情況韧涨。雖然前面提到的 map 可以修改對象的數據子集牍戚，而 replace 
則提供了一種實現該功能的更簡單、更靈活的方式虑粥。replace 可以傳入單個元素如孝、列表或字典。

### 重命名軸索引
跟 Series 中的值一樣娩贷，軸標簽頁可以通過函數或映射進行轉換第晰，從而得到一個新對象。軸還可以被就地修改彬祖，而無需新建一個數據結構茁瘦。
```python
data = DataFrame(np.arange(12).reshape((3, 4)),
                 index=['Ohio', 'Colorado', 'New York'],
                 columns=['one', 'two', 'three', 'four'])
data.index = data.index.map(str.upper)
data
Out:
    one two three   four
OHIO    0   1   2   3
COLORADO    4   5   6   7
NEW YORK    8   9   10  11         
```
如果想要創(chuàng)建數據集的轉換板（而不是修改原始數據），比較實用的方法是 rename：
```python
data.rename(index=str.title, columns=str.upper)
Out:
    ONE TWO THREE   FOUR
Ohio    0   1   2   3
Colorado    4   5   6   7
New York    8   9   10  11
```
rename 可以結合字典型對象實現對部分軸標簽的更新储笑，同時可以傳入 inplace=True 就地修改某個數據集甜熔。

### 離散化和面元劃分
為了便于分析，連續(xù)數據常常被離散化或拆分為“面元”（bin）突倍。假設有一組人員數據腔稀，將它們劃分為不同的年齡組盆昙。將數據劃分為“18到25”、
“26到35”烧颖、“35到60”以及“60以上”幾個面元弱左，需要使用到 pandas 的 cut 函數：
```python
ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]
bins = [18, 25, 35, 60, 100]
cats = pd.cut(ages, bins)
cats
Out:
[(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], ..., (25, 35], (60, 100], (35, 60], (35, 60], (25, 35]]
Length: 12
Categories (4, object): [(18, 25] < (25, 35] < (35, 60] < (60, 100]]
```
pandas 返回的是一個特殊化的 Categorical 對象，它包含一個表示不同分類名稱的 categories 數組以及一個為年齡數據進行標號的
codes 屬性：
```python
cats.codes
Out:
array([0, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)

cats.categories
Out:
Index([u'(18, 25]', u'(25, 35]', u'(35, 60]', u'(60, 100]'], dtype='object')

pd.value_counts(cats)
Out:
(18, 25]     5
(35, 60]     3
(25, 35]     3
(60, 100]    1
dtype: int64
```
跟“區(qū)間”的數學符號一樣炕淮，圓括號表示開端，而方括號則表示閉端（包括）跳夭。哪邊是閉端可以通過 right=False 進行修改涂圆。也可以
設置自己的面元名稱，將 labels 選項設置為一個列表或數組即可：
```python
group_names = ['Youth', 'YoungAdult', 'MiddleAged', 'Senior']
pd.cut(ages, bins, labels=group_names)
Out:
[Youth, Youth, Youth, YoungAdult, Youth, ..., YoungAdult, Senior, MiddleAged, MiddleAged, YoungAdult]
Length: 12
Categories (4, object): [Youth < YoungAdult < MiddleAged < Senior]
```
如果向 cut 傳入的是面元的數量而不是確切的面元邊界币叹，則它會根據數據的最小值和最大值計算等長面元润歉。

qcut 是一個非常類似于 cut 的函數，它可以根據樣本分位數對數據進行面元劃分：
```python
data = np.random.randn(1000) # Normally distributed
cats = pd.qcut(data, 4) # Cut into quartiles
cats
Out:
[(0.644, 3.26], [-3.745, -0.635], (0.644, 3.26], [-3.745, -0.635], (-0.022, 0.644], ..., (-0.022, 0.644], (0.644, 3.26], (-0.635, -0.022], (0.644, 3.26], (-0.635, -0.022]]
Length: 1000
Categories (4, object): [[-3.745, -0.635] < (-0.635, -0.022] < (-0.022, 0.644] < (0.644, 3.26]]
```
跟 cut 一樣颈抚，也可以設置自定義的分位點（0到1之間的數值踩衩，包括端點）。

### 檢測和過濾異常值
異常值的過濾或變換運算在很大程度上其實就是數組運算贩汉。下面是一個含有正態(tài)分布數據的 DataFrame：
```python
np.random.seed(12345)
data = DataFrame(np.random.randn(1000, 4))
data.describe()
Out:
    0   1   2   3
count   1000.000000 1000.000000 1000.000000 1000.000000
mean    -0.067684   0.067924    0.025598    -0.002298
std 0.998035    0.992106    1.006835    0.996794
min -3.428254   -3.548824   -3.184377   -3.745356
25% -0.774890   -0.591841   -0.641675   -0.644144
50% -0.116401   0.101143    0.002073    -0.013611
75% 0.616366    0.780282    0.680391    0.654328
max 3.366626    2.653656    3.260383    3.927528
```
找出某列中絕對值超過3的值：
```python
col = data[3]
col[np.abs(col)>3]
```
要選出全部含有“超過3或-3的值”的行驱富，可以利用 DataFrame 以及 any 方法：
```
data[(np.abs(data) > 3).any(1)]
```
然后可以將值限制在區(qū)間[-3,3]以內（np.sign 這個 ufunc 返回的是一個由1和-1組成的數組，表示原始值得符號匹舞。）：
```
data[np.abs(data) > 3] = np.sign(data) * 3
```
### 排列和隨機抽樣
利用 numpy.random.permutation 函數可以輕松實現對 Series 或 DataFrame 的列的排列工作褐鸥。通過需要排列的軸的長度調用
permutation，可產生一個表示新順序的整數數組：
```
df = DataFrame(np.arange(5 * 4).reshape((5, 4)))
sampler = np.random.permutation(5)
sampler
Out:
array([1, 0, 2, 3, 4])
df
Out:
    0   1   2   3
0   0   1   2   3
1   4   5   6   7
2   8   9   10  11
3   12  13  14  15
4   16  17  18  19
```
然后就可以在基于 ix 的索引操作或 take 函數中使用該數組了：
```python
df.take(sampler)
Out:
    0   1   2   3
1   4   5   6   7
0   0   1   2   3
2   8   9   10  11
3   12  13  14  15
4   16  17  18  19
```
### 計算指標/啞變量
一種常用于統(tǒng)計建拇突或機器學習的轉換方式是：將分類變量轉換為“啞變量矩陣”或“指標矩陣”叫榕。如果 DataFrame 的某一列中含有 k 個
不同的值，則可以派生出一個 k 列矩陣或 DataFrame（其值全為1和0）姊舵。pandas 有一個 get_dummies 函數可以實現該功能晰绎。
```python
df = DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],
                'data1': range(6)})
pd.get_dummies(df['key'])
Out:
    a   b   c
0   0   1   0
1   0   1   0
2   1   0   0
3   0   0   1
4   1   0   0
5   0   1   0
```
結合 get_dummies 和諸如 cut 之類的離散化函數：
```python
values = np.random.rand(10)
values
Out:
array([ 0.046 ,  0.5346,  0.8187,  0.3951,  0.3464,  0.0534,  0.9332,
        0.1028,  0.5361,  0.0043])

bins = [0, 0.2, 0.4, 0.6, 0.8, 1]
pd.get_dummies(pd.cut(values, bins))
Out:

(0, 0.2]    (0.2, 0.4]  (0.4, 0.6]  (0.6, 0.8]  (0.8, 1]
0   1   0   0   0   0
1   0   0   1   0   0
2   0   0   0   0   1
3   0   1   0   0   0
4   0   1   0   0   0
5   1   0   0   0   0
6   0   0   0   0   1
7   1   0   0   0   0
8   0   0   1   0   0
9   1   0   0   0   0
```

## 字符串操作
Python 能夠成為流行的數據處理語言，部分原因是其簡單易用的字符串和文本處理功能括丁。大部分文本運算直接做成了字符串對象的內置
方法荞下。對于更為復雜的模式匹配和文本操作，則可能需要用到正則表達式躏将。pandas 對此進行了加強锄弱。
### 字符串對象的方法

> Python內置的字符串方法

方法 | 說明
--- | ---
count | 返回子串在字符串中的出現次數（非重疊）
endswith、startswith | 如果字符串以某個后綴（或前綴）結尾祸憋，則返回True
join | 將字符串用作連接其他字符串序列的分隔符
index | 如果字符串中找到子串会宪，則返回子串的第一個字符所在的位置；如果沒有找到蚯窥，則引發(fā)ValueError
find | 如果字符串中找到子串掸鹅，則返回第一個發(fā)現的子串的第一個字符所在的位置塞帐；如果沒有找到，則返回-1
rfind | 如果字符串中找到子串巍沙，則返回最后一個發(fā)現的子串的第一個字符所在的位置葵姥；如果沒有找到，則返回-1
replace | 用另一個字符串替換指定子串
strip句携、rstrip榔幸、lstrip | 去除空白符（包括換行符）。
split | 通過指定的分隔符將字符串拆分為一組子串
lower矮嫉、upper | 分別將字母字符轉換為小寫或大寫
ljust削咆、rjust | 用空格（或其他字符）填充字符串的空白側以返回符合最低寬度的字符串

### 正則表達式

> 正則表達式方法

方法 | 說明
--- | ---
findall、finditer | 返回字符串中所有的費重疊匹配模式蠢笋，findall 返回的是由所有模式組成的列表拨齐，而 finditer 則通過一個迭代器逐個返回
match | 從字符串起始位置匹配模式，還可以對模式各部分進行分組昨寞。
search | 掃描整個字符串以匹配模式瞻惋，其匹配項可以位于字符串的任意位置。
split | 根據找到的模式將字符串拆分為數段
sub援岩、subn | 將字符串中所有的（sub）或前n個（subn）模式替換為指定表達式

### pandas 中矢量化的字符串函數
> 適量化的字符串方法

方法 | 說明
--- | ---
cat | 實現元素級的字符串連接操作歼狼，可指定分隔符
contains | 返回表示各字符串是否含有指定模式的布爾型數組
count | 模式的出現次數
endswith、startswith | 相當于對各個元素執(zhí)行 x.endswith(pattern) 或 x.startswith(pattern)
findall | 計算各字符串的模式列表
get | 獲取各元素的第i個字符
join | 根據指定的分隔符將 Series 中各元素的宇符串連接起來
len | 計算各字符串的長度
lower窄俏、upper | 轉換大小寫蹂匹。相當于對各個元素執(zhí)行 x.lower() 或 x.upper()
match | 根據指定的正則表達式對各個元素執(zhí)行 re.match
pad | 在字符串的左邊、右邊或左右兩邊添加空白符
center | 相當于 pad(side='both')
repeat | 重復值凹蜈。例如限寞，s.str.repeat(3) 相當于對各個字符串執(zhí)行 x*3
replace | 用指定字符串替換找到的模式
slice | 對 Series 中的各個字符串進行子串截取
split | 根據分隔符或正則表達式對字符串進行拆分
strip、rstrip仰坦、Istrip | 去除空白符履植，包括換行符。相當于對各個元素執(zhí)行 x.strip()悄晃、x.rstrip(),x.lstrip()