采集的数据存储后通常会分为多个文件或数据库，如何将这些文件按需拼接，或按键进行连接十分重要。这节将介绍数据索引的复杂操作如分层索引，stack,unstack,seet_index,reset_index等帮助重构数据，数据的拼接如merge,join,concat,combine_first等帮助连接数据，以及数据透视表的使用。

A. 分层索引

1. 创建分层索引

A.1.1 Series分层索引

• 在创建Series时，使用嵌套列表的方式指定它的索引，就会生成分层索引的Series数组
• 可以使用S.index.names 对多层索引命名
• S.index 是一个多层索引对象MultiIndex，它的每一个元素是一个元组

data = pd.Series(np.random.uniform(size=9),
                 index=[["a", "a", "a", "b", "b", "c", "c", "d", "d"],
                        [1, 2, 3, 1, 3, 1, 2, 2, 3]],
                )
data.index.names = ['word','num']
                

A.1.2 DataFrame分层索引

• 在创建DataFrame时，指定它的行和列都是用嵌套列表，就会生成分层索引的Df
• 可以对行和列的分层索引命名 Df.index.name=[ ] ,Df.columns.names=[ ]

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.index.names = ["key1", "key2"]
frame.columns.names = ["state", "color"]                             

A.1.3 直接创建多层索引再重用它

除了在创建Series和DataFrame时，通过嵌套列别指定所层索引的形式，还可以直接生成所层索引MultiIndex，这样可以重复使用这个索引。

pd.MultiIndex.from_arrays([["Ohio", "Ohio", "Colorado"],
                              ["Green", "Red", "Green"]],
                              names=["state", "color"])

2. 分层索引的引用与属性

A.2.1 对分层Series的引用

A.3.1 可以看出Series分层索引与Df之间可以相互转换，所以使用对Df的引用方法可以实现对Series的引用。下面实例中data是前文的data

A.2.1 分层DataFrame的层数判断

Df.index.nlevels
Df.columns.nelvels

3. 多层行列索引之间的转换

A.3.1 Series.unstack() DataFrame.stack() 用法

每一次使用unstack相当于把行中最内层的索引放到列最内层中，比如原来行有a,b,c和1,2,3这两种索引，使用一次unstack会把内层的1,2,3这个索引放到行上，形成Df。

对于三层的行索引可以更清晰的看出，比如下面这个数据有a,b,c ;1,2,3;x,y,z三种，每一次使用unstack会把最内层的行索引放到最内层的列索引中。直到最后索引顺序变为x,y,z；1,2,3；a,b,c。

data_ = pd.Series(np.random.uniform(size=9),
                 index=[["a", "a", "a", "b", "b", "c", "c", "d", "d"],
                        [1, 2, 3, 1, 3, 1, 2, 2, 3],['x','y','x','y','x','y','x','y','x']]
                )
data_.index.nlevels
data_.unstack()
data_.unstack().unstack()
data_.unstack().unstack().unstack()

• 可以通过level指定要挪动的索引，可以使用整数位置或者索引标签名称，但是默认还是会放到列的最内侧。
  df.unstack(level=0)
  df.unstack(level=‘name1’)
• 使用.stack方法后会默认将含有空值的行删除，使用dropna=Falese参数可以保留空值。

data = pd.DataFrame(np.arange(6).reshape((2, 3)),
                    index=pd.Index(["Ohio", "Colorado"], name="state"),
                    columns=pd.Index(["one", "two", "three"],
                    name="number"))
result.unstack(level=0)
result.unstack(level="state")

s1 = pd.Series([0, 1, 2, 3], index=["a", "b", "c", "d"], dtype="Int64")
s2 = pd.Series([4, 5, 6], index=["c", "d", "e"], dtype="Int64")
data2 = pd.concat([s1, s2], keys=["one", "two"])

data2.unstack()
data2.unstack().stack(dropna=False)

df = pd.DataFrame({"left": result, "right": result + 5},
                  columns=pd.Index(["left", "right"], name="side"))
df
df.unstack(level="state")

df.unstack(level="state").stack(level="side")

A.3.2 DataFrame.set_index 与 DataFrame.reset_index

• 可以 选择把Df的某列或某几列作为多层索引Df.set_index([‘col1’,‘col2’])
• 默认变成索引的列不再出现在列中，但是使用drop=False可以让成为索引的列仍然出现在行中
• 将所有的索引都移动到列中Df.reset_index

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]})
frame2 = frame.set_index(["c", "d"])
frame.set_index(["c", "d"], drop=False)
frame2.reset_index()                     

A.3.3 索引轴更换顺序与排序

Df.swaplevel('key1,key2']
Df.sort_index(level=1)
Df.sawplevel(0,1).sort_index(level=0)

4. 分层计算统计量

