11.1字符串对象方法
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 = piecesfirst + '::' + second + '::' + third输出结果:'a::b::guido'但这种方式并不是很实用。一种更快更符合Python风格的方式是，向字符串"::"的join方法传入一个列表或元组：
'::'.join(pieces)输出结果:'a::b::guido'其它方法关注的是子串定位。检测子串的最佳方式是利用Python的in关键字，还可以使用index和find：
'guido' in val输出结果:Trueval.index(',')输出结果:1val.find(':')输出结果:-1注意find和index的区别：如果找不到字符串，index将会引发一个异常（而不是返回－1）：
val.index(':')输出结果:---------------------------------------------------------------------------ValueError Traceback (most recent call last)<ipython-input-144-280f8b2856ce> in <module>()----> 1 val.index(':')ValueError: substring not found与此相关，count可以返回指定子串的出现次数：
val.count(',')输出结果:2replace用于将指定模式替换为另一个模式。通过传入空字符串，它也常常用于删除模式：
val.replace(',', '::')输出结果:'a::b:: guido'val.replace(',', '')输出结果:'ab guido'下图列出了Python内置的字符串方法。
这些运算大部分都能使用正则表达式实现（马上就会看到）。
casefold 将字符转换为小写，并将任何特定区域的变量字符组合转换成一个通用的可比较形式。
下一步
11.2正则表达式
正则表达式提供了一种灵活的在文本中搜索或匹配（通常比前者复杂）字符串模式的方式。正则表达式，常称作regex，是根据正则表达式语言编写的字符串。Python内置的re模块负责对字符串应用正则表达式。将通过一些例子说明其使用方法。
笔记：正则表达式的编写技巧可以自成一章，超出了本实验的范围。从网上和其它书可以找到许多非常不错的教程和参考资料。
re模块的函数可以分为三个大类：模式匹配、替换以及拆分。当然，它们之间是相辅相成的。一个regex描述了需要在文本中定位的一个模式，它可以用于许多目的。我们先来看一个简单的例子：假设我想要拆分一个字符串，分隔符为数量不定的一组空白符（制表符、空格、换行符等）。描述一个或多个空白符的regex是\s+：
import retext = "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.comSteve steve@gmail.comRob rob@gmail.comRyan ryan@yahoo.com"""pattern = r'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}'# re.IGNORECASE makes the regex case-insensitiveregex = 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 REDACTEDSteve REDACTEDRob REDACTEDRyan 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: comSteve Username: steve, Domain: gmail, Suffix: comRob Username: rob, Domain: gmail, Suffix: comRyan Username: ryan, Domain: yahoo, Suffix: comPython中还有许多的正则表达式，但大部分都超出了本实验的范围。表4-4是一个简要概括。
下一步
11.3Pandas的矢量化字符串函数
清理待分析的散乱数据时，常常需要做一些字符串规整化工作。更为复杂的情况是，含有字符串的列有时还含有缺失数据：
import numpy as npimport pandas as pddata = {'Dave': 'dave@google.com', 'Steve': 'steve@gmail.com','Rob': 'rob@gmail.com', 'Wes': np.nan}data = pd.Series(data)data输出结果:Dave dave@google.comRob rob@gmail.comSteve steve@gmail.comWes NaNdtype: objectdata.isnull()输出结果:Dave FalseRob FalseSteve FalseWes Truedtype: bool通过data.map，所有字符串和正则表达式方法都能被应用于（传入lambda表达式或其他函数）各个值，但是如果存在NA（null）就会报错。为了解决这个问题，Series有一些能够跳过NA值的面向数组方法，进行字符串操作。通过Series的str属性即可访问这些方法。例如，我们可以通过str.contains检查各个电子邮件地址是否含有"gmail"：
data.str.contains('gmail')输出结果:Dave FalseRob TrueSteve TrueWes NaNdtype: 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 NaNdtype: object有两个办法可以实现矢量化的元素获取操作：要么使用str.get，要么在str属性上使用索引：
matches = data.str.match(pattern, flags=re.IGNORECASE)matches输出结果:Dave TrueRob TrueSteve TrueWes NaNdtype: object要访问嵌入列表中的元素，我们可以传递索引到这两个函数中：
matches = data.str.findall(pattern, flags=re.IGNORECASE)matches.str.get(0)输出结果:Dave (dave, google, com)Steve (steve, gmail, com)Rob (rob, gmail, com)Wes NaNdtype: objectmatches.str[1]输出结果Dave (dave, google, com)Steve (steve, gmail, com)Rob (rob, gmail, com)Wes NaNdtype: object你可以利用这种方法对字符串进行截取：
data.str[:5]输出结果:Dave dave@Rob rob@gSteve steveWes NaNdtype: object下图介绍了更多的pandas字符串方法。
下一步
11.4层次化索引
层次化索引（hierarchical indexing）是pandas的一项重要功能，它使你能在一个轴上拥有多个（两个以上）索引级别。抽象点说，它使你能以低维度形式处理高维度数据。我们先来看一个简单的例子：创建一个Series，并用一个由列表或数组组成的列表作为索引：
data = pd.Series(np.random.randn(9), index=[['a', 'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'],[1, 2, 3, 1, 3, 1, 2, 2, 3]])data输出结果:a 1 -0.204708 2 0.478943 3 -0.519439b 1 -0.555730 3 1.965781c 1 1.393406 2 0.092908d 2 0.281746 3 0.769023dtype: float64看到的结果是经过美化的带有MultiIndex索引的Series的格式。索引之间的“间隔”表示“直接使用上面的标签”：
data.index输出结果:MultiIndex([('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 3), ('c', 1), ('c', 2), ('d', 2), ('d', 3)], )对于一个层次化索引的对象，可以使用所谓的部分索引，使用它选取数据子集的操作更简单：
data['b']输出结果:1 -0.5557303 1.965781dtype: float64data['b':'c']输出结果:b 1 -0.555730 3 1.965781c 1 1.393406 2 0.092908dtype: float64data.loc[['b', 'd']]输出结果:b 1 -0.555730 3 1.965781d 2 0.281746 3 0.769023dtype: float64有时甚至还可以在“内层”中进行选取：
data.loc[:, 2]输出结果:a 0.478943c 0.092908d 0.281746dtype: float64层次化索引在数据重塑和基于分组的操作（如透视表生成）中扮演着重要的角色。例如，可以通过unstack方法将这段数据重新安排到一个DataFrame中：
data.unstack()输出结果: 1 2 3a -0.204708 0.478943 -0.519439b -0.555730 NaN 1.965781c 1.393406 0.092908 NaNd NaN 0.281746 0.769023unstack的逆运算是stack：
data.unstack().stack()输出结果:a 1 -0.204708 2 0.478943 3 -0.519439b 1 -0.555730 3 1.965781c 1 1.393406 2 0.092908d 2 0.281746 3 0.769023dtype: float64对于一个DataFrame，每条轴都可以有分层索引：
frame = pd.DataFrame(np.arange(12).reshape((4, 3)),index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],columns=[['Ohio', 'Ohio', 'Colorado'],['Green', 'Red', 'Green']])frame输出结果: Ohio Colorado Green Red Greena 1 0 1 2 2 3 4 5b 1 6 7 8 2 9 10 11各层都可以有名字（可以是字符串，也可以是别的Python对象）。如果指定了名称，它们就会显示在控制台输出中：
frame.index.names = ['key1', 'key2']frame.columns.names = ['state', 'color']frame输出结果:state Ohio Coloradocolor Green Red Greenkey1 key2 a 1 0 1 2 2 3 4 5b 1 6 7 8 2 9 10 11注意：小心区分索引名state、color与行标签。
有了部分列索引，因此可以轻松选取列分组：
frame['Ohio']color Green Redkey1 key2 a 1 0 1 2 3 4b 1 6 7 2 9 10可以单独创建MultiIndex然后复用。上面那个DataFrame中的（带有分级名称）列可以这样创建：
data.index.from_arrays([['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']],names=['state', 'color'])输出结果:MultiIndex([( 'Ohio', 'Green'), ( 'Ohio', 'Red'), ('Colorado', 'Green')], names=['state', 'color'])下一步
11.5重排与分级排序
有时，你需要重新调整某条轴上各级别的顺序，或根据指定级别上的值对数据进行排序。swaplevel接受两个级别编号或名称，并返回一个互换了级别的新对象（但数据不会发生变化）：
frame.swaplevel('key1', 'key2')state Ohio Coloradocolor Green Red Greenkey2 key1 1 a 0 1 22 a 3 4 51 b 6 7 82 b 9 10 11而sort_index则根据单个级别中的值对数据进行排序。交换级别时，常常也会用到sort_index，这样最终结果就是按照指定顺序进行字母排序了：
frame.sort_index(level=1)state Ohio Coloradocolor Green Red Greenkey1 key2 a 1 0 1 2b 1 6 7 8a 2 3 4 5b 2 9 10 11frame.swaplevel(0, 1).sort_index(level=0)state Ohio Coloradocolor Green Red Greenkey2 key1 1 a 0 1 2 b 6 7 82 a 3 4 5 b 9 10 11下一步
11.6根据级别汇总统计
许多对DataFrame和Series的描述和汇总统计都有一个level选项，它用于指定在某条轴上求和的级别。再以上面那个DataFrame为例，我们可以根据行或列上的级别来进行求和：
frame.sum(level='key2')state Ohio Coloradocolor Green Red Greenkey2 1 6 8 102 12 14 16frame.sum(level='color', axis=1)color Green Redkey1 key2 a 1 2 1 2 8 4b 1 14 7 2 20 10这其实是利用了pandas的groupby功能。
下一步
11.7使用DataFrame的列进行索引
人们经常想要将DataFrame的一个或多个列当做行索引来用，或者可能希望将行索引变成DataFrame的列。以下面这个DataFrame为例：
frame = pd.DataFrame({'a': range(7), 'b': range(7, 0, -1), ....: 'c': ['one', 'one', 'one', 'two', 'two', ....: 'two', 'two'], ....: 'd': [0, 1, 2, 0, 1, 2, 3]})frame a b c d0 0 7 one 01 1 6 one 12 2 5 one 23 3 4 two 04 4 3 two 15 5 2 two 26 6 1 two 3DataFrame的set_index函数会将其一个或多个列转换为行索引，并创建一个新的DataFrame：
frame2 = frame.set_index(['c', 'd'])frame2 a bc d one 0 0 7 1 1 6 2 2 5two 0 3 4 1 4 3 2 5 2 3 6 1默认情况下，那些列会从DataFrame中移除，但也可以将其保留下来：
frame.set_index(['c', 'd'], drop=False) a b c dc d one 0 0 7 one 0 1 1 6 one 1 2 2 5 one 2two 0 3 4 two 0 1 4 3 two 1 2 5 2 two 2 3 6 1 two 3reset_index的功能跟set_index刚好相反，层次化索引的级别会被转移到列里面：
frame2.reset_index()Out[34]:c d a b0 one 0 0 71 one 1 1 62 one 2 2 53 two 0 3 44 two 1 4 35 two 2 5 26 two 3 6 1结束当前小节
12.1数据库风格的DataFrame合并
12.1.1 合并数据简介
pandas对象中的数据可以通过一些方式进行合并：
- pandas.merge可根据一个或多个键将不同DataFrame中的行连接起来。SQL或其他关系型数据库的用户对此应该会比较熟悉，因为它实现的就是数据库的join操作。
- pandas.concat可以沿着一条轴将多个对象堆叠到一起。
- 实例方法combine_first可以将重复数据拼接在一起，用一个对象中的值填充另一个对象中的缺失值。
12.1.2 举例详解
数据集的合并（merge）或连接（join）运算是通过一个或多个键将行连接起来的。这些运算是关系型数据库（基于SQL）的核心。pandas的merge函数是对数据应用这些算法的主要切入点。
以一个简单的例子开始：
import pandas as pdimport numpy as npdf1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], 'data1': range(7)})df2 = pd.DataFrame({'key': ['a', 'b', 'd'],'data2': range(3)})df1输出结果: data1 key0 0 b1 1 b2 2 a3 3 c4 4 a5 5 a6 6 bdf2输出结果: data2 key0 0 a1 1 b2 2 d这是一种多对一的合并。df1中的数据有多个被标记为a和b的行，而df2中key列的每个值则仅对应一行。对这些对象调用merge即可得到：
pd.merge(df1, df2)输出结果: data1 key data20 0 b 11 1 b 12 6 b 13 2 a 04 4 a 05 5 a 0注意，我并没有指明要用哪个列进行连接。如果没有指定，merge就会将重叠列的列名当做键。不过，最好明确指定一下：
pd.merge(df1, df2, on='key')输出结果: data1 key data20 0 b 11 1 b 12 6 b 13 2 a 04 4 a 05 5 a 0如果两个对象的列名不同，也可以分别进行指定：
df3 = pd.DataFrame({'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], 'data1': range(7)})df4 = pd.DataFrame({'rkey': ['a', 'b', 'd'], 'data2': range(3)})pd.merge(df3, df4, left_on='lkey', right_on='rkey')输出结果: lkey data1 rkey data20 b 0 b 11 b 1 b 12 b 6 b 13 a 2 a 04 a 4 a 05 a 5 a 0可能你已经注意到了，结果里面c和d以及与之相关的数据消失了。默认情况下，merge做的是“内连接”；结果中的键是交集。其他方式还有"left"、“right"以及"outer”。外连接求取的是键的并集，组合了左连接和右连接的效果：
pd.merge(df1, df2, how='outer')输出结果: key data1 data20 b 0.0 1.01 b 1.0 1.02 b 6.0 1.03 a 2.0 0.04 a 4.0 0.05 a 5.0 0.06 c 3.0 NaN7 d NaN 2.0下图对这些选项进行了总结。
多对多的合并有些不直观。看下面的例子：
df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],'data1': range(6)})df2 = pd.DataFrame({'key': ['a', 'b', 'a', 'b', 'd'],'data2': range(5)})df1输出结果: key data10 b 01 b 12 a 23 c 34 a 45 b 5df2输出结果: data2 key0 0 a1 1 b2 2 a3 3 b4 4 dpd.merge(df1, df2, on='key', how='left')输出结果: key data1 data20 b 0 1.01 b 0 3.02 b 1 1.03 b 1 3.04 a 2 0.05 a 2 2.06 c 3 NaN7 a 4 0.08 a 4 2.09 b 5 1.010 b 5 3.0多对多连接产生的是行的笛卡尔积。由于左边的DataFrame有3个"b"行，右边的有2个，所以最终结果中就有6个"b"行。连接方式只影响出现在结果中的不同的键的值：
pd.merge(df1, df2, how='inner')输出结果: key data1 data20 b 0 11 b 0 32 b 1 13 b 1 34 b 5 15 b 5 36 a 2 07 a 2 28 a 4 09 a 4 2要根据多个键进行合并，传入一个由列名组成的列表即可：
left = pd.DataFrame({'key1': ['foo', 'foo', 'bar'], 'key2': ['one', 'two', 'one'], 'lval': [1, 2, 3]})right = pd.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')输出结果: key1 key2 lval rval0 foo one 1.0 4.01 foo one 1.0 5.02 foo two 2.0 NaN3 bar one 3.0 6.04 bar two NaN 7.0结果中会出现哪些键组合取决于所选的合并方式，你可以这样来理解：多个键形成一系列元组，并将其当做单个连接键（当然，实际上并不是这么回事）。
注意：在进行列－列连接时，DataFrame对象中的索引会被丢弃。
对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠的问题（查看前面介绍的重命名轴标签），但merge有一个更实用的suffixes选项，用于指定附加到左右两个DataFrame对象的重叠列名上的字符串：
pd.merge(left, right, on='key1')输出结果: key1 key2_x lval key2_y rval0 foo one 1 one 41 foo one 1 one 52 foo two 2 one 43 foo two 2 one 54 bar one 3 one 65 bar one 3 two 7pd.merge(left, right, on='key1', suffixes=('_left', '_right'))输出结果: key1 key2_left lval key2_right rval0 foo one 1 one 41 foo one 1 one 52 foo two 2 one 43 foo two 2 one 54 bar one 3 one 65 bar one 3 two 7merge的参数请参见表5-2。使用DataFrame的行索引合并是下一节的主题。
下图merge函数的参数
indicator 添加特殊的列_merge，它可以指明每个行的来源，它的值有left_only、right_only或both，根据每行的合并数据的来源。
下一步
12.2索引上的合并
有时候，DataFrame中的连接键位于其索引中。在这种情况下，你可以传入left_index=True或right_index=True（或两个都传）以说明索引应该被用作连接键：
left1 = pd.DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'],'value': range(6)})right1 = pd.DataFrame({'group_val': [3.5, 7]}, index=['a', 'b'])left1输出结果: key value0 a 01 b 12 a 23 a 34 b 45 c 5right1输出结果: group_vala 3.5b 7.0pd.merge(left1, right1, left_on='key', right_index=True)输出结果: key value group_val0 a 0 3.52 a 2 3.53 a 3 3.51 b 1 7.04 b 4 7.0由于默认的merge方法是求取连接键的交集，因此你可以通过外连接的方式得到它们的并集：
pd.merge(left1, right1, left_on='key', right_index=True, how='outer')输出结果: key value group_val0 a 0 3.52 a 2 3.53 a 3 3.51 b 1 7.04 b 4 7.05 c 5 NaN对于层次化索引的数据，事情就有点复杂了，因为索引的合并默认是多键合并：
lefth = pd.DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio','Nevada', 'Nevada'], 'key2': [2000, 2001, 2002, 2001, 2002], 'data': np.arange(5.)})righth = pd.DataFrame(np.arange(12).reshape((6, 2)), index=[['Nevada', 'Nevada', 'Ohio', 'Ohio','Ohio', 'Ohio'], [2001, 2000, 2000, 2000, 2001, 2002]], columns=['event1', 'event2'])lefth输出结果: key1 key2 data0 Ohio 2000 0.01 Ohio 2001 1.02 Ohio 2002 2.03 Nevada 2001 3.04 Nevada 2002 4.0righth输出结果: event1 event2Nevada 2001 0 1 2000 2 3Ohio 2000 4 5 2000 6 7 2001 8 9 2002 10 11这种情况下，你必须以列表的形式指明用作合并键的多个列（注意用how='outer’对重复索引值的处理）：
pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)输出结果: key1 key2 data event1 event20 Ohio 2000 0.0 4 50 Ohio 2000 0.0 6 71 Ohio 2001 1.0 8 92 Ohio 2002 2.0 10 113 Nevada 2001 3.0 0 1pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True, how='outer')输出结果: key1 key2 data event1 event20 Ohio 2000 0.0 4.0 5.00 Ohio 2000 0.0 6.0 7.01 Ohio 2001 1.0 8.0 9.02 Ohio 2002 2.0 10.0 11.03 Nevada 2001 3.0 0.0 1.04 Nevada 2002 4.0 NaN NaN4 Nevada 2000 NaN 2.0 3.0同时使用合并双方的索引也没问题：
left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]],index=['a', 'c', 'e'],columns=['Ohio', 'Nevada'])right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13, 14]],index=['b', 'c', 'd', 'e'],columns=['Missouri', 'Alabama'])left2输出结果: Ohio Nevadaa 1.0 2.0c 3.0 4.0e 5.0 6.0right2 Missouri Alabamab 7.0 8.0c 9.0 10.0d 11.0 12.0e 13.0 14.0pd.merge(left2, right2, how='outer', left_index=True, right_index=True)输出结果: Ohio Nevada Missouri Alabamaa 1.0 2.0 NaN NaNb NaN NaN 7.0 8.0c 3.0 4.0 9.0 10.0d NaN NaN 11.0 12.0e 5.0 6.0 13.0 14.0DataFrame还有一个便捷的join实例方法，它能更为方便地实现按索引合并。它还可用于合并多个带有相同或相似索引的DataFrame对象，但要求没有重叠的列。在上面那个例子中，我们可以编写：
left2.join(right2, how='outer')输出结果: Ohio Nevada Missouri Alabamaa 1.0 2.0 NaN NaNb NaN NaN 7.0 8.0c 3.0 4.0 9.0 10.0d NaN NaN 11.0 12.0e 5.0 6.0 13.0 14.0因为一些历史版本的遗留原因，DataFrame的join方法默认使用的是左连接，保留左边表的行索引。它还支持在调用的DataFrame的列上，连接传递的DataFrame索引：
left1.join(right1, on='key')输出结果: key value group_val0 a 0 3.51 b 1 7.02 a 2 3.53 a 3 3.54 b 4 7.05 c 5 NaN最后，对于简单的索引合并，你还可以向join传入一组DataFrame，下一节会介绍更为通用的concat函数，也能实现此功能：
another = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [16., 17.]],index=['a', 'c', 'e', 'f'],columns=['New York','Oregon'])another输出结果: New York Oregona 7.0 8.0c 9.0 10.0e 11.0 12.0f 16.0 17.0left2.join([right2, another])输出结果: Ohio Nevada Missouri Alabama New York Oregona 1.0 2.0 NaN NaN 7.0 8.0c 3.0 4.0 9.0 10.0 9.0 10.0e 5.0 6.0 13.0 14.0 11.0 12.0left2.join([right2, another], how='outer')输出结果: Ohio Nevada Missouri Alabama New York Oregona 1.0 2.0 NaN NaN 7.0 8.0b NaN NaN 7.0 8.0 NaN NaNc 3.0 4.0 9.0 10.0 9.0 10.0d NaN NaN 11.0 12.0 NaN NaNe 5.0 6.0 13.0 14.0 11.0 12.0f NaN NaN NaN NaN 16.0 17.0下一步
12.3轴向连接
另一种数据合并运算也被称作连接（concatenation）、绑定（binding）或堆叠（stacking）。NumPy的concatenation函数可以用NumPy数组来做：
arr = np.arange(12).reshape((3, 4))
arr
输出结果:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
np.concatenate([arr, arr], axis=1)
输出结果:
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对象（如Series和DataFrame），带有标签的轴使你能够进一步推广数组的连接运算。具体点说，你还需要考虑以下这些东西：
- 如果对象在其它轴上的索引不同，我们应该合并这些轴的不同元素还是只使用交集？
- 连接的数据集是否需要在结果对象中可识别？
- 连接轴中保存的数据是否需要保留？许多情况下，DataFrame默认的整数标签最好在连接时删掉。
pandas的concat函数提供了一种能够解决这些问题的可靠方式。下面将给出一些例子来讲解其使用方式。假设有三个没有重叠索引的Series：
s1 = pd.Series([0, 1], index=['a', 'b'])
s2 = pd.Series([2, 3, 4], index=['c', 'd', 'e'])
s3 = pd.Series([5, 6], index=['f', 'g'])
对这些对象调用concat可以将值和索引粘合在一起：
pd.concat([s1, s2, s3])
输出结果:
a 0
b 1
c 2
d 3
e 4
f 5
g 6
dtype: int64
默认情况下，concat是在axis=0上工作的，最终产生一个新的Series。如果传入axis=1，则结果就会变成一个DataFrame（axis=1是列）：
pd.concat([s1, s2, s3], axis=1)
输出结果:
0 1 2
a 0.0 NaN NaN
b 1.0 NaN NaN
c NaN 2.0 NaN
d NaN 3.0 NaN
e NaN 4.0 NaN
f NaN NaN 5.0
g NaN NaN 6.0
这种情况下，另外的轴上没有重叠，从索引的有序并集（外连接）上就可以看出来。传入join='inner’即可得到它们的交集：
s4 = pd.concat([s1, s3])
s4
输出结果:
a 0
b 1
f 5
g 6
dtype: int64
pd.concat([s1, s4], axis=1)
输出结果:
0 1
a 0.0 0
b 1.0 1
f NaN 5
g NaN 6
pd.concat([s1, s4], axis=1, join='inner')
输出结果:
0 1
a 0 0
b 1 1
在这个例子中，f和g标签消失了，是因为使用的是join='inner’选项。
参与连接的片段在结果中区分不开。假设你想要在连接轴上创建一个层次化索引。使用keys参数即可达到这个目的：
result = pd.concat([s1, s1, s3], keys=['one','two', 'three'])
result
输出结果:
one a 0
b 1
two a 0
b 1
three f 5
g 6
dtype: int64
result.unstack()
输出结果:
a b f g
one 0.0 1.0 NaN NaN
two 0.0 1.0 NaN NaN
three NaN NaN 5.0 6.0
如果沿着axis=1对Series进行合并，则keys就会成为DataFrame的列头：
pd.concat([s1, s2, s3], axis=1, keys=['one','two', 'three'])
输出结果:
one two three
a 0.0 NaN NaN
b 1.0 NaN NaN
c NaN 2.0 NaN
d NaN 3.0 NaN
e NaN 4.0 NaN
f NaN NaN 5.0
g NaN NaN 6.0
同样的逻辑也适用于DataFrame对象：
df1 = pd.DataFrame(np.arange(6).reshape(3, 2), index=['a', 'b', 'c'],
....: columns=['one', 'two'])
df2 = pd.DataFrame(5 + np.arange(4).reshape(2, 2), index=['a', 'c'],
....: columns=['three', 'four'])
df1
输出结果:
one two
a 0 1
b 2 3
c 4 5
df2
输出结果:
three four
a 5 6
c 7 8
pd.concat([df1, df2], axis=1, keys=['level1', 'level2'])
输出结果:
level1 level2
one two three four
a 0 1 5.0 6.0
b 2 3 NaN NaN
c 4 5 7.0 8.0
如果传入的不是列表而是一个字典，则字典的键就会被当做keys选项的值：
pd.concat({'level1': df1, 'level2': df2}, axis=1)
输出结果:
level1 level2
one two three four
a 0 1 5.0 6.0
b 2 3 NaN NaN
c 4 5 7.0 8.0
此外还有两个用于管理层次化索引创建方式的参数（参见表5-3）。举个例子，我们可以用names参数命名创建的轴级别：
pd.concat([df1, df2], axis=1, keys=['level1', 'level2'],names=['upper', 'lower'])
upper level1 level2
lower one two three four
a 0 1 5.0 6.0
b 2 3 NaN NaN
c 4 5 7.0 8.0
最后一个关于DataFrame的问题是，DataFrame的行索引不包含任何相关数据：
df1 = pd.DataFrame(np.random.randn(3, 4), columns=['a', 'b', 'c', 'd'])
df2 = pd.DataFrame(np.random.randn(2, 3), columns=['b', 'd', 'a'])
df1
输出结果:
a b c d
0 1.246435 1.007189 -1.296221 0.274992
1 0.228913 1.352917 0.886429 -2.001637
2 -0.371843 1.669025 -0.438570 -0.539741
df2
输出结果:
b d a
0 0.476985 3.248944 -1.021228
1 -0.577087 0.124121 0.302614
在这种情况下，传入ignore_index=True即可：
pd.concat([df1, df2], ignore_index=True)
输出结果:
a b c d
0 1.246435 1.007189 -1.296221 0.274992
1 0.228913 1.352917 0.886429 -2.001637
2 -0.371843 1.669025 -0.438570 -0.539741
3 -1.021228 0.476985 NaN 3.248944
4 0.302614 -0.577087 NaN 0.124121
下一步
12.4合并重叠数据
还有一种数据组合问题不能用简单的合并（merge）或连接（concatenation）运算来处理。比如说，你可能有索引全部或部分重叠的两个数据集。举个有启发性的例子，我们使用NumPy的where函数，它表示一种等价于面向数组的if-else：
a = pd.Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan],index=['f', 'e', 'd', 'c', 'b', 'a'])b = pd.Series(np.arange(len(a), dtype=np.float64),index=['f', 'e', 'd', 'c', 'b', 'a'])b[-1] = np.nana输出结果:f NaNe 2.5d NaNc 3.5b 4.5a NaNdtype: float64b输出结果:f 0.0e 1.0d 2.0c 3.0b 4.0a NaNdtype: float64np.where(pd.isnull(a), b, a)输出结果:array([ 0. , 2.5, 2. , 3.5, 4.5, nan])Series有一个combine_first方法，实现的也是一样的功能，还带有pandas的数据对齐：
b[:-2].combine_first(a[2:])输出结果:a NaNb 4.5c 3.0d 2.0e 1.0f 0.0dtype: float64对于DataFrame，combine_first自然也会在列上做同样的事情，因此你可以将其看做：用传递对象中的数据为调用对象的缺失数据“打补丁”：
df1 = pd.DataFrame({'a': [1., np.nan, 5., np.nan],'b': [np.nan, 2., np.nan, 6.], 'c': range(2, 18, 4)})df2 = pd.DataFrame({'a': [5., 4., np.nan, 3., 7.], 'b': [np.nan, 3., 4., 6., 8.]})df1输出结果: a b c0 1.0 NaN 21 NaN 2.0 62 5.0 NaN 103 NaN 6.0 14df2输出结果: a b0 5.0 NaN1 4.0 3.02 NaN 4.03 3.0 6.04 7.0 8.0df1.combine_first(df2)输出结果: a b c0 1.0 NaN 2.01 4.0 2.0 6.02 5.0 4.0 10.03 3.0 6.0 14.04 7.0 8.0 NaN下一步
12.5重塑层次化索引
有许多用于重新排列表格型数据的基础运算。这些函数也称作重塑（reshape）或轴向旋转（pivot）运算。
层次化索引为DataFrame数据的重排任务提供了一种具有良好一致性的方式。主要功能有二：
- stack：将数据的列“旋转”为行。
- unstack：将数据的行“旋转”为列。
下面将通过一系列的范例来讲解这些操作。接下来看一个简单的DataFrame，其中的行列索引均为字符串数组：
data = pd.DataFrame(np.arange(6).reshape((2, 3)), index=pd.Index(['Ohio','Colorado'], name='state'),columns=pd.Index(['one', 'two', 'three'],name='number'))
data
输出结果:
number one two three
state
Ohio 0 1 2
Colorado 3 4 5
对该数据使用stack方法即可将列转换为行，得到一个Series：
result = data.stack()
result
输出结果:
state number
Ohio one 0
two 1
three 2
Colorado one 3
two 4
three 5
dtype: int64
对于一个层次化索引的Series，你可以用unstack将其重排为一个DataFrame：
result.unstack()
输出结果:
number one two three
state
Ohio 0 1 2
Colorado 3 4 5
默认情况下，unstack操作的是最内层（stack也是如此）。传入分层级别的编号或名称即可对其它级别进行unstack操作：
result.unstack(0)
输出结果:
state Ohio Colorado
number
one 0 3
two 1 4
three 2 5
result.unstack('state')
输出结果:
state Ohio Colorado
number
one 0 3
two 1 4
three 2 5
如果不是所有的级别值都能在各分组中找到的话，则unstack操作可能会引入缺失数据：
s1 = pd.Series([0, 1, 2, 3], index=['a', 'b', 'c', 'd'])
s2 = pd.Series([4, 5, 6], index=['c', 'd', 'e'])
data2 = pd.concat([s1, s2], keys=['one', 'two'])
data2
输出结果:
one a 0
b 1
c 2
d 3
two c 4
d 5
e 6
dtype: int64
data2.unstack()
输出结果:
a b c d e
one 0.0 1.0 2.0 3.0 NaN
two NaN NaN 4.0 5.0 6.0
stack默认会滤除缺失数据，因此该运算是可逆的：
data2.unstack()
输出结果:
a b c d e
one 0.0 1.0 2.0 3.0 NaN
two NaN NaN 4.0 5.0 6.0
data2.unstack().stack()
输出结果:
one a 0.0
b 1.0
c 2.0
d 3.0
two c 4.0
d 5.0
e 6.0
dtype: float64
data2.unstack().stack(dropna=False)
输出结果:
one a 0.0
b 1.0
c 2.0
d 3.0
e NaN
two a NaN
b NaN
c 4.0
d 5.0
e 6.0
dtype: float64
在对DataFrame进行unstack操作时，作为旋转轴的级别将会成为结果中的最低级别：
df = pd.DataFrame({'left': result, 'right': result + 5},
.....: columns=pd.Index(['left', 'right'], name='side'))
df
输出结果:
side left right
state number
Ohio one 0 5
two 1 6
three 2 7
Colorado one 3 8
two 4 9
three 5 10
df.unstack('state')
输出结果:
side left right
state Ohio Colorado Ohio Colorado
number
one 0 3 5 8
two 1 4 6 9
three 2 5 7 10
当调用stack，我们可以指明轴的名字：
df.unstack('state').stack('side')
输出结果:
state Colorado Ohio
number side
one left 3 0
right 8 5
two left 4 1
right 9 6
three left 5 2
right 10 7
下一步
12.6轴向旋转
12.6.1 将“长格式”旋转为“宽格式”
多个时间序列数据通常是以所谓的“长格式”（long）或“堆叠格式”（stacked）存储在数据库和CSV中的。我们先加载一些示例数据，做一些时间序列规整和数据清洗：
data = pd.read_csv('/home/ec2-user/jupyter_Code/data/examples/macrodata.csv')data.head()输出结果: year quarter realgdp realcons realinv realgovt realdpi cpi m1 tbilrate unemp pop infl realint0 1959.0 1.0 2710.349 1707.4 286.898 470.045 1886.9 28.98 139.7 2.82 5.8 177.146 0.00 0.001 1959.0 2.0 2778.801 1733.7 310.859 481.301 1919.7 29.15 141.7 3.08 5.1 177.830 2.34 0.742 1959.0 3.0 2775.488 1751.8 289.226 491.260 1916.4 29.35 140.5 3.82 5.3 178.657 2.74 1.093 1959.0 4.0 2785.204 1753.7 299.356 484.052 1931.3 29.37 140.0 4.33 5.6 179.386 0.27 4.064 1960.0 1.0 2847.699 1770.5 331.722 462.199 1955.5 29.54 139.6 3.50 5.2 180.007 2.31 1.19periods = pd.PeriodIndex(year=data.year, quarter=data.quarter,name='date')columns = pd.Index(['realgdp', 'infl', 'unemp'], name='item')data = data.reindex(columns=columns)data.index = periods.to_timestamp('D', 'end')ldata = data.stack().reset_index().rename(columns={0: 'value'})这就是多个时间序列（或者其它带有两个或多个键的可观察数据，这里，我们的键是date和item）的长格式。表中的每行代表一次观察。
关系型数据库（如MySQL）中的数据经常都是这样存储的，因为固定架构（即列名和数据类型）有一个好处：随着表中数据的添加，item列中的值的种类能够增加。在前面的例子中，date和item通常就是主键（用关系型数据库的说法），不仅提供了关系完整性，而且提供了更为简单的查询支持。有的情况下，使用这样的数据会很麻烦，你可能会更喜欢DataFrame，不同的item值分别形成一列，date列中的时间戳则用作索引。DataFrame的pivot方法完全可以实现这个转换：
pivoted = ldata.pivot('date', 'item', 'value')pivoted输出结果item infl realgdp unemp date 1959-03-31 23:59:59.999999999 0.00 2710.349 5.81959-06-30 23:59:59.999999999 2.34 2778.801 5.11959-09-30 23:59:59.999999999 2.74 2775.488 5.31959-12-31 23:59:59.999999999 0.27 2785.204 5.61960-03-31 23:59:59.999999999 2.31 2847.699 5.2... ... ... ...2008-09-30 23:59:59.999999999 -3.16 13324.600 6.02008-12-31 23:59:59.999999999 -8.79 13141.920 6.92009-03-31 23:59:59.999999999 0.94 12925.410 8.12009-06-30 23:59:59.999999999 3.37 12901.504 9.22009-09-30 23:59:59.999999999 3.56 12990.341 9.6前两个传递的值分别用作行和列索引，最后一个可选值则是用于填充DataFrame的数据列。假设有两个需要同时重塑的数据列：
ldata['value2'] = np.random.randn(len(ldata))输出结果： date item value value20 1959-03-31 23:59:59.999999999 realgdp 2710.349 0.8956391 1959-03-31 23:59:59.999999999 infl 0.000 0.7886302 1959-03-31 23:59:59.999999999 unemp 5.800 1.8249903 1959-06-30 23:59:59.999999999 realgdp 2778.801 -0.7316434 1959-06-30 23:59:59.999999999 infl 2.340 0.2063695 1959-06-30 23:59:59.999999999 unemp 5.100 -0.3878276 1959-09-30 23:59:59.999999999 realgdp 2775.488 0.3484867 1959-09-30 23:59:59.999999999 infl 2.740 -0.0722938 1959-09-30 23:59:59.999999999 unemp 5.300 1.7901699 1959-12-31 23:59:59.999999999 realgdp 2785.204 0.106156如果忽略最后一个参数，得到的DataFrame就会带有层次化的列：
pivoted = ldata.pivot('date', 'item')pivoted[:5]输出结果: value value2item infl realgdp unemp infl realgdp unemp date 1959-03-31 23:59:59.999999999 0.00 2710.349 5.8 0.788630 0.895639 1.8249901959-06-30 23:59:59.999999999 2.34 2778.801 5.1 0.206369 -0.731643 -0.3878271959-09-30 23:59:59.999999999 2.74 2775.488 5.3 -0.072293 0.348486 1.7901691959-12-31 23:59:59.999999999 0.27 2785.204 5.6 0.102248 0.106156 0.4667801960-03-31 23:59:59.999999999 2.31 2847.699 5.2 -1.043165 0.570924 0.904621pivoted['value'][:5]输出结果:item infl realgdp unemp date 1959-03-31 23:59:59.999999999 0.00 2710.349 5.81959-06-30 23:59:59.999999999 2.34 2778.801 5.11959-09-30 23:59:59.999999999 2.74 2775.488 5.31959-12-31 23:59:59.999999999 0.27 2785.204 5.61960-03-31 23:59:59.999999999 2.31 2847.699 5.2注意，pivot其实就是用set_index创建层次化索引，再用unstack重塑：
unstacked = ldata.set_index(['date', 'item']).unstack('item')unstacked[:7]输出结果: value value2item infl realgdp unemp infl realgdp unemp date 1959-03-31 23:59:59.999999999 0.00 2710.349 5.8 0.788630 0.895639 1.8249901959-06-30 23:59:59.999999999 2.34 2778.801 5.1 0.206369 -0.731643 -0.3878271959-09-30 23:59:59.999999999 2.74 2775.488 5.3 -0.072293 0.348486 1.7901691959-12-31 23:59:59.999999999 0.27 2785.204 5.6 0.102248 0.106156 0.4667801960-03-31 23:59:59.999999999 2.31 2847.699 5.2 -1.043165 0.570924 0.9046211960-06-30 23:59:59.999999999 0.14 2834.390 5.2 1.299669 -3.164449 1.2426821960-09-30 23:59:59.999999999 2.70 2839.022 5.6 -0.398500 -1.471695 -2.06390212.6.2 将“宽格式”旋转为“长格式”
旋转DataFrame的逆运算是pandas.melt。它不是将一列转换到多个新的DataFrame，而是合并多个列成为一个，产生一个比输入长的DataFrame。看一个例子：
df = pd.DataFrame({'key': ['foo', 'bar', 'baz'],'A': [1, 2, 3],'B': [4, 5, 6],'C': [7, 8, 9]})df输出结果: A B C key0 1 4 7 foo1 2 5 8 bar2 3 6 9 bazkey列可能是分组指标，其它的列是数据值。当使用pandas.melt，我们必须指明哪些列是分组指标。下面使用key作为唯一的分组指标：
melted = pd.melt(df, ['key'])melted输出结果: key variable value0 foo A 11 bar A 22 baz A 33 foo B 44 bar B 55 baz B 66 foo C 77 bar C 88 baz C 9使用pivot，可以重塑回原来的样子：
reshaped = melted.pivot('key', 'variable', 'value')reshaped输出结果:variable A B Ckey bar 2 5 8baz 3 6 9foo 1 4 7因为pivot的结果从列创建了一个索引，用作行标签，我们可以使用reset_index将数据移回列：
reshaped.reset_index()输出结果:variable key A B C0 bar 2 5 81 baz 3 6 92 foo 1 4 7你还可以指定列的子集，作为值的列：
pd.melt(df, id_vars=['key'], value_vars=['A', 'B'])输出结果: key variable value0 foo A 11 bar A 22 baz A 33 foo B 44 bar B 55 baz B 6pandas.melt也可以不用分组指标：
pd.melt(df, value_vars=['A', 'B', 'C'])输出结果: variable value0 A 11 A 22 A 33 B 44 B 55 B 66 C 77 C 88 C 9pd.melt(df, value_vars=['key', 'A', 'B'])输出结果: variable value0 key foo1 key bar2 key baz3 A 14 A 25 A 36 B 47 B 58 B 6结束当前小节
347
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
