阅读笔记：利用Python进行数据分析第2版——第7章 数据清洗和准备

本章讨论处理缺失数据、重复数据、字符串操作和其它分析数据转换的工具。

处理缺失数据

1. 对于数值数据，pandas使用浮点值NaN（Not a Number）表示缺失数据。我们称其为哨兵值，可以方便的检测出来：

string_data = pd.Series(['aardvark', 'artichoke', np.nan, 'avocado'])
string_data.isnull()

2. 在pandas中，我们采用了R语言中的惯用法，即将缺失值表示为NA，它表示不可用not available。

3. Python内置的None值在对象数组中也可以作为NA：
   

4. 过滤掉缺失数据的办法有很多种。你可以通过pandas.isnull或布尔索引的手工方法，但dropna可能会更实用一些。对于一个Series，dropna返回一个仅含非空数据和索引值的Series：

In [15]: from numpy import nan as NA
In [16]: data = pd.Series([1, NA, 3.5, NA, 7])
In [17]: data.dropna()  # 等价于 data[data.notnull()]
Out[17]: 
0    1.0
2    3.5
4    7.0
dtype: float64

5. 而对于DataFrame对象，事情就有点复杂了。你可能希望丢弃全NA或含有NA的行或列。dropna默认丢弃任何含有缺失值的行：

In [19]: data = pd.DataFrame([[1., 6.5, 3.], [1., NA, NA],
   ....:                      [NA, NA, NA], [NA, 6.5, 3.]])
In [20]: data.dropna()
Out[20]: 
     0    1    2
0  1.0  6.5  3.0

6. 传入how='all'将只丢弃全为NA的那些行：data.dropna(how='all')
   用这种方式丢弃列，只需传入axis=1即可：data.dropna(axis=1, how='all')
   若要同时丢弃全为NA的行和列，需传入axis=[0, 1]：data.dropna(axis=[0, 1], how='all')
7. 假设你只想留下一部分观测数据，可以用thresh参数实现此目的：

In [27]: df = pd.DataFrame(np.random.randn(7, 3))
In [28]: df.iloc[:4, 1] = NA
In [29]: df.iloc[:2, 2] = NA
In [30]: df
Out[30]: 
          0         1         2
0 -0.204708       NaN       NaN
1 -0.555730       NaN       NaN
2  0.092908       NaN  0.769023
3  1.246435       NaN -1.296221
4  0.274992  0.228913  1.352917
5  0.886429 -2.001637 -0.371843
6  1.669025 -0.438570 -0.539741
In [31]: df.dropna()
Out[31]: 
          0         1         2
4  0.274992  0.228913  1.352917
5  0.886429 -2.001637 -0.371843
6  1.669025 -0.438570 -0.539741
In [32]: df.dropna(thresh=2)
Out[32]: 
          0         1         2
2  0.092908       NaN  0.769023
3  1.246435       NaN -1.296221
4  0.274992  0.228913  1.352917
5  0.886429 -2.001637 -0.371843
6  1.669025 -0.438570 -0.539741

8. df.fillna(0)用0填充确实数据。若是通过一个字典调用fillna，就可以实现对不同的列填充不同的值：

df.fillna({1: 0.5, 2: 0})

fillna默认会返回新对象，但也可以对现有对象进行就地修改：_ = df.fillna(0, inplace=True)
9. 对reindexing有效的那些插值方法也可用于fillna：

In [37]: df = pd.DataFrame(np.random.randn(6, 3))
In [38]: df.iloc[2:, 1] = NA
In [39]: df.iloc[4:, 2] = NA
In [40]: df
Out[40]: 
          0         1         2
0  0.476985  3.248944 -1.021228
1 -0.577087  0.124121  0.302614
2  0.523772       NaN  1.343810
3 -0.713544       NaN -2.370232
4 -1.860761       NaN       NaN
5 -1.265934       NaN       NaN
In [41]: df.fillna(method='ffill')
Out[41]: 
          0         1         2
0  0.476985  3.248944 -1.021228
1 -0.577087  0.124121  0.302614
2  0.523772  0.124121  1.343810
3 -0.713544  0.124121 -2.370232
4 -1.860761  0.124121 -2.370232
5 -1.265934  0.124121 -2.370232
In [42]: df.fillna(method='ffill', limit=2)
Out[42]: 
          0         1         2
0  0.476985  3.248944 -1.021228
1 -0.577087  0.124121  0.302614
2  0.523772  0.124121  1.343810
3 -0.713544  0.124121 -2.370232
4 -1.860761       NaN -2.370232
5 -1.265934       NaN -2.370232

