1200字范文 > 数据基础---《利用Python进行数据分析·第2版》第8章数据规整：聚合合并和重塑

数据基础---《利用Python进行数据分析·第2版》第8章数据规整：聚合合并和重塑

时间：2019-11-05 12:49:55

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

在许多应用中，数据可能分散在许多文件或数据库中，存储的形式也不利于分析。本章关注可以聚合、合并、重塑数据的方法。

首先，我会介绍pandas的层次化索引，它广泛用于以上操作。然后，我深入介绍了一些特殊的数据操作。在第14章，你可以看到这些工具的多种应用。

8.1 层次化索引

层次化索引（hierarchical indexing）是pandas的一项重要功能，它使你能在一个轴上拥有多个（两个以上）索引级别。抽象点说，它使你能以低维度形式处理高维度数据。我们先来看一个简单的例子：创建一个Series，并用一个由列表或数组组成的列表作为索引：

import pandas as pdimport numpy as npdata =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.6266052 -0.0996083 1.832826b 1 0.7645713 1.241071c 1 -1.6565782 -0.837847d 2 -1.5639333 1.566208dtype: float64

看到的结果是经过美化的带有MultiIndex索引的Series的格式。索引之间的“间隔”表示“直接使用上面的标签”：

data.index

MultiIndex(levels=[['a', 'b', 'c', 'd'], [1, 2, 3]],labels=[[0, 0, 0, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 2, 0, 1, 1, 2]])

对于一个层次化索引的对象，可以使用所谓的部分索引，使用它选取数据子集的操作更简单：

data['b']

1 0.7645713 1.241071dtype: float64

data['b':'c']

b 1 0.7645713 1.241071c 1 -1.6565782 -0.837847dtype: float64

data.loc[['b','c']]

b 1 0.7645713 1.241071c 1 -1.6565782 -0.837847dtype: float64

有时甚至还可以在“内层”中进行选取：

data.loc[:,2]

a -0.099608c -0.837847d -1.563933dtype: float64

这里是Series,[:,2]中逗号的两边都是表示行索引，前者是外层索引，后者是内层索引

层次化索引在数据重塑和基于分组的操作（如透视表生成）中扮演着重要的角色。例如，可以通过unstack方法将这段数据重新安排到一个DataFrame中：

data.unstack()

unstack的逆运算是stack：

data.unstack().stack()

a 1 -0.6266052 -0.0996083 1.832826b 1 0.7645713 1.241071c 1 -1.6565782 -0.837847d 2 -1.5639333 1.566208dtype: float64

stack和unstack将在本章后面详细讲解。

对于一个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

各层都可以有名字（可以是字符串，也可以是别的Python对象）。如果指定了名称，它们就会显示在控制台输出中：

frame.index.names=['key1','key2']frame.columns.names=['state','color']frame

注意：小心区分索引名state、color与行标签。

有了部分列索引，因此可以轻松选取列分组：

frame['Ohio']

可以单独创建MultiIndex然后复用。上面那个DataFrame中的（带有分级名称）列可以这样创建：

from pandas import MultiIndexMultiIndex.from_arrays([['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']],names=['state','color'])

MultiIndex(levels=[['Colorado', 'Ohio'], ['Green', 'Red']],labels=[[1, 1, 0], [0, 1, 0]],names=['state', 'color'])

重排与分级排序

有时，你需要重新调整某条轴上各级别的顺序，或根据指定级别上的值对数据进行排序。swaplevel接受两个级别编号或名称，并返回一个互换了级别的新对象（但数据不会发生变化）：

frame.swaplevel('key1','key2')

而sort_index则根据单个级别中的值对数据进行排序。交换级别时，常常也会用到sort_index，这样最终结果就是按照指定顺序进行字母排序了：

frame.sort_index(level=1)

frame.swaplevel(0,1).sort_index(level=0)

根据级别汇总统计

许多对DataFrame和Series的描述和汇总统计都有一个level选项，它用于指定在某条轴上求和的级别。再以上面那个DataFrame为例，我们可以根据行或列上的级别来进行求和：level指的是保留的索引，按这个索引来分组

frame.sum()#默认是对各列求和

statecolorOhioGreen 18Red22Colorado Green 26dtype: int64

frame.sum(level='key2')#还是对列求和，只是分了组

frame.sum(level='color',axis=1)

这其实是利用了pandas的groupby功能，本书稍后将对其进行详细讲解。

使用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

DataFrame的set_index函数会将其一个或多个列转换为行索引，并创建一个新的DataFrame：

frame2=frame.set_index(['c','d'])frame2

默认情况下，那些列会从DataFrame中移除，但也可以将其保留下来：

frame.set_index(['c','d'],drop=False)