使用groupby

frame.groupby(level="key2").sum()
frame.groupby(level="color", axis="columns").sum()

B. 组合与合并数据

1. pd.merge() pd.join()使用键连接数据

将两个Df对象按照某列的对应关系，或者索引之间的对应关系合并成一张表，在关系型数据库中这种操作很常见。在pandas中使用merge或者join函数完成这种合并连接。下面详细介绍pd.merge(）的详细用法。假设待连接的两个数组分别是df1,df2。

B.1.1 根据Df的列（键）合成数据

• pd.merge(df1,df2) 不指定键名，将默认使用重复的列作为键连接两个数组
• pd.merge(df1,df2，on=‘key’) ；on 参数需要是两个数组共有的列名，将以它为键进行合并
• pd.merge(df1,df2,left_on=‘lkey’,right_on=‘rkey’) ；用于两个数组分别以不同的列名作为键合并
• 也可以指定多个列为连接的键pd.merge(left, right, on=[“key1”, “key2”])

#data
df1 = pd.DataFrame({"key": ["b", "b", "a", "c", "a", "a", "b"],
                    "data1": pd.Series(range(7), dtype="Int64")})
df2 = pd.DataFrame({"key": ["a", "b", "d"],
                    "data2": pd.Series(range(3), dtype="Int64")})

#pd.merge
pd.merge(df1, df2)
pd.merge(df1, df2, on="key")

#left_on,right_on
df3 = pd.DataFrame({"lkey": ["b", "b", "a", "c", "a", "a", "b"],
                    "data1": pd.Series(range(7), dtype="Int64")})
df4 = pd.DataFrame({"rkey": ["a", "b", "d"],
                    "data2": pd.Series(range(3), dtype="Int64")})
pd.merge(df3, df4, left_on="lkey", right_on="rkey")                    

#指定多个键，默认将取两个键都对应的在两个数组间的交集
left = pd.DataFrame({"key1": ["foo", "foo", "bar"],
                     "key2": ["one", "two", "one"],
                     "lval": pd.Series([1, 2, 3], dtype='Int64')})
right = pd.DataFrame({"key1": ["foo", "foo", "bar", "bar"],
                      "key2": ["one", "one", "one", "two"],
                      "rval": pd.Series([4, 5, 6, 7], dtype='Int64')})
pd.merge(left, right, on=["key1", "key2"], how="outer")

B.1.2 根据Df的索引列合成数据

某个数组待合并的键并不出现在列中，而是以索引的方式出现在数组中，也可以实现索引与列之间的连接。

• right_index = True 使用右侧数组的索引为键值
• left_index = True 使用左侧数组的索引为键值
• 若一侧指定了多个列为键值，那么另一侧需要有对应的多层索引，也就是A.部分提到的知识。

#data
left1 = pd.DataFrame({"key": ["a", "b", "a", "a", "b", "c"],
                      "value": pd.Series(range(6), dtype="Int64")})
right1 = pd.DataFrame({"group_val": [3.5, 7]}, index=["a", "b"])

#这里左侧使用键，右侧使用索引
pd.merge(left1, right1, left_on="key", right_index=True)

B.1.3 合成的集合选择方式（how参数）

两个合并的数组，键值可能不完全相同，通过how参数可以指定结果使用哪种方式对键值进行选择

• inner 使用两个数组共有的键值作为最终结果，即取交集（默认方式）
• left 使用左侧数组的键值
• right 使用右侧数组的键值
• outer 使用二者相结合的键值，即取并集
  

pd.merge(df1, df2,how='outer')
pd.merge(df1, df2,how='outer')
pd.merge(df1, df2,how='right')

B.1.4 合成时不作为键但列名相同的列（suffixes参数）

当不以重名的列作为键进行合并时，合并后为区分两个列会自动添加一个后缀
也可以使用suffixes参数手动指定添加的后缀 suffixes(‘_left’,‘_right’)

pd.merge(left, right, on="key1", suffixes=("_left", "_right"))

B.1.5 pd.merge参数总结（其他参数）

其他参数如下表，等待读者参考官方文档自行探索。

B.1.6 使用pd.join简化按索引列合并

上述pd.merge()方法在使用索引为键值的情况，参数略微有一些繁琐。而pd.join()方法 可以简化。

• 当df1 和 df2 都以索引作为键进行合并时使用 df1.join(df2) 默认的连接方式为左连接（相当于how=left）
• 当df1使用列 与df2的索引 作为键进行合并时，df1.join(df2,on=‘key’)
• 可以使用join向df1插入多个数组 df1.join([df2,df3]) 默认的连接方式也是左连接

# data
left1 = pd.DataFrame({"key": ["a", "b", "a", "a", "b", "c"],
                      "value": pd.Series(range(6), dtype="Int64")})
right1 = pd.DataFrame({"group_val": [3.5, 7]}, index=["a", "b"])
left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]],
                     index=["a", "c", "e"],
                     columns=["Ohio", "Nevada"]).astype("Int64")
