数据基础---《利用Python进行数据分析·第2版》第7章 数据清洗和准备

之前自己对于numpy和pandas是要用的时候东学一点西一点，直到看到《利用Python进行数据分析·第2版》，觉得只看这一篇就够了。非常感谢原博主的翻译和分享。

在数据分析和建模的过程中，相当多的时间要用在数据准备上：加载、清理、转换以及重塑。这些工作会占到分析师时间的80%或更多。有时，存储在文件和数据库中的数据的格式不适合某个特定的任务。许多研究者都选择使用通用编程语言（如Python、Perl、R或Java）或UNIX文本处理工具（如sed或awk）对数据格式进行专门处理。幸运的是，pandas和内置的Python标准库提供了一组高级的、灵活的、快速的工具，可以让你轻松地将数据规整为想要的格式。

如果你发现了一种本书或pandas库中没有的数据操作方式，请在邮件列表或GitHub网站上提出。实际上，pandas的许多设计和实现都是由真实应用的需求所驱动的。

在本章中，我会讨论处理缺失数据、重复数据、字符串操作和其它分析数据转换的工具。下一章，我会关注于用多种方法合并、重塑数据集。

7.1 处理缺失数据

在处理缺失值之前，最重要的是发现缺失值，由于数据来源可能比较复杂，不同系统中缺失值的表示方式并不一样，应该使用unique、value_count、describe这些函数先查看值的分布。

在许多数据分析工作中，缺失数据是经常发生的。pandas的目标之一就是尽量轻松地处理缺失数据。例如，pandas对象的所有描述性统计默认都不包括缺失数据。

缺失数据在pandas中呈现的方式有些不完美，但对于大多数用户可以保证功能正常。对于数值数据，pandas使用浮点值NaN（Not a Number）表示缺失数据。我们称其为哨兵值，可以方便的检测出来：

import pandas as pd
import numpy as np
string_data=pd.Series(['aardvark', 'artichoke', np.nan, 'avocado'])
string_data

0     aardvark
1    artichoke
2          NaN
3      avocado
dtype: object

string_data.isnull()

0    False
1    False
2     True
3    False
dtype: bool

在pandas中，我们采用了R语言中的惯用法，即将缺失值表示为NA，它表示不可用not available。在统计应用中，NA数据可能是不存在的数据或者虽然存在，但是没有观察到（例如，数据采集中发生了问题）。当进行数据清洗以进行分析时，最好直接对缺失数据进行分析，以判断数据采集的问题或缺失数据可能导致的偏差。

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

string_data[0]=None
string_data

0         None
1    artichoke
2          NaN
3      avocado
dtype: object

string_data.isnull()

0     True
1    False
2     True
3    False
dtype: bool

pandas项目中还在不断优化内部细节以更好处理缺失数据，像用户API功能，例如pandas.isnull，去除了许多恼人的细节。表7-1列出了一些关于缺失数据处理的函数。

方法	说明
drona	根据各标签的值中是否存在缺失数据对轴标签进行过滤,可通过阈值调节对缺失值的容忍度
fillIna	用指定值或插值方法(如f或bf)填充缺失数据
isnull	返回一个含有布尔值的对象,这些布尔值表示哪些值是缺失值/NA,该对象的类型与源类型一样
notnull	isnull否定式

表7-1 NA处理方法

滤除缺失数据

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

from numpy import nan as NA
data=pd.Series([1, NA, 3.5, NA, 7])
data

0    1.0
1    NaN
2    3.5
3    NaN
4    7.0
dtype: float64

data.dropna()

0    1.0
2    3.5
4    7.0
dtype: float64

data

0    1.0
1    NaN
2    3.5
3    NaN
4    7.0
dtype: float64

这等价于：

data[data.notnull()]

0    1.0
2    3.5
4    7.0
dtype: float64

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

data=pd.DataFrame([[1., 6.5, 3.], [1., NA, NA],[NA, NA, NA], [NA, 6.5, 3.]])
data

	0	1	2
0	1.0	6.5	3.0
1	1.0	NaN	NaN
2	NaN	NaN	NaN
3	NaN	6.5	3.0

cleaned =data.dropna()
cleaned

	0	1	2
0	1.0	6.5	3.0

传入how='all’将只丢弃全为NA的那些行：

data.dropna(how='all')

	0	1	2
0	1.0	6.5	3.0
1	1.0	NaN	NaN
3	NaN	6.5	3.0

用这种方式丢弃列，只需传入axis=1即可：

data[4]=NA
data

	0	1	2	4
0	1.0	6.5	3.0	NaN
1	1.0	NaN	NaN	NaN
2	NaN	NaN	NaN	NaN
3	NaN	6.5	3.0	NaN

data.dropna(axis=1,how='all')

	0	1	2
0	1.0	6.5	3.0
1	1.0	NaN	NaN
2	NaN	NaN	NaN
3	NaN	6.5	3.0

另一个滤除DataFrame行的问题涉及时间序列数据。假设你只想留下一部分观测数据，可以用thresh参数实现此目的：