数据转换

1. 移除重复数据

data = pd.DataFrame({'k1': ['one', 'two'] * 3 + ['two'], 'k2': [1, 1, 2, 3, 3, 4, 4]})
data.duplicated()  # 返回一个布尔型Series，表示各行是否是重复行（前面出现过的行）
data.drop_duplicates()  # 返回一个DataFrame

duplicated和drop_duplicates方法默认会判断全部列，也可以指定部分列进行重复项判断。
duplicated和drop_duplicates默认保留的是第一个出现的值组合。传入keep=’last’则保留最后一个：

In [49]: data['v1'] = range(7)
In [50]: data.drop_duplicates(['k1'])
Out[50]: 
    k1  k2  v1
0  one   1   0
1  two   1   1
In [51]: data.drop_duplicates(['k1', 'k2'], keep='last')

2. 利用函数或映射进行数据转换
   Series的map方法可以接受一个函数或含有映射关系的字典型对象，使用map是一种实现元素级转换以及其他数据清理工作的便捷方式。

data = pd.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]})
meat_to_animal = {
  'bacon': 'pig',
  'pulled pork': 'pig',
  'pastrami': 'cow',
  'corned beef': 'cow',
  'honey ham': 'pig',
  'nova lox': 'salmon'
}  # 肉类到动物的映射
lowercased = data['food'].str.lower()  # 将各个值转换为小写
data['animal'] = lowercased.map(meat_to_animal)
In [58]: data
Out[58]: 
          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

我们也可以传入一个能够完成全部这些工作的函数：data['food'].map(lambda x: meat_to_animal[x.lower()])
3. 替换值：

data.replace(-999, np.nan)
data.replace([-999, -1000], np.nan)  # 一次性替换多个值
data.replace([-999, -1000], [np.nan, 0])  # 每个值有不同的替换值
data.replace({-999: np.nan, -1000: 0})  # 每个值有不同的替换值

注意：data.replace方法与data.str.replace不同，后者做的是字符串的元素级替换。
4. 跟Series中的值一样，轴标签也可以通过函数或映射进行转换，从而得到一个新的不同标签的对象。

In [66]: data = pd.DataFrame(np.arange(12).reshape((3, 4)), index=['Ohio', 'Colorado', 'New York'], columns=['one', 'two', 'three', 'four'])
In [67]: transform = lambda x: x[:4].upper()
In [68]: data.index.map(transform)
Out[68]: Index(['OHIO', 'COLO', 'NEW '], dtype='object')
In [69]: data.index = data.index.map(transform)  # 就地修改

如果想要创建数据集的转换版（而不是修改原始数据），比较实用的方法是rename，且rename可以结合字典型对象实现对部分轴标签的更新：
如果希望就地修改某个数据集，传入inplace=True即可。

In [71]: data.rename(index=str.title, columns=str.upper)
Out[71]: 
      ONE  TWO  THREE  FOUR
Ohio    0    1      2     3
Colo    4    5      6     7
New     8    9     10    11
In [72]: data.rename(index={'OHIO': 'INDIANA'}, columns={'three': 'peekaboo'})
Out[72]:
one  two  peekaboo  four
INDIANA    0    1         2     3
COLO       4    5         6     7
NEW        8    9        10    11

5. 为了便于分析，连续数据常常被离散化或拆分为“面元”（bin）。

In [75]: ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]
In [76]: bins = [18, 25, 35, 60, 100]
In [77]: cats = pd.cut(ages, bins)
In [78]: cats
Out[78]: 
[(18, 25], (18, 25], (18, 25], (25, 35], (18, 25], ..., (25, 35], (60, 100], (35,60], (35, 60], (25, 35]]
Length: 12
Categories (4, interval[int64]): [(18, 25] < (25, 35] < (35, 60] < (60, 100]]

