编程实践（Pandas）Task05

最新推荐文章于 2023-01-20 12:38:10 发布

Daisy Lee

最新推荐文章于 2023-01-20 12:38:10 发布

阅读量370

点赞数

分类专栏： datawhale 文章标签： pandas python

本文链接：https://blog.csdn.net/weixin_42871941/article/details/111826548

版权

datawhale 专栏收录该内容

29 篇文章 2 订阅

订阅专栏

一、长宽表的变形

什么是长表？什么是宽表？这个概念是对于某一个特征而言的。

pd.DataFrame({'Gender': ['F','F','M','M'],
             'Height':[163, 160, 175, 180]})

	Gender	Height
0	F	163
1	F	160
2	M	175
3	M	180

pd.DataFrame({'Height: F':[163, 160],
              'Height: M':[175, 180]})

	Height: F	Height: M
0	163			175
1	160			180

1. pivot

pivot 是一种典型的长表变宽表的函数

df = pd.DataFrame({'Class':[1,1,2,2],
                   'Name':['San Zhang','San Zhang','Si Li','Si Li'],
                   'Subject':['Chinese','Math','Chinese','Math'],
                   'Grade':[80,75,90,85]})

df

	Class	Name		Subject	Grade
0	1		San Zhang	Chinese	80
1	1		San Zhang	Math	75
2	2		Si Li		Chinese	90
3	2		Si Li		Math	85

# 现在想要把语文和数学分数作为列来展示
df.pivot(index = 'Name', columns = 'Subject', values = 'Grade')

Subject		Chinese	Math
Name		
San Zhang	80		75
Si Li		90		85

对于一个基本的长变宽的操作而言，最重要的有三个要素，分别是变形后的行索引、需要转到列索引的列，以及这些列和行索引对应的数值，它们分别对应了 pivot 方法中的 index, columns, values 参数。新生成表的列索引是 columns 对应列的 unique 值，而新表的行索引是 index 对应列的 unique 值，而 values 对应了想要展示的数值列。

利用 pivot 进行变形操作需要满足唯一性的要求，即由于在新表中的行列索引对应了唯一的 value ，因此原表中的 index 和 columns 对应两个列的行组合必须唯一。

df.loc[1, 'Subject'] = 'Chinese'
df

	Class	Name		Subject	Grade
0	1		San Zhang	Chinese	80
1	1		San Zhang	Chinese	75
2	2		Si Li		Chinese	90
3	2		Si Li		Math	85

df.pivot(index='Name', columns='Subject', values='Grade')
>>> ValueError: Index contains duplicate entries, cannot reshape

pandas 从 1.1.0 开始， pivot 相关的三个参数允许被设置为列表，这也意味着会返回多级索引。

df = pd.DataFrame({'Class':[1, 1, 2, 2, 1, 1, 2, 2],
                   'Name':['San Zhang', 'San Zhang', 'Si Li', 'Si Li', 'San Zhang', 'San Zhang', 'Si Li', 'Si Li'],
                   'Examination': ['Mid', 'Final', 'Mid', 'Final', 'Mid', 'Final', 'Mid', 'Final'],
                   'Subject':['Chinese', 'Chinese', 'Chinese', 'Chinese', 'Math', 'Math', 'Math', 'Math'],
                   'Grade':[80, 75, 85, 65, 90, 85, 92, 88],
                   'rank':[10, 15, 21, 15, 20, 7, 6, 2]})

df

	Class	Name		Examination	Subject	Grade	rank
0	1		San Zhang	Mid			Chinese	80		10
1	1		San Zhang	Final		Chinese	75		15
2	2		Si Li		Mid			Chinese	85		21
3	2		Si Li		Final		Chinese	65		15
4	1		San Zhang	Mid			Math	90		20
5	1		San Zhang	Final		Math	85		7
6	2		Si Li		Mid			Math	92		6
7	2		Si Li		Final		Math	88		2

# 现在想要把测试类型和科目联合组成的四个类别（期中语文、期末语文、期中数学、期末数学）转到列索引，并且同时统计成绩和排名
pivot_multi = df.pivot(index = ['Class', 'Name'],
                      columns = ['Subject', 'Examination'],
                      values = ['Grade', 'rank'])