df = pd.DataFrame(np.random.randn(7, 3))
df.iloc[:4,1]=NA
df.iloc[:2,2]=NA
df

	0	1	2
0	0.178632	NaN	NaN
1	1.246954	NaN	NaN
2	0.427497	NaN	-0.086087
3	-0.102457	NaN	0.308933
4	0.351837	0.299638	-0.749301
5	-1.035660	0.613805	1.387823
6	-1.446220	0.482409	-0.061598

df.dropna()

	0	1	2
4	0.351837	0.299638	-0.749301
5	-1.035660	0.613805	1.387823
6	-1.446220	0.482409	-0.061598

df.dropna(thresh=2)#至少要有两个以上缺失值的行才会被过滤

	0	1	2
2	0.427497	NaN	-0.086087
3	-0.102457	NaN	0.308933
4	0.351837	0.299638	-0.749301
5	-1.035660	0.613805	1.387823
6	-1.446220	0.482409	-0.061598

填充缺失数据

你可能不想滤除缺失数据（有可能会丢弃跟它有关的其他数据），而是希望通过其他方式填补那些“空洞”。对于大多数情况而言，fillna方法是最主要的函数。通过一个常数调用fillna就会将缺失值替换为那个常数值：

df.fillna(0)

	0	1	2
0	0.178632	0.000000	0.000000
1	1.246954	0.000000	0.000000
2	0.427497	0.000000	-0.086087
3	-0.102457	0.000000	0.308933
4	0.351837	0.299638	-0.749301
5	-1.035660	0.613805	1.387823
6	-1.446220	0.482409	-0.061598

若是通过一个字典调用fillna，就可以实现对不同的列填充不同的值：

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

	0	1	2
0	0.178632	0.500000	0.000000
1	1.246954	0.500000	0.000000
2	0.427497	0.500000	-0.086087
3	-0.102457	0.500000	0.308933
4	0.351837	0.299638	-0.749301
5	-1.035660	0.613805	1.387823
6	-1.446220	0.482409	-0.061598

fillna默认会返回新对象，但也可以对现有对象进行就地修改：

df.fillna(0, inplace=True)
df

	0	1	2
0	0.178632	0.000000	0.000000
1	1.246954	0.000000	0.000000
2	0.427497	0.000000	-0.086087
3	-0.102457	0.000000	0.308933
4	0.351837	0.299638	-0.749301
5	-1.035660	0.613805	1.387823
6	-1.446220	0.482409	-0.061598

对reindexing有效的那些插值方法也可用于fillna：

df = pd.DataFrame(np.random.randn(6, 3))
df.iloc[2:,1]=NA
df.iloc[4:,2]=NA
df

	0	1	2
0	1.075599	0.447231	-1.856044
1	-0.484075	-0.403936	-1.786744
2	0.583496	NaN	-0.003471
3	0.364301	NaN	1.570826
4	-1.121330	NaN	NaN
5	-0.384293	NaN	NaN

df.fillna(method='ffill')

	0	1	2
0	1.075599	0.447231	-1.856044
1	-0.484075	-0.403936	-1.786744
2	0.583496	-0.403936	-0.003471
3	0.364301	-0.403936	1.570826
4	-1.121330	-0.403936	1.570826
5	-0.384293	-0.403936	1.570826

df.fillna(method='ffill',limit=2)

	0	1	2
0	1.075599	0.447231	-1.856044
1	-0.484075	-0.403936	-1.786744
2	0.583496	-0.403936	-0.003471
3	0.364301	-0.403936	1.570826
4	-1.121330	NaN	1.570826
5	-0.384293	NaN	1.570826

在dropna中使用thresh来控制，而在fillna中使用limit来控制

只要有些创新，你就可以利用fillna实现许多别的功能。比如说，你可以传入Series的平均值或中位数：

data = pd.Series([1., NA, 3.5, NA, 7])
data.fillna(data.mean())

0    1.000000
1    3.833333
2    3.500000
3    3.833333
4    7.000000
dtype: float64

表7-2列出了fillna的参考。

参数	说明
value	用于填充缺失值的标量值或字典对象
method	插值方式。如果函数调用时未指定其他参数的话,默认为“ffill”
axis	待填充的轴,默认axis=0
inplace	修改调用者对象而不产生副本
limit	(对于前向和后向填充)可以连续填充的最大数量

fillna函数参数

7.2 数据转换

本章到目前为止介绍的都是数据的重排。另一类重要操作则是过滤、清理以及其他的转换工作。

移除重复数据

DataFrame中出现重复行(值一模一样的两行)有多种原因。下面就是一个例子：

data = pd.DataFrame({'k1': ['one', 'two'] * 3 + ['two'], 'k2': [1, 1, 2, 3, 3, 4, 4]})
data

	k1	k2
0	one	1
1	two	1
2	one	2
3	two	3
4	one	3
5	two	4
6	two	4

DataFrame的duplicated方法返回一个布尔型Series，表示各行是否是重复行（前面出现过的行）：

data.duplicated()

0    False
1    False
2    False
3    False
4    False
5    False
6     True
dtype: bool

还有一个与此相关的drop_duplicates方法，它会返回一个DataFrame，重复的数组会标为False：

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['V1']=range(7)
data

	k1	k2	V1
