pandas数据变换(一)

92 阅读 0 评论 61 点赞

我是靠谱客的博主感动蜻蜓，这篇文章主要介绍pandas数据变换(一)，现在分享给大家，希望可以做个参考。

1.删除重复值

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import numpy as np
import pandas as pd
data=pd.DataFrame({'k1':['one','two']*3+['two'],'k2':[1,1,2,3,3,4,4]})
print(data)
#输出:
k1
k2
0
one
1
1
two
1
2
one
2
3
two
3
4
one
3
5
two
4
6
two
4

DataFrame的duplicated()方法会返回一个布尔类型的Series,默认判断每行是否重复,根据的是前一行来判断是否重复

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
print(data.duplicated())
#输出:
0
False
1
False
2
False
3
False
4
False
5
False
6
True
dtype: bool
#DataFrame的drop_duplicates()会删除重复的部分，返回一个新的DataFrame，这里重复的部分表明是row index 为6的行
#记住这里其实不是上面那个duplicated，它是将duplicated中的d 改为了s
print(data.drop_duplicates())
#输出:
k1
k2
0
one
1
1
two
1
2
one
2
3
two
3
4
one
3
5
two
4

上面的方法都有一个弊端就是考虑到了所有的列，可以指定一部分的数据来检测重复值.

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
data['v1']=range(7) #range()为python自带的生成数字的函数
print(data)
print(data.drop_duplicates(['k1'])) #这里指定删除‘k1’列中的所有重复值，因为默认删除的是行,所以保留的是k1中没有重复值的行
#输出:
k1
k2
v1
0
one
1
0
1
two
1
1
2
one
2
2
3
two
3
3
4
one
3
4
5
two
4
5
6
two
4
6
k1
k2
v1
0
one
1
0
1
two
1
1