pivot_multi

					Grade					rank
		Subject		Chinese		Math		Chinese		Math
		Examination	Mid	Final	Mid	Final	Mid	Final	Mid	Final
Class	Name								
1		San Zhang	80	75		90	85		10	15		20	7
2		Si Li		85	65		92	88		21	15		6	2

根据唯一性原则，新表的行索引等价于对 index 中的多列使用 drop_duplicates ，而列索引的长度为 values 中的元素个数乘以 columns 的唯一组合数量（与 index 类似）。

2. pivot_table

pivot 的使用依赖于唯一性条件，那如果不满足唯一性条件，那么必须通过聚合操作使得相同行列组合对应的多个值变为一个值。

df = pd.DataFrame({'Name':['San Zhang', 'San Zhang', 'San Zhang', 'San Zhang', 'Si Li', 'Si Li', 'Si Li', 'Si Li'],
                   'Subject':['Chinese', 'Chinese', 'Math', 'Math', 'Chinese', 'Chinese', 'Math', 'Math'],
                   'Grade':[80, 90, 100, 90, 70, 80, 85, 95]})

df

	Name		Subject	Grade
0	San Zhang	Chinese	80
1	San Zhang	Chinese	90
2	San Zhang	Math	100
3	San Zhang	Math	90
4	Si Li		Chinese	70
5	Si Li		Chinese	80
6	Si Li		Math	85
7	Si Li		Math	95

pandas 中提供了pivot_table 来实现，其中的 aggfunc参数就是使用的聚合函数。

df.pivot_table(index = 'Name',
              columns = 'Subject',
              values = 'Grade',
              aggfunc = 'mean')

Subject		Chinese	Math
Name		
San Zhang	85		95
Si Li		75		90

这里传入 aggfunc 包含了上一章中介绍的所有合法聚合字符串，此外还可以传入以序列为输入标量为输出的聚合函数来实现自定义操作。

df.pivot_table(index = 'Name',
              columns = 'Subject',
              values = 'Grade',
              aggfunc = lambda x: x.mean())

Subject		Chinese	Math
Name		
San Zhang	85		95
Si Li		75		90

此外， pivot_table 具有边际汇总的功能，可以通过设置 margins=True 来实现，其中边际的聚合方式与 aggfunc 中给出的聚合方法一致。

df.pivot_table(index = 'Name',
              columns = 'Subject',
              values = 'Grade',
              aggfunc = 'mean',
              margins = True)

Subject		Chinese	Math	All
Name			
San Zhang	85		95.0	90.00
Si Li		75		90.0	82.50
All			80		92.5	86.25

3. melt

melt 函数是一种典型的宽表变长表的函数，参数为pandas.melt(frame, id_vars=None, value_vars=None, var_name=None, value_name='value', col_level=None)

参数解释：

frame:要处理的数据集。
id_vars:不需要被转换的列名。
value_vars:需要转换的列名，如果剩下的列全部都要转换，就不用写了。
var_name和value_name是自定义设置对应的列名。
col_level :如果列是MultiIndex，则使用此级别。

df = pd.DataFrame({'Class':[1,2],
                   'Name':['San Zhang', 'Si Li'],
                   'Chinese':[80, 90],
                   'Math':[80, 75]})

df

	Class	Name		Chinese	Math
0	1		San Zhang	80		80
1	2		Si Li		90		75

df_melted = df.melt(id_vars = ['Class', 'Name'],
                   value_vars = ['Chinese', 'Math'],
                   var_name = 'Subject',
                   value_name = 'Grade')

df_melted

	Class	Name		Subject	Grade
0	1		San Zhang	Chinese	80
1	2		Si Li		Chinese	90
2	1		San Zhang	Math	80
3	2		Si Li		Math	75

前面提到了 melt 和 pivot 是一组互逆过程，那么就一定可以通过 pivot 操作把 df_melted 转回 df 的形式