0	one	1	0
1	two	1	1
2	one	2	2
3	two	3	3
4	one	3	4
5	two	4	5
6	two	4	6

data.drop_duplicates(['k1'])

	k1	k2	V1
0	one	1	0
1	two	1	1

duplicated和drop_duplicates默认保留的是第一个出现的值组合。传入keep='last’则保留最后一个：

data.drop_duplicates(['k1','k2'],keep='last')

	k1	k2	V1
0	one	1	0
1	two	1	1
2	one	2	2
3	two	3	3
4	one	3	4
6	two	4	6

利用函数或映射进行数据转换

对于许多数据集，你可能希望根据数组、Series或DataFrame列中的值来实现转换工作。我们来看看下面这组有关肉类的数据：

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]})
data

	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

假设你想要添加一列表示该肉类食物来源的动物类型。我们先编写一个不同肉类到动物的映射：

meat_to_animal = { 'bacon': 'pig', 'pulled pork': 'pig', 'pastrami': 'cow', 'corned beef': 'cow', 'honey ham': 'pig', 'nova lox': 'salmon' }

Series的map方法可以接受一个函数或含有映射关系的字典型对象，但是这里有一个小问题，即有些肉类的首字母大写了，而另一些则没有。因此，我们还需要使用Series的str.lower方法，将各个值转换为小写：

lowercased =data['food'].str.lower()
lowercased

0          bacon
1    pulled pork
2          bacon
3       pastrami
4    corned beef
5          bacon
6       pastrami
7      honey ham
8       nova lox
Name: food, dtype: object

data['animal']=lowercased.map(meat_to_animal)
data

	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()])

0       pig
1       pig
2       pig
3       cow
4       cow
5       pig
6       cow
7       pig
8    salmon
Name: food, dtype: object

使用map是一种实现元素级转换以及其他数据清理工作的便捷方式。这里是利用Series的map函数，实现对Series元素级别的操作；也可以直接使用map,传入函数，和多个Series，实现多个Series对应元素之间的加减乘除等更为复杂的操作。

替换值

利用fillna方法填充缺失数据可以看做值替换的一种特殊情况。前面已经看到，map可用于修改对象的数据子集，而replace则提供了一种实现该功能的更简单、更灵活的方式。我们来看看下面这个Series：

data = pd.Series([1., -999., 2., -999., -1000., 3.])
data

0       1.0
1    -999.0
2       2.0
3    -999.0
4   -1000.0
5       3.0
dtype: float64

-999这个值可能是一个表示缺失数据的标记值。要将其替换为pandas能够理解的NA值，我们可以利用replace来产生一个新的Series（除非传入inplace=True）：

data.replace(-999,NA)

0       1.0
1       NaN
2       2.0
3       NaN
4   -1000.0
5       3.0
dtype: float64

如果你希望一次性替换多个值，可以传入一个由待替换值组成的列表以及一个替换值：：

data.replace([-999,-1000],NA)

0    1.0
1    NaN
2    2.0
3    NaN
4    NaN
5    3.0
dtype: float64

要让每个值有不同的替换值，可以传递一个替换列表：

data.replace([-999,-1000],[np.nan,0])

0    1.0
1    NaN
2    2.0
3    NaN
4    0.0
5    3.0
dtype: float64

传入的参数也可以是字典：

data.replace({-999:np.nan,-1000:0})

0    1.0
1    NaN
2    2.0
3    NaN
4    0.0
5    3.0
dtype: float64

笔记：data.replace方法与data.str.replace不同，后者做的是字符串的元素级替换。我们会在后面学习Series的字符串方法。

重命名轴索引

跟Series中的值一样，轴标签也可以通过函数或映射进行转换，从而得到一个新的不同标签的对象。轴还可以被就地修改，而无需新建一个数据结构。接下来看看下面这个简单的例子：

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

跟Series一样，轴索引也有一个map方法：

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)

	ONE	TWO	THREE	FOUR
Ohio	0	1	2	3
Colo	4	5	6	7
New	8	9	10	11

data

	one	two	three	four
OHIO	0	1	2	3
COLO	4	5	6	7
NEW	8	9	10	11

特别说明一下，rename可以结合字典型对象实现对部分轴标签的更新：

data.rename(index={'OHIO': 'INDIANA'},columns={'three': 'peekaboo'})

	one	two	peekaboo	four
INDIANA	0	1	2	3
COLO	4	5	6	7
NEW	8	9	10	11

rename可以实现复制DataFrame并对其索引和列标签进行赋值。如果希望就地修改某个数据集，传入inplace=True即可：

data.rename(index={'OHIO':'INDIANA'},inplace=True)
data

	one	two	three	four
INDIANA	0	1	2	3
COLO	4	5	6	7
NEW	8	9	10	11

离散化和面元划分

为了便于分析，连续数据常常被离散化或拆分为“面元”（bin）。假设有一组人员数据，而你希望将它们划分为不同的年龄组：

ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]

