【学习】数据规整化：清理、转换、合并、重塑【pandas】
这一部分非常关键！
数据分析和建模方面的大量编程工作都是用在数据准备上的：加载、清理、转换以及重塑。
1、合并数据集
- pandas对象中的数据可以通过 一些内置的方式进行合并：
- pandas.merge可根据一个或多个健将不同DataFrame中的行连接起来。实现的就是数据库的连接操作
- pandas.concat可以沿着一条轴将多个对象堆叠到一起
- 实例方法combine_first可以将重复数据编接在一起，用一个对象中的值填充另一个对象中的缺失值（通俗来说，差不多就是数据库的全外连接，简单地说，就是先从第一个对象中选值，不行就再去第二个对象中选值）
@数据库风格的DataFrame合并
数据集的合并（merge）或连接（join）运算是通过一个或多个键将行链接起来的。这些运算是关系型数据库的核心。pandas的merge函数是对数据应用这些算法的主要切入点。
import pandas as pd
df1 = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'], 'data1': range(7)})
Out[15]:
data1 key
0 0 b
1 1 b
2 2 a
3 3 c
4 4 a
5 5 a
6 6 b
df2 = pd.DataFrame({'key': ['a', 'b', 'd'], 'data2': range(3)})
Out[16]:
data2 key
0 0 a
1 1 b
2 2 d
df1
df2
#这是一种多对一的合并，df1中的数据有多个被标记为a和b的行，而df2中key列的每个值则仅对应一行
pd.merge(df1, df2)
Out[17]:
data1 key data2
0 0 b 1
1 1 b 1
2 6 b 1
3 2 a 0
4 4 a 0
5 5 a 0
注意，这里并没有指明用哪个列进行连接。如果没有指定，merge就会将重叠列的列名当作 键，不过，最好显示指定一下
#注意，这里并没有指明用哪个列进行连接。如果没有指定，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)})
pd.merge(df3, df4, left_on = 'lkey', right_on = 'rkey') Out[20]:
data1 lkey data2 rkey
0 0 b 1 b
1 1 b 1 b
2 6 b 1 b
3 2 a 0 a
4 4 a 0 a
5 5 a 0 a
但注意到，结果里面c和d以及与之相关的数据都消失了，默认情况下，merge做的是inner连接；结果中的键是交集。
其他方式还有left 、right以及outer。外连接求取的是键的并集，组合了左连接和右连接的效果
pd.merge(df1, df2, how = 'outer')
Out[21]:
data1 key data2
0 0.0 b 1.0
1 1.0 b 1.0
2 6.0 b 1.0
3 2.0 a 0.0
4 4.0 a 0.0
5 5.0 a 0.0
6 3.0 c NaN
7 NaN d 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
df2
pd.merge(df1, df2, on = 'key', how = 'left')
Out[26]:
data1 key data2
0 0 b 1.0
1 0 b 3.0
2 1 b 1.0
3 1 b 3.0
4 2 a 0.0
5 2 a 2.0
6 3 c NaN
7 4 a 0.0
8 4 a 2.0
9 5 b 1.0
10 5 b 3.0
#多对多连接产生的是行的笛卡尔积。由于左边的DataFrame有3个b行，右边有2个，所以最终结果中就有6个b行，连接方式只影响出现在结果中键
pd.merge(df1, df2, on = 'key', how = 'left')
#多对多连接产生的是行的笛卡尔积。由于左边的DataFrame有3个b行，右边有2个，所以最终结果中就有6个b行，连接方式只影响出现在结果中键
pd.merge(df1, df2, how = 'inner')
pd.merge(df1, df2, on = 'key', how = 'left')
Out[26]:
data1 key data2
0 0 b 1.0
1 0 b 3.0
2 1 b 1.0
3 1 b 3.0
4 2 a 0.0
5 2 a 2.0
6 3 c NaN
7 4 a 0.0
8 4 a 2.0
9 5 b 1.0
10 5 b 3.0 pd.merge(df1, df2, how = 'inner')
Out[27]:
data1 key data2
0 0 b 1
1 0 b 3
2 1 b 1
3 1 b 3
4 5 b 1
5 5 b 3
6 2 a 0
7 2 a 2
8 4 a 0
9 4 a 2
要根据多个键进行合并，传入一个由列名组成的列表即可
left = pd.DataFrame({'key1': ['foo', 'foo', 'bar'],
'key2': ['one', 'two', 'one'],
'lva1': [1, 2, 3]})
right = pd.DataFrame({'key1': ['foo', 'foo', 'bar', 'bar'],
'key2': ['one', 'one', 'one', 'two'],
'rva1': [4, 5, 6, 7]})
pd.merge(left, right, on = ['key1', 'key2'], how = 'outer')
Out[32]:
key1 key2 lva1 rva1
0 foo one 1.0 4.0
1 foo one 1.0 5.0
2 foo two 2.0 NaN
3 bar one 3.0 6.0
4 bar two NaN 7.0
结果中会出现哪些键组合取决于所选的合并方式，可以这样理解：多个键组成一系列元组，并将其当作单个连接键
警告：在进行列-列连接时，DataFrame对象中的索引会被丢弃
left
Out[33]:
key1 key2 lva1
0 foo one 1
1 foo two 2
2 bar one 3 right
Out[34]:
key1 key2 rva1
0 foo one 4
1 foo one 5
2 bar one 6
3 bar two 7
#对于合并运算需要考虑的最后一个问题是对重复列名的处理。虽然你可以手工处理列名重叠的问题，但merge有一个更实用的suffixes选项，用于指定
#附加到左右两个DataFrame对象的重叠列名上的字符串
pd.merge(left, right, on = 'key1')
Out[35]:
key1 key2_x lva1 key2_y rva1
0 foo one 1 one 4
1 foo one 1 one 5
2 foo two 2 one 4
3 foo two 2 one 5
4 bar one 3 one 6
5 bar one 3 two 7
pd.merge(left, right, on = 'key1', suffixes = ('_left', '_right'))
Out[36]:
key1 key2_left lva1 key2_right rva1
0 foo one 1 one 4
1 foo one 1 one 5
2 foo two 2 one 4
3 foo two 2 one 5
4 bar one 3 one 6
5 bar one 3 two 7
merge函数有参数
标注：sort 根据连接键对合并后的数据进行排序，默认为True, 有时在处理大数据集时，禁用该选项可获得更好的性能
suffixes 字符串元组，用于追加到重叠列名的末尾，默认为（’_x‘, '_y'）.
copy 设置为False, 可以在某些特殊情况下避免将数据复制到结果数据结构中，默认总是复制
@索引上的合并
有时候，连接键位于索引中，在这种情况下，你可以传入left_index = True 或 right_index= True（或者两个都传）以说明索引应用被用作连接键
left1 = pd.DataFrame({'key': ['a', 'b', 'a', 'a', 'b', 'c'], 'value': range(6)})
left1
Out[37]:
key value
0 a 0
1 b 1
2 a 2
3 a 3
4 b 4
5 c 5
right1 = pd.DataFrame({'group_val': [3.5, 7]}, index = ['a', 'b'])
right1
Out[40]:
group_val
a 3.5
b 7.0
pd.merge(left1, right1, left_on = 'key', right_index = True)
Out[41]:
key value group_val
0 a 0 3.5
2 a 2 3.5
3 a 3 3.5
1 b 1 7.0
4 b 4 7.0
由于默认的merge方法是求取连接键的交集，因此可以通过外连接的方式得到它们的并集
pd.merge(left1, right1, left_on = 'key', right_index = True, how = 'outer')
Out[42]:
key value group_val
0 a 0 3.5
2 a 2 3.5
3 a 3 3.5
1 b 1 7.0
4 b 4 7.0
5 c 5 NaN
对于层次化索引的数据
import numpy as np
lefth = pd.DataFrame({'key1': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
'key2': [2000, 2001, 2002, 2001, 2002],
'lva1': np.arange(5)})
lefth Out[46]:
key1 key2 lva1
0 Ohio 2000 0
1 Ohio 2001 1
2 Ohio 2002 2
3 Nevada 2001 3
4 Nevada 2002 4
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'])
righth Out[51]:
event1 event2
Nevada 2001 0 1
2000 2 3
Ohio 2000 4 5
2000 6 7
2001 8 9
2002 10 11
这种情况下，你必须以列表的形式指明用作合并键的多个列（注意对重复索引值的处理）
pd.merge(lefth, righth, left_on = ['key1', 'key2'], right_index = True)
Out[52]:
key1 key2 lva1 event1 event2
0 Ohio 2000 0 4 5
0 Ohio 2000 0 6 7
1 Ohio 2001 1 8 9
2 Ohio 2002 2 10 11
3 Nevada 2001 3 0 1
pd.merge(lefth, righth, left_on = ['key1', 'key2'], right_index = True, how = 'outer')
Out[53]:
key1 key2 lva1 event1 event2
0 Ohio 2000 0.0 4.0 5.0
0 Ohio 2000 0.0 6.0 7.0
1 Ohio 2001 1.0 8.0 9.0
2 Ohio 2002 2.0 10.0 11.0
3 Nevada 2001 3.0 0.0 1.0
4 Nevada 2002 4.0 NaN NaN
4 Nevada 2000 NaN 2.0 3.0
同时使用合并双方的索引也没问题
left2 = pd.DataFrame([[1., 2.], [3., 4.], [5., 6.]], index = ['a', 'c', 'e'], columns = ['Ohio', 'Nevada']) left2
Out[55]:
Ohio Nevada
a 1.0 2.0
c 3.0 4.0
e 5.0 6.0 right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13., 14.]], index = ['b', 'c', 'd', 'e'], columns = ['Missouri', 'Alabama']) right2
Out[57]:
Missouri Alabama
b 7.0 8.0
c 9.0 10.0
d 11.0 12.0
e 13.0 14.0 pd.merge(left2, right2, how = 'outer', left_index = True, right_index = True)
Out[58]:
Ohio Nevada Missouri Alabama
a 1.0 2.0 NaN NaN
b NaN NaN 7.0 8.0
c 3.0 4.0 9.0 10.0
d NaN NaN 11.0 12.0
e 5.0 6.0 13.0 14.0
DataFrame还有一个join实例方法，它能更为方便地实现按索引合并。它还还可用于合并多个带有相同或相似索引的DataFrame对象，而不管它们之间有没有重叠的列
left2.join(right2, how = 'outer')
Out[59]:
Ohio Nevada Missouri Alabama
a 1.0 2.0 NaN NaN
b NaN NaN 7.0 8.0
c 3.0 4.0 9.0 10.0
d NaN NaN 11.0 12.0
e 5.0 6.0 13.0 14.0
#支持参数DataFrame的索引跟调用者DataFrame的某个列之间的连接
left1.join(right1, on = 'key')
Out[60]:
key value group_val
0 a 0 3.5
1 b 1 7.0
2 a 2 3.5
3 a 3 3.5
4 b 4 7.0
5 c 5 NaN
对于简单的索引合并，还可以向join传入一组DataFrame
another = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [16., 17.]],
index = ['a', 'c', 'e', 'f'],
columns = ['New York', 'Oregon'])
left2
Out[66]:
Ohio Nevada
a 1.0 2.0
c 3.0 4.0
e 5.0 6.0 another
Out[63]:
New York Oregon
a 7.0 8.0
c 9.0 10.0
e 11.0 12.0
f 16.0 17.0 right2
Out[64]:
Missouri Alabama
b 7.0 8.0
c 9.0 10.0
d 11.0 12.0
e 13.0 14.0 left2.join([right2, another]) Out[65]: In [66]:
Ohio Nevada Missouri Alabama New York Oregon
a 1.0 2.0 NaN NaN 7.0 8.0
c 3.0 4.0 9.0 10.0 9.0 10.0
e 5.0 6.0 13.0 14.0 11.0 12.0
left2.join([right2, another], how = 'outer')
Out[67]:
Ohio Nevada Missouri Alabama New York Oregon
a 1.0 2.0 NaN NaN 7.0 8.0
b NaN NaN 7.0 8.0 NaN NaN
c 3.0 4.0 9.0 10.0 9.0 10.0
d NaN NaN 11.0 12.0 NaN NaN
e 5.0 6.0 13.0 14.0 11.0 12.0
f NaN NaN NaN NaN 16.0 17.0
@轴向连接
另一种数据合并运算也被称作连接、绑定或堆叠。numpy有一个用于合并原始numpy数组的concatenation函数
arr = np.arange(12).reshape((3, 4)) arr
Out[69]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]) np.concatenate([arr, arr], axis = 1)
Out[70]:
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, 带有标签的轴使你能够进一步推广数组的连接运算。具体点说，你还需要考虑以下这些东西
- 如果各对象其他轴上的索引不同，那些轴应该是做并集还是交集
- 结果对象中的分组需要各不相同吗
- 用于连接的轴重要吗
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']) s1
Out[74]:
a 0
b 1
dtype: int64 s2
Out[75]:
c 2
d 3
e 4
dtype: int64 s3
Out[76]:
f 5
g 6
dtype: int64 pd.concat([s1, s2, s3])
Out[77]:
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)
Out[78]:
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 * 5, s3])
s4
Out[99]:
a 0
b 5
f 5
g 6
dtype: int64 pd.concat([s1, s4], axis = 1)
Out[100]:
0 1
a 0.0 0
b 1.0 5
f NaN 5
g NaN 6 pd.concat([s1, s4], axis = 1, join = 'inner')
Out[101]:
0 1
a 0 0
b 1 5
#你可以通过join_axes指定要在其他 轴上使用的索引
pd.concat([s1, s4], axis = 1, join_axes = [['a', 'c', 'b', 'e']])
Out[102]:
0 1
a 0.0 0.0
c NaN NaN
b 1.0 5.0
e NaN NaN
#如果你想要在连接轴上创建一个层次化索引。使用keys参数 即可达到这个目的
result = pd.concat([s1, s2, s3], keys = ['one', 'two', 'three'])
result Out[103]:
one a 0
b 1
two c 2
d 3
e 4
three f 5
g 6
dtype: int64 result.unstack()
Out[104]:
a b c d e f g
one 0.0 1.0 NaN NaN NaN NaN NaN
two NaN NaN 2.0 3.0 4.0 NaN NaN
three NaN NaN NaN NaN NaN 5.0 6.0
#如果沿着axis = 1 对Series进行合并，则keys就会成为DataFrame的列头
pd.concat([s1, s2, s3], axis = 1, keys = ['one', 'two', 'three'])
Out[105]:
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'])
pd.concat([df1, df2], axis = 1, keys = ['level1', 'level2']) Out[106]:
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) Out[107]:
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
#此外还有两个管理层次化索引创建方式的参数
pd.concat([df1, df2], axis = 1, keys = ['level1', 'level2'], names = ['upper', 'lower'])
Out[108]:
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行索引
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
Out[110]:
a b c d
0 0.003212 -0.342055 -0.152235 -1.848477
1 -0.357666 -1.667613 -0.499012 0.559769
2 -1.025485 0.770518 -0.203711 -0.513205 df2
Out[111]:
b d a
0 0.573107 -0.259251 0.087934
1 1.070468 1.113611 -1.062122
#在这种情况下，传入ignore_index = True 即可
pd.concat([df1, df2], ignore_index = True) Out[112]:
a b c d
0 0.003212 -0.342055 -0.152235 -1.848477
1 -0.357666 -1.667613 -0.499012 0.559769
2 -1.025485 0.770518 -0.203711 -0.513205
3 0.087934 0.573107 NaN -0.259251
4 -1.062122 1.070468 NaN 1.113611
concat函数的参数
【学习】数据规整化：清理、转换、合并、重塑【pandas】的更多相关文章
- Python之数据规整化：清理、转换、合并、重塑
Python之数据规整化:清理.转换.合并.重塑 1. 合并数据集 pandas.merge可根据一个或者多个不同DataFrame中的行连接起来. pandas.concat可以沿着一条轴将多个对象 ...
- 《python for data analysis》第七章，数据规整化
<利用Python进行数据分析>第七章的代码. # -*- coding:utf-8 -*-# <python for data analysis>第七章, 数据规整化 imp ...
- 【学习】数据规整化：清理、转换、合并、重塑（续）【pandas】
@合并重叠数据 还有一种数据组合问题不能用简单的合并或连接运算来处理.比如说,你可能有索引全部或部分重叠的两个数据集 使用numpy的where函数,它用于表达一种矢量化的if - else a = ...
- 利用Python进行数据分析——数据规整化：清理、转换、合并、重塑(七)(1)
数据分析和建模方面的大量编程工作都是用在数据准备上的:载入.清理.转换以及重塑.有时候,存放在文件或数据库中的数据并不能满足你的数据处理应用的要求.很多人都选择使用通用编程语言(如Python.Per ...
- pandas（七）数据规整化：清理、转换、合并、重塑之合并数据集
pandas对象中的数据可以通过一些内置的方式进行合并: pandas.merge 可根据一个或多个键将不同的DataFrame中的行连接起来. pandas.concat可以沿着一条轴将多个对象堆叠 ...
- Python 数据分析（一） 本实验将学习 pandas 基础，数据加载、存储与文件格式，数据规整化，绘图和可视化的知识
第1节 pandas 回顾 第2节 读写文本格式的数据 第3节 使用 HTML 和 Web API 第4节 使用数据库 第5节 合并数据集 第6节 重塑和轴向旋转 第7节 数据转换 第8节 字符串操作 ...
- 利用Python进行数据分析-Pandas(第五部分-数据规整：聚合、合并和重塑)
在许多应用中,数据可能分散在许多文件或数据库中,存储的形式也不利于分析.本部分关注可以聚合.合并.重塑数据的方法. 1.层次化索引 层次化索引(hierarchical indexing)是panda ...
- 利用Python进行数据分析 第8章 数据规整：聚合、合并和重塑.md
学习时间:2019/11/03 周日晚上23点半开始,计划1110学完 学习目标:Page218-249,共32页:目标6天学完(按每页20min.每天1小时/每天3页,需10天) 实际反馈:实际XX ...
- 利用python进行数据分析之数据规整化
数据分析和建模大部分时间都用在数据准备上,数据的准备过程包括:加载,清理,转换与重塑. 合并数据集 pandas对象中的数据可以通过一些内置方法来进行合并: pandas.merge可根据一个或多个键 ...
随机推荐
- UGUI之用ScrollRect做下拉刷新
在ScrollView下有中层次是scorllview->viewport->content scorllView对象下的ScrollRect组件是关键 ,scorllRect中指定其对 ...
- JavaWeb（二）
三.搭建JavaWeb应用开发环境——Tomcat服务器 3.1.疑问:学习web开发,为什么必须要先装一个WEB服务器? 在本地计算机上随便创建一个web页面,用户是无法访问到的,但是如果启动tom ...
- linux设置自启动redis
vi /etc/init.d/redis # chkconfig: 2345 10 90 # description: Start and Stop redis PATH=/usr/local/bin ...
- 报文 HTTP HTTPS
报文是网络中交换与传输的数据单元,即站点一次性要发送的数据块.报文包含了将要发送的完整的数据信息,其长短很不一致,长度不限且可变. 报文也是网络传输的单位,传输过程中会不断的封装成分组.包.帧来传输, ...
- the status bar issue of react-native Modal on Android ( RN v0.57.0)
Problem: When use Modal in react-native, the status bar is not included if you make a full-screen ma ...
- Assembly Experiment9
用英文写太浪费时间了,而且书上的讲解对各种功能的英文原句少之又少,有空还是看龙书吧(不存在的) 实验1: 十六进制转换十进制 实验代码: ; 在屏幕上输出内存单元中的十进制两位数 assume cs: ...
- PythonStudy——迭代器 iterator
# 迭代器对象: 可以不用依赖索引取值的容器# 可迭代对象:可以通过某种方法得到迭代器对象 # 迭代器优点:可以不用依赖索引取值# 迭代器缺点:只能从前往后依次取值 可迭代对象 # 可迭代对象:有__ ...
- 编写一个简单的基于jmespath 的prometheus exporter
目的很简单,因为系统好多监控指标是通过json 暴露的,并不是标准的prometheus metrics 格式,处理方法 实际上很简单,我们可以基于jsonpath 解析json数据,转换为prome ...
- python如何输出文件的年月日
import time print('{}BiasedMF312and4414_rt.txt'.format(time.strftime("%Y-%m-%d"))) 输出: 201 ...
- mvc项目远程发布到windows server服务器
1.安装IIS的时候需要将这两个选项勾选起来 2.确保 管理服务委派 这个选项存在 3.添加委派规则 4.配置IIS管理用户,后续需要用这个用户进行发布连接 5.配置站点的IIS权限 选择刚才在前面设 ...