df_unmelted = df_melted.pivot(index = ['Class', 'Name'],
                              columns='Subject',
                              values='Grade')

df_unmelted

	Subject			Chinese	Math
Class	Name		
1		San Zhang	80		80
2		Si Li		90		75

# 恢复索引，并且重命名列索引名称
df_unmelted = df_unmelted.reset_index().rename_axis(columns={'Subject':''})

df_unmelted

	Class	Name		Chinese	Math
0	1		San Zhang	80		80
1	2		Si Li		90		75

4. wide_to_long

melt方法中，在列索引中被压缩的一组值对应的列元素只能代表同一层次的含义，即values_name 。现在如果列中包含了交叉类别，比如期中期末的类别和语文数学的类别，那么想要把 values_name 对应的 Grade 扩充为两列分别对应语文分数和数学分数，只把期中期末的信息压缩，这种需求下就要使用 wide_to_long 函数来完成。

df = pd.DataFrame({'Class':[1,2],
                   'Name':['San Zhang', 'Si Li'],
                   'Chinese_Mid':[80, 75],
                   'Math_Mid':[90, 85],
                   'Chinese_Final':[80, 75],
                   'Math_Final':[90, 85]})

df

	Class	Name		Chinese_Mid	Math_Mid	Chinese_Final	Math_Final
0	1		San Zhang	80			90			80				90
1	2		Si Li		75			85			75				85

pd.wide_to_long(df,stubnames, i, j, sep, suffix)

参数解释：

stubnames：提取以指定字符串开头的列
i：用作索引的列
j：提取开头后剩余的部分会成一列，在此指定列名
sep：分隔符
suffix：捕获正则表达式匹配的后缀

pd.wide_to_long(df,
               stubnames = ['Chinese', 'Math'],
               i = ['Class', 'Name'],
               j = 'Examination',
               sep = '_',
               suffix = '.+')

								Chinese	Math
Class	Name		Examination		
1		San Zhang	Mid			80		90
					Final		80		90
2		Si Li		Mid			75		85
					Final		75		85

把之前在 pivot 一节中多列操作的结果（产生了多级索引），利用 wide_to_long 函数，将其转为原来的形态。

res = pivot_multi.copy()
res

					Grade					rank
		Subject		Chinese		Math		Chinese		Math
		Examination	Mid	Final	Mid	Final	Mid	Final	Mid	Final
Class	Name								
1		San Zhang	80	75		90	85		10	15		20	7
2		Si Li		85	65		92	88		21	15		6	2

res.columns = res.columns.map(lambda x:'_'.join(x))
res.columns
>>> Index(['Grade_Chinese_Mid', 'Grade_Chinese_Final', 'Grade_Math_Mid',
           'Grade_Math_Final', 'rank_Chinese_Mid', 'rank_Chinese_Final',
           'rank_Math_Mid', 'rank_Math_Final'],
          dtype='object')

res = res.reset_index()
res

	Class	Name		Grade_Chinese_Mid	Grade_Chinese_Final	Grade_Math_Mid	Grade_Math_Final	rank_Chinese_Mid	rank_Chinese_Final	rank_Math_Mid	rank_Math_Final
0	1		San Zhang	80					75					90				85					10					15					20				7
1	2		Si Li		85					65					92				88					21					15					6				2

res = pd.wide_to_long(res, stubnames=['Grade', 'rank'],
                      i = ['Class', 'Name'],
                      j = 'Subject_Examination',
                      sep = '_',
                      suffix = '.+')
res

										Grade	rank
Class	Name		Subject_Examination		
1		San Zhang	Chinese_Mid			80		10
					Chinese_Final		75		15
					Math_Mid			90		20
					Math_Final			85		7
2		Si Li		Chinese_Mid			85		21
					Chinese_Final		65		15
					Math_Mid			92		6
					Math_Final			88		2

res = res.reset_index()
res

	Class	Name		Subject_Examination	Grade	rank