接下来将这些数据划分为“18到25”、“26到35”、“35到60”以及“60以上”几个面元。要实现该功能，你需要使用pandas的cut函数：

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返回的是一个特殊的Categorical对象。结果展示了pandas.cut划分的面元。你可以将其看做一组表示面元名称的字符串。它的底层含有一个表示不同分类名称的类型数组，以及一个codes属性中的年龄数据的标签：一组分隔区间，然后将元素用这些区间去套，套在哪个区间，就记录哪个区间；同时codes属性会对这些分隔区间编号。

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]')

pd.value_counts(cats)

(18, 25]     5
(35, 60]     3
(25, 35]     3
(60, 100]    1
dtype: int64

pd.value_counts(cats)是pandas.cut结果的面元计数。

跟“区间”的数学符号一样，圆括号表示开端，而方括号则表示闭端（包括）。哪边是闭端可以通过right=False进行修改：

pd.cut(ages,[18, 26, 36, 61, 100],right=False)

[[18, 26), [18, 26), [18, 26), [26, 36), [18, 26), ..., [26, 36), [61, 100), [36, 61), [36, 61), [26, 36)]
Length: 12
Categories (4, interval[int64]): [[18, 26) < [26, 36) < [36, 61) < [61, 100)]

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

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

[Youth, Youth, Youth, YoungAdult, Youth, ..., YoungAdult, Senior, MiddleAged, MiddleAged, YoungAdult]
Length: 12
Categories (4, object): [Youth < YoungAdult < MiddleAged < Senior]

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

data = np.random.rand(20)
pd.cut(data,4,precision=2)

[(0.72, 0.94], (0.29, 0.5], (0.072, 0.29], (0.072, 0.29], (0.5, 0.72], ..., (0.72, 0.94], (0.5, 0.72], (0.29, 0.5], (0.29, 0.5], (0.5, 0.72]]
Length: 20
Categories (4, interval[float64]): [(0.072, 0.29] < (0.29, 0.5] < (0.5, 0.72] < (0.72, 0.94]]

选项precision=2，限定小数只有两位。

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

data = np.random.randn(1000)  # Normally distributed
cats=pd.qcut(data,4)# Cut into quartiles
cats

[(-3.034, -0.659], (-0.659, -0.0201], (-0.659, -0.0201], (-3.034, -0.659], (-3.034, -0.659], ..., (-0.659, -0.0201], (-0.659, -0.0201], (-0.0201, 0.636], (0.636, 2.781], (-0.0201, 0.636]]
Length: 1000
Categories (4, interval[float64]): [(-3.034, -0.659] < (-0.659, -0.0201] < (-0.0201, 0.636] < (0.636, 2.781]]

pd.value_counts(cats)

(0.636, 2.781]       250
(-0.0201, 0.636]     250
(-0.659, -0.0201]    250
(-3.034, -0.659]     250
dtype: int64

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

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

[(-3.034, -1.314], (-1.314, -0.0201], (-1.314, -0.0201], (-3.034, -1.314], (-3.034, -1.314], ..., (-1.314, -0.0201], (-1.314, -0.0201], (-0.0201, 1.242], (1.242, 2.781], (-0.0201, 1.242]]
Length: 1000
Categories (4, interval[float64]): [(-3.034, -1.314] < (-1.314, -0.0201] < (-0.0201, 1.242] < (1.242, 2.781]]

本章稍后在讲解聚合和分组运算时会再次用到cut和qcut，因为这两个离散化函数对分位和分组分析非常重要。

检测和过滤异常值

过滤或变换异常值（outlier）在很大程度上就是运用数组运算。来看一个含有正态分布数据的DataFrame：

data = pd.DataFrame(np.random.randn(1000, 4))
data.describe()

	0	1	2	3
count	1000.000000	1000.000000	1000.000000	1000.000000
mean	-0.045435	0.015863	-0.024726	0.029081
std	1.014167	0.999113	0.958619	0.982428
min	-3.349742	-2.624249	-2.994383	-3.089542
25%	-0.755542	-0.680002	-0.678557	-0.619185
50%	-0.016888	0.018472	-0.030876	0.024967
75%	0.663736	0.643524	0.679940	0.716727
max	3.015235	3.782454	3.237579	3.334935

假设你想要找出某列中绝对值大小超过3的值：

col = data[2]
col[np.abs(col)>3]

463    3.237579
589    3.145094
833    3.005211
Name: 2, dtype: float64

要选出全部含有“超过3或－3的值”的行，你可以在布尔型DataFrame中使用any方法：

data[(np.abs(data)>3).any(1)]

	0	1	2	3
13	0.425707	0.720154	0.001886	3.334935
181	-3.349742	0.914764	-0.929595	1.245052
463	-1.595809	-0.476014	3.237579	-0.990840
464	0.523759	1.133464	1.641490	-3.089542
486	3.015235	0.144464	-1.153507	0.038683
589	-0.162133	-0.534091	3.145094	-1.444534
638	-3.189906	-1.052505	-0.058832	0.436706
728	-0.552710	3.330465	2.059002	1.501929
738	0.765028	3.782454	0.703223	1.129645
833	1.061304	0.612197	3.005211	0.165137