right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13, 14]],
                      index=["b", "c", "d", "e"],
                      columns=["Missouri", "Alabama"]).astype("Int64")
another = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [16., 17.]],
                       index=["a", "c", "e", "f"],
                       columns=["New York", "Oregon"])                      
                      

# df1.join(df2)
left2.join(right2)

# df1.join(df2,how='outer')
left2.join(right2, how="outer")

# df1.join(df,on='key') key是df1的键
left1.join(right1, on="key")

# df1.join([df2,df3]) 
left2.join([right2, another])
left2.join([right2, another], how="outer")

2. pd.concat()按轴方向串联数据

• pd.concat（）会按照指定轴的方向，将数组以及索引都连接起来。
• pd.concat（）第一个参数制定待连接的对象，可以是列表的形式pd.concat([df1,df2’])
• 默认连接方向是向下（沿行），如果需要向右拼接（沿列）需要指定参数 axis=‘columns’
• 默认是取待串联的数组各个索引的并集。如需要取交集，需要指定参数join=‘inner’
• 可以对被拼接的轴增加一层索引，通过keys参数指示来自哪个是数组pd.concat([df1,df2,df3],keys=[‘1’,‘2’,‘3’])
• pd.concat（）第一个参数制定待连接的对象，也可以是字典的形式pd.concat({‘l1’:df1,‘l2’:df2})这里l1 l2 也会给被拼接轴增加一层索引，指示数据来自哪个数组。
• names参数可以对形成的多层索引命名。
• 默认生成的新数组索引时原数组的拼接(沿轴串联保留索引），若想重新生成索引，使用ignore_index=True

# data 三个数组索引没有交集
s1 = pd.Series([0, 1], index=["a", "b"], dtype="Int64")
s2 = pd.Series([2, 3, 4], index=["c", "d", "e"], dtype="Int64")
s3 = pd.Series([5, 6], index=["f", "g"], dtype="Int64")

# 默认横向拼接，默认取并集
pd.concat([s1, s2, s3])

#纵向拼接
pd.concat([s1, s2, s3], axis="columns")

#对于有重复的数据，取并集
s4 = pd.concat([s1, s3])
#取交集
pd.concat([s1, s4], axis="columns", join="inner")

#依据数据来源设置分层索引
result = pd.concat([s1, s1, s3], keys=["one", "two", "three"])

#data 两个Df
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"])

#纵向拼接，按数据来源设置分层索引
pd.concat([df1, df2], axis="columns", keys=["level1", "level2"])
#也可以按字典方式设置分层索引并传入数据
pd.concat({"level1": df1, "level2": df2}, axis="columns")

#默认索引是将原来的拼接在一起但是也可以指定重新排雷索引
df1 = pd.DataFrame(np.random.standard_normal((3, 4)),
                   columns=["a", "b", "c", "d"])
df2 = pd.DataFrame(np.random.standard_normal((2, 3)),
                   columns=["b", "d", "a"])
pd.concat([df1, df2], ignore_index=True)

3. df.combine_first()实现有重复索引的选择性拼接

pd.merge可以实现将重复索引作为键值，连接其他列
pd.concat 可以实现将重复索但值不同会合成不同的行
而df.combine_first()可以实现对于重复色索引，但是值不同，选择其中某个数组的值行层新的列。
a.combine_first(b)实现的功能类似于np.where(pd.sina(a),b,a) ，也就是说当a为空值时，选择b的值填入，当a为非空时选择a的值。
对于Df来说，就是对每一列进行上述操作。

# data
a = pd.Series([np.nan, 2.5, 0.0, 3.5, 4.5, np.nan],
              index=["f", "e", "d", "c", "b", "a"])
b = pd.Series([0., np.nan, 2., np.nan, np.nan, 5.],
              index=["a", "b", "c", "d", "e", "f"])

#以下两个命令类似
np.where(pd.isna(a), b, a)
a.combine_first(b)

#data
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.combine_first(df2)                    

C. 数据透视表

C.1 df.pivot

假设现在数据的解构如下表，item列代表不同的键(可以转换成很多列)，value代表不同的值

现要将其转换为常规Df的新式，即每一列都是一种数据使用Df.pivot(index= ,columns=‘item’,value=)
如下图：

• 达到的效果和把item列移动到列索引类似。
  

C.2 pd.melt

pd.melt 与df.pivot达到的效果相反。
pd.melt(df,id_vars=‘key’)会将Df的各列合并成一列，其中id_vars可以不指定

使用pivot复原