0	1		San Zhang	Chinese_Mid			80		10
1	1		San Zhang	Chinese_Final		75		15
2	1		San Zhang	Math_Mid			90		20
3	1		San Zhang	Math_Final			85		7
4	2		Si Li		Chinese_Mid			85		21
5	2		Si Li		Chinese_Final		65		15
6	2		Si Li		Math_Mid			92		6
7	2		Si Li		Math_Final			88		2

res[['Subject', 'Examination']] = res['Subject_Examination'].str.split('_', expand=True)
res = res[['Class', 'Name', 'Examination', 'Subject', 'Grade', 'rank']].sort_values('Subject')
res

	Class	Name		Examination	Subject	Grade	rank
0	1		San Zhang	Mid			Chinese	80		10
1	1		San Zhang	Final		Chinese	75		15
4	2		Si Li		Mid			Chinese	85		21
5	2		Si Li		Final		Chinese	65		15
2	1		San Zhang	Mid			Math	90		20
3	1		San Zhang	Final		Math	85		7
6	2		Si Li		Mid			Math	92		6
7	2		Si Li		Final		Math	88		2

res = res.reset_index(drop=True)
res

	Class	Name		Examination	Subject	Grade	rank
0	1		San Zhang	Mid			Chinese	80		10
1	1		San Zhang	Final		Chinese	75		15
2	2		Si Li		Mid			Chinese	85		21
3	2		Si Li		Final		Chinese	65		15
4	1		San Zhang	Mid			Math	90		20
5	1		San Zhang	Final		Math	85		7
6	2		Si Li		Mid			Math	92		6
7	2		Si Li		Final		Math	88		2

二、索引的变形

1. stack与unstack

在第二章中提到了利用 swaplevel 或者 reorder_levels 进行索引内部的层交换，下面就要讨论行列索引之间的交换，由于这种交换带来了 DataFrame 维度上的变化，因此属于变形操作。

unstack 函数的作用是把行索引转为列索引

df = pd.DataFrame(np.ones((4,2)),
                  index = pd.Index([('A', 'cat', 'big'), ('A', 'dog', 'small'), ('B', 'cat', 'big'), ('B', 'dog', 'small')]),
                  columns=['col_1', 'col_2'])

df

				col_1	col_2
A	cat	big		1.0		1.0
	dog	small	1.0		1.0
B	cat	big		1.0		1.0
	dog	small	1.0		1.0

df.unstack()

		col_1		col_2
		big	small	big	small
A	cat	1.0	NaN		1.0	NaN
	dog	NaN	1.0		NaN	1.0
B	cat	1.0	NaN		1.0	NaN
	dog	NaN	1.0		NaN	1.0

unstack 的主要参数是移动的层号，默认转化最内层，移动到列索引的最内层，同时支持同时转化多个层：

df.unstack(2)

		col_1		col_2
		big	small	big	small
A	cat	1.0	NaN		1.0	NaN
	dog	NaN	1.0		NaN	1.0
B	cat	1.0	NaN		1.0	NaN
	dog	NaN	1.0		NaN	1.0

df.unstack([0,2])

	col_1					col_2
	A			B			A			B
	big	small	big	small	big	small	big	small
cat	1.0	NaN		1.0	NaN		1.0	NaN		1.0	NaN
dog	NaN	1.0		NaN	1.0		NaN	1.0		NaN	1.0

df.unstack([1,2])

	col_1		col_2
	cat	dog		cat	dog
	big	small	big	small
A	1.0	1.0		1.0	1.0
B	1.0	1.0		1.0	1.0

类似于 pivot 中的唯一性要求，在 unstack 中必须保证 被转为列索引的行索引层 和 被保留的行索引层 构成的组合是唯一的。

my_index = df.index.to_list()
my_index

[('A', 'cat', 'big'),
 ('A', 'dog', 'small'),
 ('B', 'cat', 'big'),
 ('B', 'dog', 'small')]

my_index[1] = my_index[0]
df.index = pd.Index(my_index)
df

				col_1	col_2
A	cat	big		1.0		1.0
		big		1.0		1.0
B	cat	big		1.0		1.0
	dog	small	1.0		1.0

df.unstack()
>>> ValueError: Index contains duplicate entries, cannot reshape