根据这些条件，就可以对值进行设置。下面的代码可以将值限制在区间－3到3以内：

data[np.abs(data)>3]=np.sign(data) * 3
data.describe()

	0	1	2	3
count	1000.000000	1000.000000	1000.000000	1000.000000
mean	-0.044910	0.014750	-0.025114	0.028836
std	1.012467	0.995417	0.957352	0.981076
min	-3.000000	-2.624249	-2.994383	-3.000000
25%	-0.755542	-0.680002	-0.678557	-0.619185
50%	-0.016888	0.018472	-0.030876	0.024967
75%	0.663736	0.643524	0.679940	0.716727
max	3.000000	3.000000	3.000000	3.000000

根据数据的值是正还是负，np.sign(data)可以生成1和-1：np.abs(data)>3得到的是一个含有bool值的DataFrame,而np.sign(data) * 3得到是也是一个DataFrame,bool值为真的地方被np.sign(data) * 3对应位置的值替换(其实data[np.abs(data)>3会在bool值为False的地方变成空,True的地方取到原数据)

np.sign(data).head()

	0	1	2	3
0	1.0	1.0	1.0	-1.0
1	-1.0	1.0	1.0	-1.0
2	1.0	1.0	1.0	-1.0
3	-1.0	1.0	1.0	1.0
4	1.0	1.0	-1.0	-1.0

排列和随机采样

利用numpy.random.permutation函数可以轻松实现对Series或DataFrame的列的排列工作（permuting，随机重排序）。通过需要排列的轴的长度调用permutation，可产生一个表示新顺序的整数数组：

df = pd.DataFrame(np.arange(5 * 4).reshape((5, 4)))
df

	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)
sampler

array([1, 3, 0, 4, 2])

然后就可以在基于iloc的索引操作或take函数中使用该数组了：

df.take(sampler)

	0	1	2	3
1	4	5	6	7
3	12	13	14	15
0	0	1	2	3
4	16	17	18	19
2	8	9	10	11

这种方法同样可以通过设置index属性实现。

如果不想用替换的方式选取随机子集，可以在Series和DataFrame上使用sample方法：

df.sample(3)

	0	1	2	3
1	4	5	6	7
0	0	1	2	3
4	16	17	18	19

要通过替换的方式产生样本（就是有放回的采样，允许重复选择），可以传递replace=True到sample：

choices = pd.Series([5, 7, -1, 6, 4])
draws = choices.sample(n=10, replace=True)
draws

4    4
1    7
4    4
1    7
0    5
2   -1
4    4
3    6
0    5
1    7
dtype: int64

计算指标/哑变量

另一种常用于统计建模或机器学习的转换方式是：将分类变量（categorical variable）转换为“哑变量”或“指标矩阵”。

如果DataFrame的某一列中含有k个不同的值，则可以派生出一个k列矩阵或DataFrame（其值全为1和0）。pandas有一个get_dummies函数可以实现该功能（其实自己动手做一个也不难）。使用之前的一个DataFrame例子：

df = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],'data1': range(6)})
df

	data1	key
0	0	b
1	1	b
2	2	a
3	3	c
4	4	a
5	5	b

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

有时候，你可能想给指标DataFrame的列加上一个前缀，以便能够跟其他数据进行合并。get_dummies的prefix参数可以实现该功能：

dummies = pd.get_dummies(df['key'],prefix='key')
dummies

	key_a	key_b	key_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

df_with_dummy =df[['data1']].join(dummies)#这里一定要用df[['data1']]，因为这样得到是DataFrame，而df[[data1']得到的是Series，Series没有join()
df_with_dummy

	data1	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

如果DataFrame中的某行同属于多个分类，则事情就会有点复杂。看一下MovieLens 1M数据集，14章会更深入地研究它：

mnames = ['movie_id', 'title', 'genres']
movies = pd.read_table('datasets/movielens/movies.dat', sep='::',header=None, names=mnames)
movies[:10]

c:\users\qingt\miniconda2\envs\python35\lib\site-packages\ipykernel_launcher.py:2: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support regex separators (separators > 1 char and different from '\s+' are interpreted as regex); you can avoid this warning by specifying engine='python'.

	movie_id	title	genres
0	1	Toy Story (1995)	Animation|Children's|Comedy
1	2	Jumanji (1995)	Adventure|Children's|Fantasy
2	3	Grumpier Old Men (1995)	Comedy|Romance
3	4	Waiting to Exhale (1995)	Comedy|Drama
4	5	Father of the Bride Part II (1995)	Comedy
5	6	Heat (1995)	Action|Crime|Thriller
6	7	Sabrina (1995)	Comedy|Romance
7	8	Tom and Huck (1995)	Adventure|Children's
8	9	Sudden Death (1995)	Action
9	10	GoldenEye (1995)	Action|Adventure|Thriller

要为每个genre添加指标变量就需要做一些数据规整操作。首先，我们从数据集中抽取出不同的genre值：

all_genres = []
for x in movies.genres:
    all_genres.extend(x.split('|'))
genres=pd.unique(all_genres)
genres

