7.1处理缺失值
对于数值型数据，pandas使用浮点数NaN（not a number 来表示缺失值）。我们称NaN为容易检测到的缺失值：
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
string_data = pd.Series(['aardvark','artichoke',np.nan,'avocado'])
string_data.isnull()
0 False
1 False
2 True
3 False
dtype: bool
在pandas中我们采用了R语言中的编程惯例，将缺失值成为NA，意思是not available（不可用）。
Python内建的None值在对象数组中也被当作NA处理：
string_data[0] = None
string_data.isnull()
0 True
1 False
2 True
3 False
dtype: bool
过滤缺失值
虽然你可以使用pandas.isnull和布尔值索引手动地过滤缺失值，但dropna在过滤缺失值时是非常有用的。
在Series上使用dropna，它会返回Series中所有的非空数据及其索引值。
from numpy import nan as NA
data = pd.Series([1,NA,3.5,NA,7])
data.dropna()
0 1.0
2 3.5
4 7.0
dtype: float64
这等价于
data[data.notnull()]
当处理DataFrame对象时，你可能想要删除全部为NA或包含有NA的行或列
dropna默认情况下会删除包含缺失值的行。
传入how = 'all'时，将删除所有值均为NA的行。(此时默认axis = 0)
传入参数axis = 1和how= 'all'，将删除所有值均为NA的列。
如果想保留包含一定数量观察值的行，用thresh参数：df.dropna(thresh = 2)向上保留两行
补全缺失值
大多数情况下主要使用fillna方法来补全缺失值，调用它时可以使用一个是 常数 来替代缺失值。
在调用fillna时使用字典，你可以为不同 列 设定不同的 填充值。
fillna返回的是一个新的对象，但你也可以修改已经存在的对象，inplace 修改被调用的对象，而不是生成一个备份 df.fillna(0,inplace = True)
用于重建索引的相同的插值方法也可以用于fillna，method：插值方法，如果没有其他参数，默认是‘ffill’，limit:用于前向或后向填充时最大的填充范围df.fillna(method = 'ffill',limit = 2)
你也可以将Series的平均值或中位数用于填充缺失值：Series.fillna(Series.mean())
还有一种比较常用数学上的朗格朗日插值法以及牛顿插值法，见博客。
7.2数据转换
由于各种原因，DataFrame中会出现重复行。
DataFrame的duplicated方法返回的是一个布尔值Series，这个Series反映的是每行是否存在 重复 情况。
drop_duplicates返回的是DataFrame，内容是duplicated返回数组中为False的部分（相当于去除重复行后的部分）。
data = pd.DataFrame({'k1':['one','two']*3 + ['two'],'k2':[1,1,2,3,3,4,4]})
data.duplicated()
0 False
1 False
2 False
3 False
4 False
5 False
6 True
dtype: bool
#
data.drop_duplicates()
k1 k2
0 one 1
1 two 1
2 one 2
3 two 3
4 one 3
5 two 4
这些方法默认都是对 列 进行操作。你可以指定数据的任何子集来检测是否有重复。假设我们有一个额外的列，并想基于‘k1’列去除重复值：data.drop_duplicates(['k1'])
duplicated 和 drop_duplicates默认都是保留第一个观测到的值，传入参数keep = ‘last’将会返回最后一个 ：data.drop_duplicates(['k1','k2'],keep = 'last')
使用 函数 或 映射 进行数据转换
对于许多数据集，你可能希望基于DataFrame中的数组、列或列中的数值进行一些转换。
data = pd.DataFrame({'food':['bacon','pulled pork','bacon', 'Pastrami','corned beef','Bacon',
'pastrami','honey ham','nova lox'], 'oneces':[4,3,12,6,7.5,8,3,5,6]})
meat_to_animal = {'bacon':'pig', 'pulled pork':'pig', 'pastrami':'cow', 'corned beef':'pig',
'honey ham':'pig', 'nova lox':'salmon'}
lowercased = data['food'].str.lower()
data['animal'] = lowercased.map(meat_to_animal)
data
food oneces 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 pig
5 Bacon 8.0 pig
6 pastrami 3.0 cow
7 honey ham 5.0 pig
8 nova lox 6.0 salmon
Series 的map方法接收一个函数或包含映射关系的字典型对象，可以传入一个能够完成所有工作的函数：
data['food'].map(lambda x: meat_to_animal[x.lower()])
0 pig
1 pig
2 pig
3 cow
4 pig
5 pig
6 cow
7 pig
8 salmon
Name: food, dtype: object
替代值
使用fillna填充缺失值是通用值替换的特殊案例。
map 可以用来修改一个对象中的子集的值，但是replace提供了更为简单灵活的实现
-999可能是缺失值的标识。如果要使用NA来替代，可以使用replace方法生成新的Series（除非你传入了inplace= True
data = pd.Series([1.,-999,2.,-999,-1000.,3.])
data.replace(-999,np.nan)
0 1.0
1 NaN
2 2.0
3 NaN
4 -1000.0
5 3.0
dtype: float64
如果你想一次替代多个值，传入一个列表和一个替代值：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 方法不同的，data.str.replace是对 字符串 按元素替代
重命名轴索引
和Series一样，你可以通过函数或某种形式的映射对 轴标签 进行类似的转换，生成新的且带有不同标签的对象。你也可以在不生成新的的数据结构的情况下修改轴。
与Series类似，轴索引也有一个map方法，transform = lambda x: x[:4].upper()，然后赋值给index，修改DataFrame data.index = data.index.map(transform)
data = pd.DataFrame(np.arange(12).reshape((3,4)),
index = ['Ohio','Colorado','New York'],
columns = ['one','two','three','four'])
data
one two three four
Ohio 0 1 2 3
Colorado 4 5 6 7
New York 8 9 10 11
transform = lambda x: x[:4].upper()
data.index.map(transform)
Index(['OHIO', 'COLO', 'NEW '], dtype='object')
#也可以赋值给index，修改DataFrame
data.index = data.index.map(transform)
data
one two three four
OHIO 0 1 2 3
COLO 4 5 6 7
NEW 8 9 10 11
如果你想创建数据集转换后的版本，并且不修改原有的数据集，一个有用的方法就是rename data.rename(index = str.title,columns = str.upper)
rename 可以结合字典型对象使用，为轴标签的子集提供新的值(修改轴标签)
data.rename(index = {'OHIO':'INDIADA'},columns = {'three':'peekaboo'})
如果你想修改原有的数据集，传入inplace = True
data.rename(index = {'OHIO':'INDIADA'},inplace = True)
离散化和分箱
假设你有一组人群的数据，你想将他们分组，放入离散的年龄框中cats = pd.cut(ages,bins)
#将这些年龄分为18-25,26-35，36-60，以及61以上等若干组。你可以使用pandas中的cut：
#(区间左开右闭)
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
[(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]]
你看到的输出描述了由pandas.cut计算出的箱。你可以把它当做一个表示箱名的字符串数组；它在内部包含一个categories（类别）数组，他制定了不同的类别名称以及codes属性中的categories类别：
cats.codes
array([0, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)
cats.categories
IntervalIndex([(18, 25], (25, 35], (35, 60], (60, 100]],
closed='right',
dtype='interval[int64]')
#value_counts是对箱数量的计数
pd.value_counts(cats)
(18, 25] 5
(35, 60] 3
(25, 35] 3
(60, 100] 1
dtype: int64
与数学区间的符号一样，区间默认左开右闭。你可以通过传递right = False来改变那一边是封闭的：pd.cut(ages,[18,26,36,61,100],right = False)
你也可以通过向 labels 选项传递一个列表或数组来传入自定义的箱名：
如果你根据cut 整数个的箱来代替显式的箱边，pandas将根据数组中的最大值和最小值计算出等长的箱。pd.cut(data,4,precision=2)# 将十进制精度限制在两位。
qcut 函数，基于样本分位数进行分箱。你可以使用 qcut 获得等长（箱内数据量相等）的箱。
data = np.random.randn(1000)#正态分布
cats = pd.qcut(data,4)#切成4份
cats
[(0.018, 0.679], (0.018, 0.679], (0.679, 2.951], (-0.684, 0.018], (-2.96, -0.684], ..., (-0.684, 0.018], (-0.684, 0.018], (-2.96, -0.684], (0.018, 0.679], (-2.96, -0.684]]
Length: 1000
Categories (4, interval[float64]): [(-2.96, -0.684] < (-0.684, 0.018] < (0.018, 0.679] < (0.679, 2.951]]
pd.value_counts(cats)
(0.679, 2.951] 250
(0.018, 0.679] 250
(-0.684, 0.018] 250
(-2.96, -0.684] 250
dtype: int64
与cut类似，你可以传入自定义的分位数（0合1之间的数据，包括边）pd.qcut(data,[0,0.1,0.5,0.9,1.])
检测和过滤异常值
假设你想找出一列中绝对值大于三的值 col = data[2] col[np.abs(col)>3]
要选出所有大于3小于-3的行，你可以对布尔值DataFrame使用any方法
data[(np.abs(data) > 3).any(1) ]
这里eny()用于判断给定的iterable可迭代参数是否全部为False，只要有一个为True，则返回True。（这样使布尔序列的索引，与原索引对象的索引匹配。）
将绝对值大于三的值根据其正负转换成3或-3 data[np.abs(data)>3] = np.sign(data)*3
置换和随机抽样
使用numpy.random.permutation 对DataFrame中的Series或行进行置换（随机重排序）是非常方便的。
在调用permutation时根据你想要的轴长度可以产生一个表示新顺序的整数数组：
整数数组可以用在基于iloc的索引和等价的take函数中：
df = pd.DataFrame(np.arange(5*4).reshape((5,4)))
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
sampler = np.random.permutation(5)#array([0, 1, 3, 4, 2])
df.take(sampler)
0 1 2 3
0 0 1 2 3
1 4 5 6 7
3 12 13 14 15
4 16 17 18 19
2 8 9 10 11
df.iloc[sampler]
0 1 2 3
0 0 1 2 3
1 4 5 6 7
3 12 13 14 15
4 16 17 18 19
2 8 9 10 11
要选出一个不含有替代值的随机子集，可以使用Series和DataFrame中的sample方法
df.sample(n=3)
0 1 2 3
1 4 5 6 7
0 0 1 2 3
3 12 13 14 15
要生成一个带有替代值的样本（允许有重复选择），将replace = True传入sample方法：
draws = choices.sample(n=10,replace = True)
choices = pd.Series([5,7,-1,6,4])
draws = choices.sample(n=10,replace = True)
4 4
0 5
1 7
3 6
1 7
4 4
1 7
4 4
0 5
4 4
dtype: int64
计算指标/虚拟变量
如果DataFrame中的一列有k个不同的值，则可以衍生一个k列的值为1和0的矩阵或DataFrame。
pandas有一个get_dummies 函数用于实现该功能，pd.get_dummies(df['key'])
df = pd.DataFrame({'key':['b','b','a','c','a','b'],
'data':range(6)}
key data
0 b 0
1 b 1
2 a 2
3 c 3
4 a 4
5 b 5
pd.get_dummies(df['key'])
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
pd.get_dummies(df['data'])
0 1 2 3 4 5
0 1 0 0 0 0 0
1 0 1 0 0 0 0
2 0 0 1 0 0 0
3 0 0 0 1 0 0
4 0 0 0 0 1 0
5 0 0 0 0 0 1
#你可能想在指标DataFrame的列上后加入前缀，然后与其他数据合并。在get_dummies方法中有一个前缀参数prefix用于实现该功能：
pd.get_dummies(df['key'],prefix = 'key')
df_with_dummy = df[['data']].join(dummies)
data key_a key_b key_c
0 0 0 1 0
1 1 0 1 0
2 2 1 0 0
3 3 0 0 1
4 4 1 0 0
5 5 0 1 0
这里的join函数前面的索引项是一个列表，这样导出的是一个DataFrame，否则生成Series，与join函数大小不一致，会报错。
（!!!重点:书中205页案例）
字符串对象方法
一个逗号分隔的字符串可以使用split方法拆分成多块 val ='a,b, guide' val.split(',')
split常和strip一起使用，用于清除空格（包括换行） pieces = [x.strip() for x in val.split(',')]
这些字符串可以使用加法与两个冒号分隔符连接在一起：first,second,third = pieces
first + '::' + second+ '::' + third ---- 'a::b::guide'
在字符串‘：：’的join方法中传入一个列表或元组是一种更快的pythonic（python风格化）的方法 '::'.join(pieces)
使用和关键字in 是检验子字符串的最佳方法，index和find也能实现同样的功能
请注意find和index 的区别：index在字符串没有找到时抛出一个异常，而find返回的是-1 'guide' in val val.index(',') val.find(':')
count返回的是某个特定的子字符串在字符串中出现的次数 val.count(',')
replace 将用另一种模式替代一种模式。也可用于传入空字符来删除某个模式val.replace(',','::') val.replace(',','')
正则表达式
一种在文本中灵活查找或匹配字符串模式的方法。Python内建的re 模块适用于将正则表达式应用到字符串上的库。
re模块有三的主题：模式匹配、替代、拆分
描述一个或多个空白字符的正则表达式是 \s+
你可以使用re.compile自行编译，形成一个可复用的正则表达式对象：re.compile('\s+')
re.IGNORECASE使正则表达式不区分大小写 re.compile(pattern,flags = re.IGNORECASE)
如果想获得 一个所有匹配正则表达式的列表，使用findall方法 regex.findall(text)
search匹配对象只能返回 模式在字符串中起始和结束的位置
match如果在起始位置没有匹配到，则返回None
sub会返回 一个新的字符串，原字符串中的模式会被新的字符串替代：
pandas中的向量化字符串函数
部分向量字符串方法列表