与 unstack 相反， stack 的作用就是把列索引的层压入行索引，其用法完全类似。

df = pd.DataFrame(np.ones((4,2)),
                  index = pd.Index([('A', 'cat', 'big'), ('A', 'dog', 'small'), ('B', 'cat', 'big'), ('B', 'dog', 'small')]),
                  columns=['index_1', 'index_2']).T

df

		A			B
		cat	dog		cat	dog
		big	small	big	small
index_1	1.0	1.0		1.0	1.0
index_2	1.0	1.0		1.0	1.0

df.stack()

				A		B
				cat	dog	cat	dog
index_1	big		1.0	NaN	1.0	NaN
		small	NaN	1.0	NaN	1.0
index_2	big		1.0	NaN	1.0	NaN
		small	NaN	1.0	NaN	1.0

df.stack([1, 2])

					A	B
index_1	cat	big		1.0	1.0
		dog	small	1.0	1.0
index_2	cat	big		1.0	1.0
		dog	small	1.0	1.0

2. 聚合与变形的关系

在上面介绍的所有函数中，除了带有聚合效果的 pivot_table 以外，所有的函数在变形前后并不会带来 values 个数的改变，只是这些值在呈现的形式上发生了变化。聚合之后把原来的多个值变为了一个值，因此 values 的个数产生了变化，这也是分组聚合与变形函数的最大区别（value个数的改变）。

三、其他变形函数

1. crosstab

crosstab 并不是一个值得推荐使用的函数，因为它能实现的所有功能 pivot_table 都能完成，并且速度更快。在默认状态下， crosstab 可以统计元素组合出现的频数，即 count 操作。

pd.crosstab(index = df.School, columns = df.Transfer)

Transfer						N	Y
School		
Fudan University				38	1
Peking University				28	2
Shanghai Jiao Tong University	53	0
Tsinghua University				62	4

pd.crosstab(index = df.School,
           columns = df.Transfer,
           values = [0]*df.shape[0],
           aggfunc = 'count')

Transfer						N		Y
School		
Fudan University				38.0	1.0
Peking University				28.0	2.0
Shanghai Jiao Tong University	53.0	NaN
Tsinghua University				62.0	4.0

# 可以利用 pivot_table 进行等价操作
df.pivot_table(index = 'School',
              columns = 'Transfer',
              values = 'Name',
              aggfunc = 'count')

Transfer						N		Y
School		
Fudan University				38.0	1.0
Peking University				28.0	2.0
Shanghai Jiao Tong University	53.0	NaN
Tsinghua University				62.0	4.0

从上面可以看出这两个函数的区别在于， crosstab 的对应位置传入的是具体的序列，而 pivot_table 传入的是被调用表对应的名字，若传入序列对应的值则会报错。

除了默认状态下的 count 统计，所有的聚合字符串和返回标量的自定义函数都是可用的。

pd.crosstab(index = df.School, 
            columns = df.Transfer,
            values = df.Height, 
            aggfunc = 'mean')

Transfer						N			Y
School		
Fudan University				162.043750	177.20
Peking University				163.429630	162.40
Shanghai Jiao Tong University	163.953846	NaN
Tsinghua University				163.253571	164.55

2. explode

explode 参数能够对某一列的元素进行纵向的展开，被展开的单元格必须存储 list, tuple, Series, np.ndarray 中的一种类型。

df_ex = pd.DataFrame({'A': [[1, 2], 'my_str', {1, 2}, pd.Series([3, 4])],
                      'B': 1})

df_ex

	A						B
0	[1, 2]					1
1	my_str					1
2	{1, 2}					1
3	0 3 1 4 dtype: int64	1

df_ex.explode('A')

	A		B
0	1		1
0	2		1
1	my_str	1
2	{1, 2}	1
3	3		1
3	4		1

3. get_dummies

get_dummies 是用于特征构建的重要函数之一，其作用是把类别特征转为指示变量。

pd.get_dummies(df.Grade).head()

	Freshman	Junior	Senior	Sophomore
0	1			0		0		0
1	1			0		0		0
2	0			0		1		0
3	0			0		0		1
4	0			0		0		1