array(['Animation', "Children's", 'Comedy', 'Adventure', 'Fantasy',
       'Romance', 'Drama', 'Action', 'Crime', 'Thriller', 'Horror',
       'Sci-Fi', 'Documentary', 'War', 'Musical', 'Mystery', 'Film-Noir',
       'Western'], dtype=object)

构建指标DataFrame的方法之一是从一个全零DataFrame开始：

zero_matrix = np.zeros((len(movies),len(genres)))
zero_matrix[:5,:]

array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0.]])

dummies = pd.DataFrame(zero_matrix,columns=genres)
dummies.head()

	Animation	Children's	Comedy	Adventure	Fantasy	Romance	Drama	Action	Crime	Thriller	Horror	Sci-Fi	Documentary	War	Musical	Mystery	Film-Noir	Western
0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
1	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
2	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
3	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
4	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0

现在，迭代每一部电影，并将dummies各行的条目设为1。要这么做，我们使用dummies.columns来计算每个类型的列索引：

gen = movies.genres[0]
gen.split('|')

['Animation', "Children's", 'Comedy']

dummies.columns.get_indexer(gen.split('|'))

array([0, 1, 2], dtype=int64)

上面是做了个试验。
然后，根据索引，使用.iloc设定值：

for i,gen in enumerate(movies.genres):
    indices = dummies.columns.get_indexer(gen.split('|'))#不获取整数型索引而直接使用字符型索引应该也是可以的
    dummies.iloc[i,indices]=1
dummies.head()

	Animation	Children's	Comedy	Adventure	Fantasy	Romance	Drama	Action	Crime	Thriller	Horror	Sci-Fi	Documentary	War	Musical	Mystery	Film-Noir	Western
0	1.0	1.0	1.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
1	0.0	1.0	0.0	1.0	1.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
2	0.0	0.0	1.0	0.0	0.0	1.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
3	0.0	0.0	1.0	0.0	0.0	0.0	1.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
4	0.0	0.0	1.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0

然后，和以前一样，再将其与movies合并起来：

movies_windic = movies.join(dummies.add_prefix('Genre_'))
movies_windic.head()

	movie_id	title	genres	Genre_Animation	Genre_Children's	Genre_Comedy	Genre_Adventure	Genre_Fantasy	Genre_Romance	Genre_Drama	...	Genre_Crime	Genre_Thriller	Genre_Horror	Genre_Sci-Fi	Genre_Documentary	Genre_War	Genre_Musical	Genre_Mystery	Genre_Film-Noir	Genre_Western
0	1	Toy Story (1995)	Animation|Children's|Comedy	1.0	1.0	1.0	0.0	0.0	0.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
1	2	Jumanji (1995)	Adventure|Children's|Fantasy	0.0	1.0	0.0	1.0	1.0	0.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
2	3	Grumpier Old Men (1995)	Comedy|Romance	0.0	0.0	1.0	0.0	0.0	1.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
3	4	Waiting to Exhale (1995)	Comedy|Drama	0.0	0.0	1.0	0.0	0.0	0.0	1.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
4	5	Father of the Bride Part II (1995)	Comedy	0.0	0.0	1.0	0.0	0.0	0.0	0.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0

5 rows × 21 columns

笔记：对于很大的数据，用这种方式构建多成员指标变量就会变得非常慢。最好使用更低级的函数，将其写入NumPy数组，然后结果包装在DataFrame中。

一个对统计应用有用的秘诀是：结合get_dummies和诸如cut之类的离散化函数：

np.random.seed(12345)
values = np.random.rand(10)
values

array([0.92961609, 0.31637555, 0.18391881, 0.20456028, 0.56772503,
       0.5955447 , 0.96451452, 0.6531771 , 0.74890664, 0.65356987])

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

[(0.8, 1.0], (0.2, 0.4], (0.0, 0.2], (0.2, 0.4], (0.4, 0.6], (0.4, 0.6], (0.8, 1.0], (0.6, 0.8], (0.6, 0.8], (0.6, 0.8]]
Categories (5, interval[float64]): [(0.0, 0.2] < (0.2, 0.4] < (0.4, 0.6] < (0.6, 0.8] < (0.8, 1.0]]