reset_index的功能跟set_index刚好相反，层次化索引的级别会被转移到列里面：

frame2.reset_index()

8.2 合并数据集

pandas对象中的数据可以通过一些方式进行合并：

pandas.merge可根据一个或多个键将不同DataFrame中的行连接起来。SQL或其他关系型数据库的用户对此应该会比较熟悉，因为它实现的就是数据库的join操作。pandas.concat可以沿着一条轴将多个对象堆叠到一起。实例方法combine_first可以将重复数据拼接在一起，用一个对象中的值填充另一个对象中的缺失值。

我将分别对它们进行讲解，并给出一些例子。本书剩余部分的示例中将经常用到它们。

数据库风格的DataFrame合并

数据集的合并（merge）或连接（join）运算是通过一个或多个键将行连接起来的。这些运算是关系型数据库（基于SQL）的核心。pandas的merge函数是对数据应用这些算法的主要切入点。

以一个简单的例子开始：

df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], 'data1': range(7)})df2 = pd.DataFrame({'key': ['a', 'b', 'd'], 'data2': range(3)})df1

df2

这是一种多对一的合并。df1中的数据有多个被标记为a和b的行，而df2中key列的每个值则仅对应一行。对这些对象调用merge即可得到：

pd.merge(df1,df2)

注意，我并没有指明要用哪个列进行连接。如果没有指定，merge就会将重叠列的列名当做键。不过，最好明确指定一下：

pd.merge(df1,df2,on='key')

如果两个对象的列名不同，也可以分别进行指定：

df3 = pd.DataFrame({'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],'data1': range(7)})df4 = pd.DataFrame({'rkey': ['a', 'b', 'd'],'data2': range(3)})df3

df4

pd.merge(df3,df4,left_on='lkey',right_on='rkey')

可能你已经注意到了，结果里面c和d以及与之相关的数据消失了。默认情况下，merge做的是“内连接”；结果中的键是交集。其他方式还有"left"、“right"以及"outer”。外连接求取的是键的并集，组合了左连接和右连接的效果：

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

表8-1对这些选项进行了总结。

表8-1 不同的连接类型

多对多的合并有些不直观。看下面的例子：

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

df2

pd.merge(df1,df2,on='key',how='left')

多对多连接产生的是行的笛卡尔积。由于左边的DataFrame有3个"b"行，右边的有2个，所以最终结果中就有6个"b"行。连接方式只影响出现在结果中的不同的键的值：

pd.merge(df1,df2,on='key',how='inner')

要根据多个键进行合并，传入一个由列名组成的列表即可：

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

right

pd.merge(left,right,on=['key1','key2'],how='outer')

结果中会出现哪些键组合取决于所选的合并方式，你可以这样来理解：多个键形成一系列元组，并将其当做单个连接键（当然，实际上并不是这么回事）。

注意：在进行列－列连接时，DataFrame对象中的索引会被丢弃。

对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠的问题（查看前面介绍的重命名轴标签），但merge有一个更实用的suffixes选项，用于指定附加到左右两个DataFrame对象的重叠列名上的字符串：

(merge就相当于mysql中不用on用using的join，对于用来连接的列，如果是双方共有，那么会去除冗余列；如果是通过left_on和right_on将名字不同都数据一样的列作为连接列的话，那么两者都会保留；虽然双方还有其他相同名字的字段，但只要没有参与连接，那么就都会保留，只不过默认会加上_x和_y后缀；)

pd.merge(left,right,on='key1')

pd.merge(left,right,on='key1',suffixes=['_left','_right'])

merge的参数请参见表8-2。使用DataFrame的行索引合并是下一节的主题。

表8-2 merge函数的参数

索引上的合并

有时候，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

right1

pd.merge(left1,right1,left_on='key',right_index=True)

由于默认的merge方法是求取连接键的交集，因此你可以通过外连接的方式得到它们的并集：

pd.merge(left1,right1,left_on='key',right_index=True,how='outer')

对于层次化索引的数据，事情就有点复杂了，因为索引的合并默认是多键合并：

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

righth

这种情况下，你必须以列表的形式指明用作合并键的多个列（注意用how='outer’对重复索引值的处理）：

pd.merge(lefth,righth,left_on=['key1','key2'],right_index=True)

pd.merge(lefth,righth,left_on=['key1','key2'],right_index=True,how='outer')

同时使用合并双方的索引也没问题

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

right2

pd.merge(left2,right2,left_index=True,right_index=True,how='outer')

DataFrame还有一个便捷的join实例方法（似乎默认是通过索引来连接的，也可以用on连指明用列来连接，未指明的就用索引），它能更为方便地实现按索引合并。它还可用于合并多个带有相同或相似索引的DataFrame对象，但要求没有重叠的列。在上面那个例子中，我们可以编写：

left2.join(right2,how='outer')

left1.join(right1,on='key')

最后，对于简单的索引合并，你还可以向join传入一组DataFrame，下一节会介绍更为通用的concat函数，也能实现此功能：

another = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [16., 17.]],index=['a', 'c', 'e', 'f'],columns=['New York', 'Oregon'])another