四、练一练

练一练1

在上面的边际汇总例子中，行或列的汇总为新表中行元素或者列元素的平均值，而总体的汇总为新表中四个元素的平均值。这种关系一定成立吗？若不成立，请给出一个例子来说明。

不成立，行列汇总后的平均数是总成绩/总科目数，与新表中的汇总数无关，比如张三新加一行语文成绩，行汇总的平均数为(80+90+70+100+90)/5=86，但是不等于行元素的平均值：(80+95)/2=87.5

df = pd.DataFrame({'Name':['San Zhang', 'San Zhang', 'San Zhang', 'San Zhang', 'San Zhang', 'Si Li', 'Si Li', 'Si Li', 'Si Li'],
                   'Subject':['Chinese', 'Chinese', 'Chinese', 'Math', 'Math', 'Chinese', 'Chinese', 'Math', 'Math'],
                   'Grade':[80, 90, 70, 100, 90, 70, 80, 85, 95]})

df

	Name		Subject	Grade
0	San Zhang	Chinese	80
1	San Zhang	Chinese	90
2	San Zhang	Chinese	70
3	San Zhang	Math	100
4	San Zhang	Math	90
5	Si Li		Chinese	70
6	Si Li		Chinese	80
7	Si Li		Math	85
8	Si Li		Math	95

df.pivot_table(index = 'Name',
               columns = 'Subject',
               values = 'Grade',
               aggfunc='mean',
               margins=True)

Subject		Chinese	Math	All
Name			
San Zhang	80		95.0	86.000000
Si Li		75		90.0	82.500000
All			78		92.5	84.444444

练一练2

前面提到了 crosstab 的性能劣于 pivot_table ，请选用多个聚合方法进行验证。

运行上面两段代码，crosstab运行时间为26ms，同样形式pivot_table运行时间为16ms。

%time pd.crosstab(index = df.School, columns = df.Transfer, values = [0]*df.shape[0], aggfunc = 'count')

Wall time: 26 ms
Transfer						N		Y
School		
Fudan University				38.0	1.0
Peking University				28.0	2.0
Shanghai Jiao Tong University	53.0	NaN
Tsinghua University				62.0	4.0

%time df.pivot_table(index = 'School', columns = 'Transfer', values = 'Name', aggfunc = 'count')

Wall time: 16 ms
Transfer						N		Y
School		
Fudan University				38.0	1.0
Peking University				28.0	2.0
Shanghai Jiao Tong University	53.0	NaN
Tsinghua University				62.0	4.0

五、课后练习

Ex1：美国非法药物数据集

现有一份关于美国非法药物的数据集，其中 SubstanceName, DrugReports 分别指药物名称和报告数量：

将数据转为如下的形式：

df_pivot = df.pivot_table(index = ['State', 'COUNTY', 'SubstanceName'],
              columns = 'YYYY',
              values = 'DrugReports',
              aggfunc = 'sum')
res = df_pivot.reset_index().rename_axis(columns={'YYYY' : ''})
res.head()

	State	COUNTY	SubstanceName	2010	2011	2012	2013	2014	2015	2016	2017
0	KY		ADAIR	Buprenorphine	NaN		3.0		5.0		4.0		27.0	5.0		7.0		10.0
1	KY		ADAIR	Codeine			NaN		NaN		1.0		NaN		NaN		NaN		NaN		1.0
2	KY		ADAIR	Fentanyl		NaN		NaN		1.0		NaN		NaN		NaN		NaN		NaN
3	KY		ADAIR	Heroin			NaN		NaN		1.0		2.0		NaN		1.0		NaN		2.0
4	KY		ADAIR	Hydrocodone		6.0		9.0		10.0	10.0	9.0		7.0		11.0	3.0

将第1问中的结果恢复为原表。

res2 = res.copy()
df2 = res2.melt(id_vars = ['State', 'COUNTY', 'SubstanceName'],
               var_name = 'YYYY',
               value_name = 'DrugReports')
df3 = df2.dropna(subset = ['DrugReports'])
df3.head()

	State	COUNTY	SubstanceName	YYYY	DrugReports