pd.get_dummies(pd.cut(values,bins))

	(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

pd.get_dummies(pd.cut(values,bins,labels=['Q1','Q2','Q3','Q4','Q5']))

	Q1	Q2	Q3	Q4	Q5
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

我们用numpy.random.seed，使这个例子具有确定性。本书后面会介绍pandas.get_dummies。

7.3 字符串操作

Python能够成为流行的数据处理语言，部分原因是其简单易用的字符串和文本处理功能。大部分文本运算都直接做成了字符串对象的内置方法。对于更为复杂的模式匹配和文本操作，则可能需要用到正则表达式。pandas对此进行了加强，它使你能够对整组数据应用字符串表达式和正则表达式，而且能处理烦人的缺失数据。

字符串对象方法

对于许多字符串处理和脚本应用，内置的字符串方法已经能够满足要求了。例如，以逗号分隔的字符串可以用split拆分成数段,默认是空格：

val = 'a,b,  guido'
val.split(',')

['a', 'b', '  guido']

split常常与strip一起使用，以去除空白符（包括换行符）：

pieces = [x.strip() for x in val.split(',')]
pieces

['a', 'b', 'guido']

利用加法，可以将这些子字符串以双冒号分隔符的形式连接起来：

first, second, third = pieces
first+'::'+second+'::'+third

'a::b::guido'

但这种方式并不是很实用。一种更快更符合Python风格的方式是，向字符串"::"的join方法传入一个列表或元组：

'::'.join(pieces)

'a::b::guido'

但我个人更喜欢统一用’%s’%()的形式

其它方法关注的是子串定位。检测子串的最佳方式是利用Python的in关键字，还可以使用index和find：

'guido' in val

True

val.index(',')

1

val.find(':')

-1

完全可以把字符串当成一个列表来看。

注意find和index的区别：如果找不到字符串，index将会引发一个异常（而不是返回－1）：

val.index(':')

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-143-2c016e7367ac> in <module>()
----> 1 val.index(':')


ValueError: substring not found

与此相关，count可以返回指定子串的出现次数：

val.count(',')

2

replace用于将指定模式替换为另一个模式。通过传入空字符串，它也常常用于删除模式：

val.replace(',','::')

'a::b::  guido'

表7-3列出了Python内置的字符串方法。
这些运算大部分都能使用正则表达式实现（马上就会看到）。

表7－3： Python内置的字符串方法

说明	方法
count	返回子串在字符串中的出现次数（非重叠）
endswith、 startswith	如果字符串以某个后缀结尾（以某个前缀开头），则返回True
join	将字符串用作连接其他字符串序列的分隔符
index	如果在字符串中找到子串，则返回子串第一个字符所在的位置。如果没有找到，则引发 Value Error。

如果在字符串中找到子串，则返回第一个发现的子串的第一个
|find|字符所在的位置。如果没有找到，则返回－1|
|rfind|如果在字符串中找到子串，则返回最后一个发现的子串的第个字符所在的位置。如果没有找到，则返回－1|
|replace|用另一个字符率替换指定子串|
|strip、 rstrip、 lstrip去除空白符（包括换行符）。相当于对各个元素执行x.strip()（以及 rstrip、 Istrip）|
|split|通过指定的分隔符将字符串拆分为一组子串|
|lower、 upper|分别将字母字符转換为小写或大写|
|ljust、 rjust|用空格（或其他字符）填充字符串的空白侧以返回符合最低宽度的字符串|
|casefold |将字符转换为小写，并将任何特定区域的变量字符组合转换成一个通用的可比较形式。

正则表达式

正则表达式提供了一种灵活的在文本中搜索或匹配（通常比前者复杂）字符串模式的方式。正则表达式，常称作regex，是根据正则表达式语言编写的字符串。Python内置的re模块负责对字符串应用正则表达式。我将通过一些例子说明其使用方法。

笔记：正则表达式的编写技巧可以自成一章，超出了本书的范围。从网上和其它书可以找到许多非常不错的教程和参考资料。

re模块的函数可以分为三个大类：模式匹配、替换以及拆分。当然，它们之间是相辅相成的。一个regex描述了需要在文本中定位的一个模式，它可以用于许多目的。我们先来看一个简单的例子：假设我想要拆分一个字符串，分隔符为数量不定的一组空白符（制表符、空格、换行符等）。描述一个或多个空白符的regex是\s+：

import re
text = "foo    bar\t baz  \tqux"
text

'foo    bar\t baz  \tqux'

re.split('\s+', text)

['foo', 'bar', 'baz', 'qux']

调用re.split(’\s+’,text)时，正则表达式会先被编译，然后再在text上调用其split方法。你可以用re.compile自己编译regex以得到一个可重用的regex对象：

regex = re.compile('\s+')
regex.split(text)

['foo', 'bar', 'baz', 'qux']

如果只希望得到匹配regex的所有模式，则可以使用findall方法：

regex.findall(text)

['    ', '\t ', '  \t']

笔记：如果想避免正则表达式中不需要的转义（\），则可以使用原始字符串字面量如r’C:\x’（也可以编写其等价式’C:\x’）。

如果打算对许多字符串应用同一条正则表达式，强烈建议通过re.compile创建regex对象。这样将可以节省大量的CPU时间。

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)

对text使用findall将得到一组电子邮件地址：

regex.findall(text)

['dave@google.com', 'steve@gmail.com', 'rob@gmail.com', 'ryan@yahoo.com']

search返回的是文本中第一个电子邮件地址（以特殊的匹配项对象形式返回）。对于上面那个regex，匹配项对象只能告诉我们模式在原字符串中的起始和结束位置：

m=regex.search(text)
m

<_sre.SRE_Match object; span=(5, 20), match='dave@google.com'>

text[m.start():m.end()]

'dave@google.com'

regex.match则将返回None，因为它只匹配出现在字符串开头的模式：

print(regex.match(text))

None

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

print(regex.sub('REDACTED', text))

Dave REDACTED
Steve REDACTED
Rob REDACTED
Ryan REDACTED