In [79]: cats.codes
Out[79]: array([0, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)
In [80]: cats.categories
Out[80]: 
IntervalIndex([(18, 25], (25, 35], (35, 60], (60, 100]]
              closed='right',
              dtype='interval[int64]')
In [81]: pd.value_counts(cats)  # 面元计数, 等价于cats.value_counts()
Out[81]: 
(18, 25]     5
(35, 60]     3
(25, 35]     3
(60, 100]    1
dtype: int64

你可 以通过传递一个列表或数组到labels，设置自己的面元名称：

In [83]: group_names = ['Youth', 'YoungAdult', 'MiddleAged', 'Senior']
In [84]: pd.cut(ages, bins, labels=group_names)

如果向cut传入的是面元的数量而不是确切的面元边界，则它会根据数据的最小值和最大值计算等长面元。下面这个例子中，我们将一些均匀分布的数据分成四组：

In [85]: data = np.random.rand(20)
In [86]: pd.cut(data, 4, precision=2)  # 限定小数只有两位

6. qcut是一个非常类似于cut的函数，它可以根据样本分位数对数据进行面元划分。根据数据的分布情况，cut可能无法使各个面元中含有相同数量的数据点。而qcut由于使用的是样本分位数，因此可以得到大小基本相等的面元：

In [87]: data = np.random.randn(1000)  # Normally distributed
In [88]: cats = pd.qcut(data, 4)  # Cut into quartiles
In [90]: pd.value_counts(cats)
Out[90]:
(0.62, 3.928]       250
(-0.0265, 0.62]     250
(-0.68, -0.0265]    250
(-2.95, -0.68]      250
dtype: int64

与cut类似，你也可以传递自定义的分位数（0到1之间的数值，包含端点）：

pd.qcut(data, [0, 0.1, 0.5, 0.9, 1.])

7. 检测和过滤异常值

data = pd.DataFrame(np.random.randn(1000, 4))
col = data[2]
col[np.abs(col) > 3]
data[(np.abs(data) > 3).any(1)]  # 要选出全部含有“超过3或－3的值”的行
data[np.abs(data) > 3] = np.sign(data) * 3  # 下面的代码可以将值限制在区间-3到3以内

8. 利用numpy.random.permutation函数可以轻松实现对Series或DataFrame的列的排列工作（permuting，随机重排序）。

In [100]: df = pd.DataFrame(np.arange(5 * 4).reshape((5, 4)))
In [101]: sampler = np.random.permutation(5)
In [102]: sampler
Out[102]: array([3, 1, 4, 2, 0])
In [103]: df.take(sampler)  # 等价于df.iloc[sampler]

可以在Series和DataFrame上使用sample方法：

df.sample(n=3)  # 随机取三行

若要允许重复选择，可以传递replace=True到sample：df.sample(n=3)
9. 一种常用于统计建模或机器学习的转换方式是：将分类变量（categorical variable）转换为“哑变量”或“指标矩阵”
如果DataFrame的某一列中含有k个不同的值，则可以派生出一个k列矩阵或DataFrame（其值全为1和0）。pandas.get_dummies函数可以实现该功能。

In [109]: df = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],
   .....:                    'data1': range(6)})
In [110]: pd.get_dummies(df['key'])
Out[110]: 
   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之类的离散化函数：

In [129]: np.random.seed(12345)  # 使这个例子具有确定性
In [130]: values = np.random.rand(10)
In [131]: values
Out[131]: 
array([ 0.9296,  0.3164,  0.1839,  0.2046,  0.5677,  0.5955,  0.9645,
        0.6532,  0.7489,  0.6536])
In [132]: bins = [0, 0.2, 0.4, 0.6, 0.8, 1]
In [133]: pd.get_dummies(pd.cut(values, bins))
Out[133]: 
   (0.0, 0.2]  (0.2, 0.4]  (0.4, 0.6]  (0.6, 0.8]  (0.8, 1.0]
0           0           0           0           0           1
1           0           1           0           0           0
2           1           0           0           0           0
3           0           1           0           0           0
4           0           0           1           0           0
5           0           0           1           0           0
6           0           0           0           0           1
7           0           0           0           1           0
8           0           0           0           1           0
9           0           0           0           1           0

字符串操作

1. 以指定字符或字符串分隔

In [134]: val = 'a,b,  guido'
In [135]: val.split(',')
Out[135]: ['a', 'b', '  guido']

2. 使用strip，以去除字符串两侧任意数量空白符和换行符（需为连续）

In [136]: pieces = [x.strip() for x in val.split(',')]
In [137]: pieces
Out[137]: ['a', 'b', 'guido']

3. 字符串连接

In [140]: '::'.join(pieces)
Out[140]: 'a::b::guido'

4. 子串定位

In [141]: 'guido' in val  # 最佳方法
Out[141]: True
In [142]: val.index(',')  # 找不到字符串，index将会引发一个异常
Out[142]: 1
In [143]: val.find(':')  # 找不到字符串，返回－1
Out[143]: -1

5. count可以返回指定子串的出现次数：val.count(',')
6. replace用于将指定模式替换为另一个模式。