4	KY		ADAIR	Hydrocodone		2010	6.0
6	KY		ADAIR	Methadone		2010	1.0
13	KY		ALLEN	Hydrocodone		2010	10.0
15	KY		ALLEN	Methadone		2010	4.0
17	KY		ALLEN	Oxycodone		2010	15.0

df_new = df3.sort_values(['State','COUNTY','SubstanceName'],ignore_index=True)
df_new.head()

	State	COUNTY	SubstanceName	YYYY	DrugReports
0	KY		ADAIR	Buprenorphine	2011	3.0
1	KY		ADAIR	Buprenorphine	2012	5.0
2	KY		ADAIR	Buprenorphine	2013	4.0
3	KY		ADAIR	Buprenorphine	2014	27.0
4	KY		ADAIR	Buprenorphine	2015	5.0

按 State 分别统计每年的报告数量总和，其中 State, YYYY 分别为列索引和行索引，要求分别使用 pivot_table 函数与 groupby+unstack 两种不同的策略实现，并体会它们之间的联系。

df_pt = df.pivot_table(index='YYYY', 
                       columns='State', 
                       values='DrugReports', 
                       aggfunc='sum')
df_pt

State	KY		OH		PA		VA		WV
YYYY					
2010	10453	19707	19814	8685	2890
2011	10289	20330	19987	6749	3271
2012	10722	23145	19959	7831	3376
2013	11148	26846	20409	11675	4046
2014	11081	30860	24904	9037	3280
2015	9865	37127	25651	8810	2571
2016	9093	42470	26164	10195	2548
2017	9394	46104	27894	10448	1614

df_gb = df.groupby(['YYYY', 'State'])['DrugReports'].sum().unstack()
df_gb

State	KY		OH		PA		VA		WV
YYYY					
2010	10453	19707	19814	8685	2890
2011	10289	20330	19987	6749	3271
2012	10722	23145	19959	7831	3376
2013	11148	26846	20409	11675	4046
2014	11081	30860	24904	9037	3280
2015	9865	37127	25651	8810	2571
2016	9093	42470	26164	10195	2548
2017	9394	46104	27894	10448	1614

Ex2：特殊的wide_to_long方法

从功能上看， melt 方法应当属于 wide_to_long 的一种特殊情况，即 stubnames 只有一类。请使用
wide_to_long 生成 melt 一节中的 df_melted 。（提示：对列名增加适当的前缀）

df_melted = df.melt(id_vars = ['Class', 'Name'],
                    value_vars = ['Chinese', 'Math'],
                    var_name = 'Subject',
                    value_name = 'Grade')
df_melted

	Class	Name		Subject	Grade
0	1		San Zhang	Chinese	80
1	2		Si Li		Chinese	90
2	1		San Zhang	Math	80
3	2		Si Li		Math	75

df = df.rename(columns={'Chinese':'ex_Chinese','Math':'ex_Math'})
df_wl = pd.wide_to_long(df,
                stubnames='ex',
                i = ['Class', 'Name'],
                j = 'Subject',
                sep='_',
                suffix='.+')
df_wide = df_wl.reset_index().rename(columns = {'ex':'Grade'})
df_wide

	Class	Name		Subject	Grade
0	1		San Zhang	Chinese	80
1	1		San Zhang	Math	80
2	2		Si Li		Chinese	90
3	2		Si Li		Math	75

参考文档

https://blog.csdn.net/maymay_/article/details/80039677
https://datawhalechina.github.io/joyful-pandas/build/html/%E7%9B%AE%E5%BD%95/ch5.html

Daisy Lee

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
编程实践（Pandas）Task05

一、长宽表的变形什么是长表？什么是宽表？这个概念是对于某一个特征而言的。pd.DataFrame({'Gender': ['F','F','M','M'], 'Height':[163, 160, 175, 180]}) Gender Height0 F 1631 F 1602 M 1753 M 180pd.DataFrame({'Height: F':[163, 160], 'Height: M':[175, 180]}) He
复制链接

扫一扫