假设你不仅想要找出电子邮件地址，还想将各个地址分成3个部分：用户名、域名以及域后缀。要实现此功能，只需将待分段的模式的各部分用圆括号包起来即可：

pattern = r'([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})'
regex = re.compile(pattern, flags=re.IGNORECASE)

由这种修改过的正则表达式所产生的匹配项对象，可以通过其groups方法返回一个由模式各段组成的元组：

m = regex.match('wesm@bright.net')
m.groups()

('wesm', 'bright', 'net')

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

regex.findall(text)

[('dave', 'google', 'com'),
 ('steve', 'gmail', 'com'),
 ('rob', 'gmail', 'com'),
 ('ryan', 'yahoo', 'com')]

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

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
Rob Username: rob, Domain: gmail, Suffix: com
Ryan Username: ryan, Domain: yahoo, Suffix: com

Python中还有许多的正则表达式，但大部分都超出了本书的范围。表7-4是一个简要概括。

表7－4：正则表达式方法

说明	方法
findall、 finditer	返回字符串中所有的非重叠匹配模式。 findall返回的是由所有模式组成的列表，而 inditer则通过一个迭代器逐个返回
match	从字符串起始位匹配模式，还可以对模式各部分进行分组。如果匹配到模式，则返回一个匹配项对象，否则返回None
search	扫描整个字符串以匹配模式。如果找到则返回一个匹配项对象。跟match不同，其匹配项可以位于字符串的任意位置，而不仅仅是起始处
split	根据找到的模式将字符串拆分为数段
sub、subn	将字符串中所有的（sub）或前n个（subn）模式替换为指定表达式2。在替换字符串中可以通过\1、\2等符号表示各分组项

pandas的矢量化字符串函数

清理待分析的散乱数据时，常常需要做一些字符串规整化工作。更为复杂的情况是，含有字符串的列有时还含有缺失数据：

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

Dave     dave@google.com
Rob        rob@gmail.com
Steve    steve@gmail.com
Wes                  NaN
dtype: object

data.isnull()

Dave     False
Rob      False
Steve    False
Wes       True
dtype: bool

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

data.str.contains('gmail')

Dave     False
Rob       True
Steve     True
Wes        NaN
dtype: object

也可以使用正则表达式，还可以加上任意re选项（如IGNORECASE）：

pattern

'([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\\.([A-Z]{2,4})'

data.str.findall(pattern,flags=re.IGNORECASE)

Dave     [(dave, google, com)]
Rob        [(rob, gmail, com)]
Steve    [(steve, gmail, com)]
Wes                        NaN
dtype: object

有两个办法可以实现矢量化的元素获取操作：要么使用str.get，要么在str属性上使用索引：

matches = data.str.match(pattern, flags=re.IGNORECASE)
matches

Dave     True
Rob      True
Steve    True
Wes       NaN
dtype: object

要访问嵌入列表中的元素，我们可以传递索引到这两个函数中：

matches.str.get(1)

Dave    NaN
Rob     NaN
Steve   NaN
Wes     NaN
dtype: float64

matches.str[0]

Dave    NaN
Rob     NaN
Steve   NaN
Wes     NaN
dtype: float64

你可以利用这种方法对字符串进行截取：

data.str[:5]

Dave     dave@
Rob      rob@g
Steve    steve
Wes        NaN
dtype: object

表7-5介绍了更多的pandas字符串方法。

方法	说明
cat	实现元素级的字符串连接操作，可指定分符
count	返回表示个字符串是否含有指定模式的布尔型数组
extract	使用带分组的正则表述式从字符中 Series提取一个成多个字符串，結果是ー个 DataFrame每组有一列
endswith	相当于对每个元素执行x.endswith（pattern）
startswith	相当于对每个元素执行x.startswith（pattern）
findall	计算各字符的模式列表
get	获取各元素的第i个字符
isalnum	相当于内置的str.alnum
isalpha	相当于内置的 str.isalpha
isdecimal	相当于内置的 str.decimal
isdigit	相当于内置的str.isdigit
islower	相当于内置的 str.islower
isnumeric	相当于内置的 str.isnumeric
isupper	相当于内置的str.upper
join	根据指定的分隔符将 Series中各元素的字符串连接起来
len	计算各字符串的长度
lower, upper	转换大小写。相当于对各个元素执行x.lower()或x.upper()
match	根据指定的正则表达式对各个元素执行re.match，返回匹配的组为列表
pad	在字符串的左边、右边或两边添加空白符
center	相当于 pad（side=‘both’
repeat	重复值。例如， s.str.repeat(3)相当于对各个字符串执行x*3
replace	用指定字符串换找到的模式
slice	对 Series中的各个字符串进行子串截取
split	根据分隔符或正则表达式对字符串进行拆分
strip	去除两边的空白符，包括新行
rstrip	去除右边的空白符
Istrip	去除左边的空白符出

表7-5 部分矢量化字符串方法

7.4 总结

高效的数据准备可以让你将更多的时间用于数据分析，花较少的时间用于准备工作，这样就可以极大地提高生产力。我们在本章中学习了许多工具，但覆盖并不全面。下一章，我们会学习pandas的聚合与分组。