duplicated()和drop_duplicates(）默认是保留第一次观测到的数据的组合，意思就是如果下一行是重复的和第一次观测到的重复的。那么就去掉下一行的数据，而duplicated()就会在下一行观测到的重复数据标记为True。而传入参数keep=‘last’就会保留最后一行。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
print(data.duplicated(['k1','k2'],keep='last'))
print(data.drop_duplicates(['k1','k2'],keep='last'))
#输出:
0
False
1
False
2
False
3
False
4
False
5
True
6
False
dtype: bool
k1
k2
v1
0
one
1
0
1
two
1
1
2
one
2
2
3
two
3
3
4
one
3
4
6
two
4
6

2.用函数和映射来转换数据

当我们希望可以做一些数据转换，例子不同种类的肉

这里介绍一下map()函数，map()函数就是一个数据到一个数据的映射关系，中间没有对数据的增删改

map(function,list),map函数就是将list里面的数据取出来然后用于function

复制代码

#例子，比如不同种类的肉
data = pd.DataFrame({'food': ['bacon', 'pulled pork', 'bacon',
'Pastrami', 'corned beef', 'Bacon',
'pastrami', 'honey ham', 'nova lox'],
'ounces': [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})
print(data)
#输出:
food
ounces
0
bacon
4.0
1
pulled pork
3.0
2
bacon
12.0
3
Pastrami
6.0
4
corned beef
7.5
5
Bacon
8.0
6
pastrami
3.0
7
honey ham
5.0
8
nova lox
6.0
#当我们想在data中加一列来表明每种肉的来源的时候
meat_to_animal = {
'bacon': 'pig',
'pulled pork': 'pig',
'pastrami': 'cow',
'corned beef': 'cow',
'honey ham': 'pig',
'nova lox': 'salmon'
}
#Series的map()方法可以接受一个函数 或则一个字典，meat_to_animal就是一个字典类型的数据,但是这里有一个小问题data数据中
#肉名称有大写，和字典里的映射关系肉名称不对应，所以我们使用str.lower()函数，将data里面的food数据全部变为小写
lowercased=data['food'].str.lower()
#这里记住用的.str.lower()，因为Series没有lower()，lower（)是用于字符串数据的
print(lowercased)
#输出:
0
bacon
1
pulled pork
2
bacon
3
pastrami
4
corned beef
5
bacon
6
pastrami
7
honey ham
8
nova lox
#然后将含有映射关系的字典 meat_to_animal 传入到lowercased的map()中
print(lowercased.map(meat_to_animal)) #这里就是将meat_to_animal去匹配lowercased的数据，然后返回meat_to_animal中的value
data['animal']=lowercased.map(meat_to_animal)
print(data)
#输出:
0
pig
1
pig
2
pig
3
cow
4
cow
5
pig
6
cow
7
pig
8
salmon
Name: food, dtype: object
food
ounces
animal
0
bacon
4.0
pig
1
pulled pork
3.0
pig
2
bacon
12.0
pig
3
Pastrami
6.0
cow
4
corned beef
7.5
cow
5
Bacon
8.0
pig
6
pastrami
3.0
cow
7
honey ham
5.0
pig
8
nova lox
6.0
salmon
#可以使用函数来解决上述的问题
print(data['food'].map(lambda x : meat_to_animal[x.lower()]))
#这里得lambda是一个匿名函数，x 作为参数入口，而meat_to_animal[x.lower()]作为函数体.这里的输入得参数是data['food']
#这里可以使用.lower(）是因为参数不是以Series传入，而是以一个个字符串传入,所以去返回字典型数据meat_to_animal每个对应Key的value
#输出:
0
pig
1
pig
2
pig
3
cow
4
cow
5
pig
6
cow
7
pig
8
salmon

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
#例子，比如不同种类的肉
data = pd.DataFrame({'food': ['bacon', 'pulled pork', 'bacon',
'Pastrami', 'corned beef', 'Bacon',
'pastrami', 'honey ham', 'nova lox'],
'ounces': [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})
print(data)
#输出:
food
ounces
0
bacon
4.0
1
pulled pork
3.0
2
bacon
12.0
3
Pastrami
6.0
4
corned beef
7.5
5
Bacon
8.0
6
pastrami
3.0
7
honey ham
5.0
8
nova lox
6.0
#当我们想在data中加一列来表明每种肉的来源的时候
meat_to_animal = {
'bacon': 'pig',
'pulled pork': 'pig',
'pastrami': 'cow',
'corned beef': 'cow',
'honey ham': 'pig',
'nova lox': 'salmon'
}
#Series的map()方法可以接受一个函数 或则一个字典，meat_to_animal就是一个字典类型的数据,但是这里有一个小问题data数据中
#肉名称有大写，和字典里的映射关系肉名称不对应，所以我们使用str.lower()函数，将data里面的food数据全部变为小写
lowercased=data['food'].str.lower()
#这里记住用的.str.lower()，因为Series没有lower()，lower（)是用于字符串数据的
print(lowercased)
#输出:
0
bacon
1
pulled pork
2
bacon
3
pastrami
4
corned beef
5
bacon
6
pastrami
7
honey ham
8
nova lox
#然后将含有映射关系的字典 meat_to_animal 传入到lowercased的map()中
print(lowercased.map(meat_to_animal)) #这里就是将meat_to_animal去匹配lowercased的数据，然后返回meat_to_animal中的value
data['animal']=lowercased.map(meat_to_animal)
print(data)
#输出:
0
pig
1
pig
2
pig
3
cow
4
cow
5
pig
6
cow
7
pig
8
salmon
Name: food, dtype: object
food
ounces
animal
0
bacon
4.0
pig
1
pulled pork
3.0
pig
2
bacon
12.0
pig
3
Pastrami
6.0
cow
4
corned beef
7.5
cow
5
Bacon
8.0
pig
6
pastrami
3.0
cow
7
honey ham
5.0
pig
8
nova lox
6.0
salmon
#可以使用函数来解决上述的问题
print(data['food'].map(lambda x : meat_to_animal[x.lower()]))
#这里得lambda是一个匿名函数，x 作为参数入口，而meat_to_animal[x.lower()]作为函数体.这里的输入得参数是data['food']
#这里可以使用.lower(）是因为参数不是以Series传入，而是以一个个字符串传入,所以去返回字典型数据meat_to_animal每个对应Key的value
#输出:
0
pig
1
pig
2
pig
3
cow
4
cow
5
pig
6
cow
7
pig
8
salmon

3.替换值

fillna是一个特殊的替换操作,map可以修改一个对象(object)里的部分值,但是这里学习的replace可以提供一个更简单更灵活的操作

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
from numpy import nan as NA
data=pd.Series([1.,-999,-2.0,-999,1000,3.])
print(data)
data1=data.replace(-999,NA)
print(data1)
#输出:
0
1.0
1
-999.0
2
-2.0
3
-999.0
4
1000.0
5
3.0
这里的-999可能是用来表示缺失值，所以我们可以使用repalce（）来将-999替换掉，
它会返回一个新的Series,这里来将新的Series赋值给data1。
如果我们给replace（）传入inplace=True的话就可以直接改变data,不用返回一个新的Series
dtype: float64
0
1.0
1
NaN
2
-2.0
3
NaN
4
1000.0
5
3.0
dtype: float64
#如果想要一次替换掉多个值，就用一个list存入这些值，然后作为参数传给replace()函数
print(data.replace([-999,1000],NA))
#输出:
0
1.0
1
NaN
2
-2.0
3
NaN
4
NaN
5
3.0
#对于不同的值用不同的值替换，那么也可以用一个list存入，然后传入
print(data.replace([-999,1000],[NA,101]))
#输出:
0
1.0
1
NaN
2
-2.0
3
NaN
4
101.0
5
3.0
dtype: float64
#其实上面那种使用两个列表也麻烦了，我们可以直接传入一个字典，利用对应的关系
print(data.replace({-999:NA,1000:101}))
#输出:
0
1.0
1
NaN
2
-2.0
3
NaN
4
101.0
5
3.0
dtype: float64

4.重命名Axis Indexes

像Series里的value一样，axis label(索引标记)也可以使用函数或映射来改变，产生一个新的对象,如果不产生一个新的对象，直接更改数据，那么一样传入inplace

复制代码

data = pd.DataFrame(np.arange(12).reshape((3, 4)),
index=['Ohio', 'Colorado', 'New York'],
columns=['one', 'two', 'three', 'four'])
print(data)
#与Series相同，axis index也有一个map方法
transfrom=lambda x : x[:4].upper()
print(transfrom)
print(data.index) #data数据的索引,index代表DataFrame的行索引，columns代表DataFrame的列索引，
#输出:
one
two
three
four
Ohio
0
1
2
3
Colorado
4
5
6
7
New York
8
9
10
11
<function <lambda> at 0x0822DA50>
Index(['Ohio', 'Colorado', 'New York'], dtype='object')
print(data.index.map(transfrom)) #这个就是使用map的功能了，然后将函数传给map,将data.index 转变为大写,这里的X参数入口就是为data.index
#输出:
Index(['OHIO', 'COLO', 'NEW '], dtype='object')
data.index=data.index.map(transfrom)
#更改data.index
print(data)
#输出:
one
two
three
four
OHIO
0
1
2
3
COLO
4
5
6
7
NEW
8
9
10
11
#如果想改变索引的大小写，那么可以使用rename，它而且不会改变原始的数据
print(data.rename(index=str.title,columns=str.upper)) #str.upper 将索引字符串变为大写
print(data.rename(index=str.upper,columns=str.title)) #str.title 不改变索引的大小写
print(data)
#输出：
ONE
TWO
THREE
FOUR
Ohio
0
1
2
3
Colorado
4
5
6
7
New York
8
9
10
11
One
Two
Three
Four
OHIO
0
1
2
3
COLORADO
4
5
6
7
NEW YORK
8
9
10
11
one
two
three
four
Ohio
0
1
2
3
Colorado
4
5
6
7
New York
8
9
10
11
#可以给data传入字典的object
print(data.rename(index={'OHIO': 'INDIANA'},
columns={'three': 'pekaboo'}))
#输出:
one
two
pekaboo
four
Ohio
0
1
2
3
Colorado
4
5
6
7
New York
8
9
10
11

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
data = pd.DataFrame(np.arange(12).reshape((3, 4)),
index=['Ohio', 'Colorado', 'New York'],
columns=['one', 'two', 'three', 'four'])
print(data)
#与Series相同，axis index也有一个map方法
transfrom=lambda x : x[:4].upper()
print(transfrom)
print(data.index) #data数据的索引,index代表DataFrame的行索引，columns代表DataFrame的列索引，
#输出:
one
two
three
four
Ohio
0
1
2
3
Colorado
4
5
6
7
New York
8
9
10
11
<function <lambda> at 0x0822DA50>
Index(['Ohio', 'Colorado', 'New York'], dtype='object')
print(data.index.map(transfrom)) #这个就是使用map的功能了，然后将函数传给map,将data.index 转变为大写,这里的X参数入口就是为data.index
#输出:
Index(['OHIO', 'COLO', 'NEW '], dtype='object')
data.index=data.index.map(transfrom)
#更改data.index
print(data)
#输出:
one
two
three
four
OHIO
0
1
2
3
COLO
4
5
6
7
NEW
8
9
10
11
#如果想改变索引的大小写，那么可以使用rename，它而且不会改变原始的数据
print(data.rename(index=str.title,columns=str.upper)) #str.upper 将索引字符串变为大写
print(data.rename(index=str.upper,columns=str.title)) #str.title 不改变索引的大小写
print(data)
#输出：
ONE
TWO
THREE
FOUR
Ohio
0
1
2
3
Colorado
4
5
6
7
New York
8
9
10
11
One
Two
Three
Four
OHIO
0
1
2
3
COLORADO
4
5
6
7
NEW YORK
8
9
10
11
one
two
three
four
Ohio
0
1
2
3
Colorado
4
5
6
7
New York
8
9
10
11
#可以给data传入字典的object
print(data.rename(index={'OHIO': 'INDIANA'},
columns={'three': 'pekaboo'}))
#输出:
one
two
pekaboo
four
Ohio
0
1
2
3
Colorado
4
5
6
7
New York
8
9
10
11

rename()方法可以让我们自己手动去将整个数据都重新写一下，它可以修改你想修改你想修改任何一个索引名称，我们可以在rename加入inplace=True来直接修改数据

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
print(data)
data.rename(index={'Ohio':'hard'},inplace=True)
print(data)
#输出:
one
two
three
four
Ohio
0
1
2
3
Colorado
4
5
6
7
New York
8
9
10
11
one
two
three
four
hard
0
1
2
3
Colorado
4
5
6
7
New York
8
9
10
11