left2.join([right2,another])

left2.join([right2, another], how='outer')

c:\users\qingt\miniconda2\envs\python35\lib\site-packages\pandas\core\frame.py:6369: FutureWarning: Sorting because non-concatenation axis is not aligned. A future versionof pandas will change to not sort by default.To accept the future behavior, pass 'sort=False'.To retain the current behavior and silence the warning, pass 'sort=True'.verify_integrity=True)

轴向连接

另一种数据合并运算也被称作连接（concatenation）、绑定（binding）或堆叠（stacking）。NumPy的concatenation函数可以用NumPy数组来做：

arr=np.arange(12).reshape(4,3)arr

array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])

np.concatenate([arr,arr],axis=1)

array([[ 0, 1, 2, 0, 1, 2],[ 3, 4, 5, 3, 4, 5],[ 6, 7, 8, 6, 7, 8],[ 9, 10, 11, 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'])pd.concat([s1,s2,s3])

a 0b 1c 2d 3e 4f 5g 6dtype: int64

默认情况下，concat是在axis=0上工作的，最终产生一个新的Series。如果传入axis=1，则结果就会变成一个DataFrame（axis=1是列）：

pd.concat([s1,s2,s3],axis=1)

c:\users\qingt\miniconda2\envs\python35\lib\site-packages\ipykernel_launcher.py:1: FutureWarning: Sorting because non-concatenation axis is not aligned. A future versionof pandas will change to not sort by default.To accept the future behavior, pass 'sort=False'.To retain the current behavior and silence the warning, pass 'sort=True'."""Entry point for launching an IPython kernel.

这种情况下，另外的轴上没有重叠，从索引的有序并集（外连接）上就可以看出来。merge默认的是内连接，concat默认的是外连接

传入join='inner’即可得到它们的交集：

s4=pd.concat([s1,s3])s4

a 0b 1f 5g 6dtype: int64

pd.concat([s1,s4],axis=1)

pd.concat([s1,s4],axis=1,join='inner')

在这个例子中，f和g标签消失了，是因为使用的是join='inner’选项。

你可以通过join_axes指定要在其它轴上使用的索引：

pd.concat([s1,s4],axis=1,join_axes=[['a', 'c', 'b', 'e']])#相当于在对Series和DataFrame操作索引时指定索引一样，就会以索引为准

不过有个问题，参与连接的片段在结果中区分不开。假设你想要在连接轴上创建一个层次化索引。使用keys参数即可达到这个目的：

result = pd.concat([s1,s1,s3],keys=['one','two','three'])#两层索引，one对应s1result

one a 0b 1two a 0b 1three f 5g 6dtype: int64

result.unstack()

如果沿着axis=1对Series进行合并，则keys就会成为DataFrame的列头：

pd.concat([s1,s2,s3],axis=1,keys=['one','two', 'three'])

同样的逻辑也适用于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

df2

pd.concat([df1,df2],axis=1,keys=['level1', 'level2'])

如果传入的不是列表而是一个字典，则字典的键就会被当做keys选项的值：

pd.concat({'level1':df1,'level2':df2},axis=1)

此外还有两个用于管理层次化索引创建方式的参数（参见表8-3）。举个例子，我们可以用names参数命名创建的轴级别：

pd.concat([df1,df2],axis=1,keys=['upper', 'lower'],names=['upper', 'lower'])

最后一个关于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

df2

在这种情况下，传入ignore_index=True即可：

pd.concat([df1,df2])

pd.concat([df1,df2],ignore_index=True)

表8-3 concat函数的参数

合并重叠数据

还有一种数据组合问题不能用简单的合并（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: float64

b

f 0.0e 1.0d 2.0c 3.0b 4.0a NaNdtype: float64

np.where(pd.isnull(a),b,a)

array([0. , 2.5, 2. , 3.5, 4.5, nan])

Series有一个combine_first方法，实现的也是一样的功能，还带有pandas的数据对齐：

bine_first(a)

f 0.0e 1.0d 2.0c 3.0b 4.0a NaNdtype: float64

bine_first(b)

f 0.0e 2.5d 2.0c 3.5b 4.5a NaNdtype: float64

b[:-2].combine_first(a[2:])

a NaNb 4.5c 3.0d 2.0e 1.0f 0.0dtype: float64

通过对比，可以看到combine_first实现的就是如果前面这个Series中对应元素存在则有前面这个，否则用后面这个。

对于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

df2

bine_first(df2)

8.3 重塑和轴向旋转

有许多用于重新排列表格型数据的基础运算。这些函数也称作重塑（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

对该数据使用stack方法即可将列转换为行，得到一个Series：

result = data.stack()result

statenumberOhioone 0two 1three2Colorado one 3two 4three5dtype: int32

对于一个层次化索引的Series，你可以用unstack将其重排为一个DataFrame：

result.unstack()

默认情况下，unstack操作的是最内层（stack也是如此）。传入分层级别的编号或名称即可对其它级别进行unstack操作：

result.unstack(0)

result.unstack('state')

如果不是所有的级别值都能在各分组中找到的话，则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 0b 1c 2d 3two c 4d 5e 6dtype: int64

data2.unstack()

stack默认会滤除缺失数据，因此该运算是可逆的：

data2.unstack().stack()

one a 0.0b 1.0c 2.0d 3.0two c 4.0d 5.0e 6.0dtype: float64

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

one a 0.0b 1.0c 2.0d 3.0e NaNtwo a NaNb NaNc 4.0d 5.0e 6.0dtype: float64

在对DataFrame进行unstack操作时，作为旋转轴的级别将会成为结果中的最低级别：

df = pd.DataFrame({'left': result, 'right': result + 5},columns=pd.Index(['left', 'right'], name='side'))#用两个双层索引的Series混合得到的DataFramedf

df.unstack()

当调用stack，我们可以指明轴的名字：

df.unstack('state').stack('side')

将“长格式”旋转为“宽格式”

data = pd.read_csv('examples/macrodata.csv')data.head()

periods = pd.PeriodIndex(year=data.year, quarter=data.quarter,name='date')periods

PeriodIndex(['1959Q1', '1959Q2', '1959Q3', '1959Q4', '1960Q1', '1960Q2','1960Q3', '1960Q4', '1961Q1', '1961Q2',...'Q2', 'Q3', 'Q4', 'Q1', 'Q2', 'Q3','Q4', 'Q1', 'Q2', 'Q3'],dtype='period[Q-DEC]', name='date', length=203, freq='Q-DEC')

columns=pd.Index(['realgdp', 'infl', 'unemp'],name='item')columns

Index(['realgdp', 'infl', 'unemp'], dtype='object', name='item')

data=data.reindex(columns=columns)data.head()

data.index=periods.to_timestamp('D', 'end')data.head()

data.stack()[:5]

date item 1959-03-31 realgdp 2710.349infl0.000unemp 5.8001959-06-30 realgdp 2778.801infl2.340dtype: float64

data.stack().reset_index().head()

data.stack().reset_index().rename(columns={0: 'value'}).head()

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.head()

前两个传递的值分别用作行和列索引，最后一个可选值则是用于填充DataFrame的数据列。假设有两个需要同时重塑的数据列：

ldata['value2'] = np.random.randn(len(ldata))ldata[:10]

如果忽略最后一个参数，得到的DataFrame就会带有层次化的列：

pivoted = ldata.pivot('date', 'item')pivoted[:5]

pivoted['value'][:5]

注意，pivot其实就是用set_index创建层次化索引，再用unstack重塑：

unstacked = ldata.set_index(['date', 'item']).unstack('item')unstacked[:7]

将“宽格式”旋转为“长格式”

旋转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

key列可能是分组指标，其它的列是数据值。当使用pandas.melt，我们必须指明哪些列是分组指标。下面使用key作为唯一的分组指标：

melted=pd.melt(df,['key'])#第二个参数分组指标就相当于要保留不参与融化的列melted

使用pivot，可以重塑回原来的样子：

reshaped = melted.pivot('key', 'variable', 'value')reshaped

因为pivot的结果从列创建了一个索引，用作行标签，我们可以使用reset_index将数据移回列：

reshaped.reset_index()

你还可以指定列的子集，作为值的列：

pd.melt(df, id_vars=['key'], value_vars=['A', 'B'])

pandas.melt也可以不用分组指标：

pd.melt(df, value_vars=['A', 'B', 'C'])

pd.melt(df, value_vars=['key', 'A', 'B'])#这个可以看到melt也是非常灵活的

pandas的DataFrame怎么把几列数据合并成为新的一列

parent_teacher_data['address'] = parent_teacher_data['country']+parent_teacher_data['province']+parent_teacher_data['city']+parent_teacher_data['county']

如果某一列是非str类型的数据，那么我们需要用到map(str)将那一列数据类型做转换：

dataframe["newColumn"] = dataframe["age"].map(str) + dataframe["phone"] + dataframe["address”]