In [146]: val.replace(',', '::')
Out[146]: 'a::b::  guido'
In [147]: val.replace(',', '')
Out[147]: 'ab  guido'

7. 正则表达式(regex)提供了一种灵活的在文本中搜索或匹配（通常比前者复杂）字符串模式的方式。re模块的函数可以分为三个大类：模式匹配、替换以及拆分。
8. 拆分一个字符串，分隔符为数量不定的一组空白符（制表符、空格、换行符等）：

In [148]: import re
In [149]: text = "foo    bar\t baz  \tqux"
In [150]: re.split('\s+', text)
Out[150]: ['foo', 'bar', 'baz', 'qux']
In [151]: regex = re.compile('\s+')  # 编译regex以得到一个可重用的regex对象
In [152]: regex.split(text)
Out[152]: ['foo', 'bar', 'baz', 'qux']
In [153]: regex.findall(text)  # 得到匹配regex的所有模式
Out[153]: ['    ', '\t ', '  \t']

9. 如果打算对许多字符串应用同一条正则表达式，强烈建议通过re.compile创建regex对象。这样将可以节省大量的CPU时间。
10. match和search跟findall功能类似。findall返回的是字符串中所有的匹配项，而search则只返回第一个匹配项。match更加严格，它只匹配字符串的首部。

text = """Dave dave@google.com
Steve steve@gmail.com
Rob rob@gmail.com
Ryan ryan@yahoo.com
"""
pattern = r'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}'
# re.IGNORECASE makes the regex case-insensitive
regex = re.compile(pattern, flags=re.IGNORECASE)
regex.findall(text)  # 使用findall将得到一组电子邮件地址
regex.search(text)  # search返回的是文本中第一个电子邮件地址, <_sre.SRE_Match object; span=(5, 20), match='dave@google.com'>
print(regex.match(text))  # regex.match则将返回None，因为它只匹配出现在字符串开头的模式

11. sub方法可以将匹配到的模式替换为指定字符串，并返回所得到的新字符串

In [160]: print(regex.sub('REDACTED', text))
Dave REDACTED
Steve REDACTED

12. 假设你不仅想要找出电子邮件地址，还想将各个地址分成3个部分：用户名、域名以及域后缀。要实现此功能，只需将待分段的模式的各部分用圆括号包起来即可：
    可以通过其groups方法返回一个由模式各段组成的元组

In [161]: pattern = r'([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})'
In [162]: regex = re.compile(pattern, flags=re.IGNORECASE)
In [163]: m = regex.match('wesm@bright.net')
In [164]: m.groups()
Out[164]: ('wesm', 'bright', 'net')

13. 对于带有分组功能的模式，findall会返回一个元组列表：

In [165]: regex.findall(text)
Out[165]:
[('dave', 'google', 'com'),
 ('steve', 'gmail', 'com'),
 ('rob', 'gmail', 'com'),
 ('ryan', 'yahoo', 'com')]

14. sub还能通过诸如\1、\2之类的特殊符号访问各匹配项中的分组。符号\1对应第一个匹配的组，\2对应第二个匹配的组，以此类推：

In [166]: print(regex.sub(r'Username: \1, Domain: \2, Suffix: \3', text))
Dave Username: dave, Domain: google, Suffix: com
Steve Username: steve, Domain: gmail, Suffix: com

14. pandas的矢量化字符串函数

data = {'Dave': 'dave@google.com', 'Steve': 'steve@gmail.com',
   .....:         'Rob': 'rob@gmail.com', 'Wes': np.nan}
data = pd.Series(data)
data[data.notnull()]
Dave     dave@google.com
Rob        rob@gmail.com
Steve    steve@gmail.com
dtype: object

通过data.map，所有字符串和正则表达式方法都能被应用于（传入lambda表达式或其他函数）各个值，但是如果存在NA（null）就会报错。
Series有一些能够跳过NA值的面向数组方法，进行字符串操作。通过Series的str属性即可访问这些方法。
例如，我们可以通过str.contains检查各个电子邮件地址是否含有”gmail”：data.str.contains('gmail')
也可以使用正则表达式，还可以加上任意re选项（如IGNORECASE）：

In [172]: pattern
Out[172]: '([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\\.([A-Z]{2,4})'
In [173]: data.str.findall(pattern, flags=re.IGNORECASE)
Out[173]: 
Dave     [(dave, google, com)]
Rob        [(rob, gmail, com)]
Steve    [(steve, gmail, com)]
Wes                        NaN
dtype: object

pandas字符串方法