数据分析之pandas教程------数据处理

时间：2018-02-14 00:15:35 阅读：244 评论：0 收藏：0 [点我收藏+]

标签：2.2.3 inter only 运用个数 int range null 数据转换

当我们有多张表的时候, 经常会遇到的一个问题就是, 如何把这些表关联起来, 我们可以想想我们在数据库的时候,
进场会遇到表连接的问题, 比如join, union等等, 其实这里等同于是在pandas里实现了这些
功能. 首先, 我们来看看这个join在pandas里是怎么实现的.

我们在pandas里主要通过merge来实现数据库的join工作.

from pandas import Series, DataFrame
import pandas as pd
import numpy as np

sep = "---------------------------------------------------------------------"

data1 = {"data1": [1, 2, 3, 4, 5], "key":[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]}
data2 = {"data2": [1, 2, 3,100], "key":[‘a‘, ‘b‘, ‘c‘, ‘f‘]}

frame1 = DataFrame(data1)
frame2 = DataFrame(data2)

print(frame1)

print(sep)

print(frame2)

print(sep)

print(pd.merge(frame1, frame2, on="key"))

   data1 key
0      1   a
1      2   b
2      3   c
3      4   d
4      5   e
---------------------------------------------------------------------
   data2 key
0      1   a
1      2   b
2      3   c
3    100   f
---------------------------------------------------------------------
   data1 key  data2
0      1   a      1
1      2   b      2
2      3   c      3

注意, 我们默认是inner方式的连接, 对于数据库怎么做连接的, 以及连接的种类, 留作作业.

作业1: 熟悉数据库连接的方式.

# 左外连
print(pd.merge(frame1, frame2, on="key", how=‘left‘))

   data1 key  data2
0      1   a    1.0
1      2   b    2.0
2      3   c    3.0
3      4   d    NaN
4      5   e    NaN

# 右外连
print(pd.merge(frame1, frame2, on="key", how=‘right‘))

   data1 key  data2
0    1.0   a      1
1    2.0   b      2
2    3.0   c      3
3    NaN   f    100

# 外连接
print(pd.merge(frame1, frame2, on="key", how=‘outer‘))

   data1 key  data2
0    1.0   a    1.0
1    2.0   b    2.0
2    3.0   c    3.0
3    4.0   d    NaN
4    5.0   e    NaN
5    NaN   f  100.0

我们看到, 这和我们数据库的是一模一样, 我们主要到, on可以指定要关联的列名, 但是我们可能需要关联的列名不同, 这时候我们要分别指定.

data1 = {"data1": [1, 2, 3, 4, 5], "key1":[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]}
data2 = {"data2": [1, 2, 3,100], "key2":[‘a‘, ‘b‘, ‘c‘, ‘f‘]}

frame1 = DataFrame(data1)
frame2 = DataFrame(data2)

print(frame1)

print(sep)

print(frame2)

   data1 key1
0      1    a
1      2    b
2      3    c
3      4    d
4      5    e
---------------------------------------------------------------------
   data2 key2
0      1    a
1      2    b
2      3    c
3    100    f

如果我们要在把key1和key2关联起来, 我们可以怎么做呢? 在sql中, 我们可以用on (key1 = key2), 在pandas中, 我们可以这么做:

print(pd.merge(frame1, frame2, how=‘inner‘, left_on=‘key1‘, right_on=‘key2‘).drop("key1", axis=1))

   data1  data2 key2
0      1      1    a
1      2      2    b
2      3      3    c

我们发现一个有趣的现象:

print(pd.merge(frame1, frame2, how=‘outer‘, left_on=‘key1‘, right_on=‘key2‘))

   data1 key1  data2 key2
0    1.0    a    1.0    a
1    2.0    b    2.0    b
2    3.0    c    3.0    c
3    4.0    d    NaN  NaN
4    5.0    e    NaN  NaN
5    NaN  NaN  100.0    f

我们发现, 这个数据就不一样了, 因为我们是外连接,会保留所有的数据.

多个键做关联也是一样的, 只不过把on改成一个list.

作业2: 研究多个键关联.

下面我们来说一个有趣的东西, 我们来看:

data1 = {"data": [1, 2, 3, 4, 5], "key":[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]}
data2 = {"data": [1, 2, 3,100], "key":[‘a‘, ‘b‘, ‘c‘, ‘f‘]}

frame1 = DataFrame(data1)
frame2 = DataFrame(data2)

print(frame1)

print(sep)

print(frame2)

print(sep)

print(pd.merge(frame1, frame2, on=‘key‘))

   data key
0     1   a
1     2   b
2     3   c
3     4   d
4     5   e
---------------------------------------------------------------------
   data key
0     1   a
1     2   b
2     3   c
3   100   f
---------------------------------------------------------------------
   data_x key  data_y
0       1   a       1
1       2   b       2
2       3   c       3

我们发现对于列名重复的列, 会自动加上一个后缀, 左边+_x, 右边+_y, 注意这个后缀, 我们是可以自己定义的.

print(pd.merge(frame1, frame2, on=‘key‘, suffixes=["-a", "-b"]))

   data-a key  data-b
0       1   a       1
1       2   b       2
2       3   c       3

然后我们的问题来了, 如果我们要关联的列, 是索引怎么办 , 这个问题有点意思, 但是merge这个函数已经为大家都设计好了,
我们可以这样搞:

data1 = {"data": [1, 2, 3, 4, 5], "key":[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]}
data2 = {"data": [1, 2, 3,100], "key":[‘a‘, ‘b‘, ‘c‘, ‘f‘]}

frame1 = DataFrame(data1, index=[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘])
frame2 = DataFrame(data2, index = [‘a‘, ‘b‘, ‘c‘, ‘f‘])

print(frame1)

print(sep)

print(frame2)

print(sep)

print(pd.merge(frame1, frame2, left_index=True, right_index=True))

print(sep)

frame2 = DataFrame(data2, index = [‘1‘, ‘2‘, ‘3‘, ‘4‘])

print(frame2)

print(sep)

print(pd.merge(frame1, frame2, left_index=True, right_on=‘key‘, how=‘left‘))

   data key
a     1   a
b     2   b
c     3   c
d     4   d
e     5   e
---------------------------------------------------------------------
   data key
a     1   a
b     2   b
c     3   c
f   100   f
---------------------------------------------------------------------
   data_x key_x  data_y key_y
a       1     a       1     a
b       2     b       2     b
c       3     c       3     c
---------------------------------------------------------------------
   data key
1     1   a
2     2   b
3     3   c
4   100   f
---------------------------------------------------------------------
  key  data_x key_x  data_y key_y
1   a       1     a     1.0     a
2   b       2     b     2.0     b
3   c       3     c     3.0     c
4   d       4     d     NaN   NaN
4   e       5     e     NaN   NaN

最后一个例子是把frame1的index和frame2的key连接了起来, 这里我们发现, frame1的索引因为被merge掉了, frame2的索引保留了下来, 同时frame1的key被保留了下来.

我们还有一个函数是join, 他也是实现了按索引关联.

frame1

	data	key
a	1	a
b	2	b
c	3	c
d	4	d
e	5	e

frame2

	data	key
1	1	a
2	2	b
3	3	c
4	100	f

frame1.join(frame2, lsuffix="_x", rsuffix="_y")

	data_x	key_x	data_y	key_y
a	1	a	NaN	NaN
b	2	b	NaN	NaN
c	3	c	NaN	NaN
d	4	d	NaN	NaN
e	5	e	NaN	NaN

我们发现调用者的索引被保留了下来.

# 参数的索引和调用者的列关联在一起
frame2.join(frame1, lsuffix="_x", rsuffix="_y", on="key")

	data_x	key_x	data_y	key_y
1	1	a	1.0	a
2	2	b	2.0	b
3	3	c	3.0	c
4	100	f	NaN	NaN

这里设置了on参数, 因此是调用者的列和参数的索引关联, 最后保留了调用者的索引.

实现union功能

上面介绍的都是列关联的,也就是join, 之后我们会看怎么做union. 所谓union就是在纵向上面做连接, 我们可以看到, 这种方式, 可以两张列相同的表拼接起来.

# Series的连接

a = Series([1, 2, 3], index=[‘a‘, ‘b‘, ‘c‘])
b = Series([3, 4], index=[‘d‘ , ‘e‘])
c = Series([6, 7], index=[‘e‘, ‘f‘])

pd.concat([a, b, c])

a    1
b    2
c    3
d    3
e    4
e    6
f    7
dtype: int64

我们看到, 这样就把这3个Series拼接起来了, 默认是在axis=0上连接的, 但是我们也可以在axis=1上连接, 我们来看看结果怎么样.

pd.concat([a, b, c], axis=1)

	0	1	2
a	1.0	NaN	NaN
b	2.0	NaN	NaN
c	3.0	NaN	NaN
d	NaN	3.0	NaN
e	NaN	4.0	6.0
f	NaN	NaN	7.0

我们看到, 这个相当于是这3个Series按索引做外连接. 如果我们要做内连接, 怎么办呢?

pd.concat([b, c], axis=1, join=‘inner‘)

	0	1
e	4	6

如果要区分从原来哪些地方合并而来的, 我们可以指定keys:

pd.concat([a, b, c], keys=[‘one‘, ‘two‘, ‘three‘])

one     a    1
        b    2
        c    3
two     d    3
        e    4
threee  e    6
        f    7
dtype: int64

pd.concat([a, b, c], axis=1,  keys=[‘one‘, ‘two‘, ‘three‘])

	one	two	three
a	1.0	NaN	NaN
b	2.0	NaN	NaN
c	3.0	NaN	NaN
d	NaN	3.0	NaN
e	NaN	4.0	6.0
f	NaN	NaN	7.0

我们发现, 我们的keys在axis=1连接的时候, 变成了列头.

我们下面来看看如果是两个DataFrame, 会怎么样.

f1 = DataFrame(np.arange(6).reshape(3, 2), index=[‘a‘, ‘b‘, ‘c‘], columns=[‘one‘, ‘two‘])

f2 = DataFrame(np.arange(4).reshape(2, 2), index=[‘c‘,  ‘d‘], columns=[‘three‘, ‘four‘])

print(f1)

print(sep)

print(f2)

   one  two
a    0    1
b    2    3
c    4    5
---------------------------------------------------------------------
   three  four
c      0     1
d      2     3

pd.concat([f1, f2])

	four	one	three	two
a	NaN	0.0	NaN	1.0
b	NaN	2.0	NaN	3.0
c	NaN	4.0	NaN	5.0
c	1.0	NaN	0.0	NaN
d	3.0	NaN	2.0	NaN

这就是我们要的union效果, 我们也可以区分出来源

pd.concat([f1, f2], keys=[1, 2])

		four	one	three	two
1	a	NaN	0.0	NaN	1.0
	b	NaN	2.0	NaN	3.0
	c	NaN	4.0	NaN	5.0
2	c	1.0	NaN	0.0	NaN
2	d	3.0	NaN	2.0	NaN

pd.concat([f1, f2], keys=[1, 2], axis=1)

	1		2
	one	two	three	four
a	0.0	1.0	NaN	NaN
b	2.0	3.0	NaN	NaN
c	4.0	5.0	0.0	1.0
d	NaN	NaN	2.0	3.0

如果我们不想要原来的索引, 而想要重新索引, 我们可以这样来:

pd.concat([f1, f2], ignore_index=True)

	four	one	three	two
0	NaN	0.0	NaN	1.0
1	NaN	2.0	NaN	3.0
2	NaN	4.0	NaN	5.0
3	1.0	NaN	0.0	NaN
4	3.0	NaN	2.0	NaN

总结起来, concat默认就是union的功能, 但是我们可以通过设置axis=1达到按索引关联的功能.

数据转换

轴旋转

这里我们要来聊聊轴旋转的课题, 其中主要用到两个函数:

stack 将列旋转为行
unstack 将行旋转为列

data = DataFrame(np.arange(6).reshape(2, 3), columns=pd.Index([‘a‘, ‘b‘, ‘c‘], name="column"), index=pd.Index(["one", "two"], name="index"))
print(data)

column  a  b  c
index          
one     0  1  2
two     3  4  5

我们来stack一下, 看看会有什么结果:

print(data.stack())

print(sep)

print(data[‘a‘][‘one‘])
print(data.loc[‘one‘][‘a‘])

print(sep)

print(data.stack()[‘one‘, ‘a‘])

index  column
one    a         0
       b         1
       c         2
two    a         3
       b         4
       c         5
dtype: int32
---------------------------------------------------------------------
0
0
---------------------------------------------------------------------
0

我们看到, 我们把每一行都变成了一列, 然后堆了起来, 变成了一个Series.

print(data.stack().unstack())

column  a  b  c
index          
one     0  1  2
two     3  4  5

我们来看看, 如果我们把stack后的two, c项给删了, 会怎么样呢?

a = data.stack()
del a[‘two‘, ‘c‘]

print(a.unstack())

column    a    b    c
index                
one     0.0  1.0  2.0
two     3.0  4.0  NaN

在unstack的时候, 会自动补充NaN值来对齐, 而在stack的时候, 会删除这些NaN值.

a.unstack().stack()

index  column
one    a         0.0
       b         1.0
       c         2.0
two    a         3.0
       b         4.0
dtype: float64

我们发现, 我们在做stack还是unstack的时候, 都是从最内测的轴开始的

b = a.unstack().stack()
print(b)

print(sep)

print(b.unstack())

index  column
one    a         0.0
       b         1.0
       c         2.0
two    a         3.0
       b         4.0
dtype: float64
---------------------------------------------------------------------
column    a    b    c
index                
one     0.0  1.0  2.0
two     3.0  4.0  NaN

确实是内侧的column转到了列上面去. 如果我们要转外侧的索引呢, 我们可以指定数字或者列名.

print(b.unstack(0))

print(b.unstack("index"))

index   one  two
column          
a       0.0  3.0
b       1.0  4.0
c       2.0  NaN
index   one  two
column          
a       0.0  3.0
b       1.0  4.0
c       2.0  NaN

index	one	two
count	3.0	2.000000
mean	1.0	3.500000
std	1.0	0.707107
min	0.0	3.000000
25%	0.5	3.250000
50%	1.0	3.500000
75%	1.5	3.750000
max	2.0	4.000000

这样, 行和列就互换了.

强调一下:

stack: 把行变成列. 我们可以这么理解, 把行堆到了列上.

unstack: 把列变成行, 把列反堆到了行上.

数据转换

去重

去除重复数据, 我们这里主要讲讲怎么能够把重复的数据进行去除

data = DataFrame({‘one‘:[1, 1, 2, 2, 3],‘two‘:[1, 1, 2, 2, 3]})
print(data)

   one  two
0    1    1
1    1    1
2    2    2
3    2    2
4    3    3

print(data.drop_duplicates())

   one  two
0    1    1
2    2    2
4    3    3

data = DataFrame({‘one‘:[1, 1, 2, 2, 3],‘two‘:[1, 1, 2, 2, 3], ‘three‘:[5, 6, 7, 8, 9]})
print(data)

   one  three  two
0    1      5    1
1    1      6    1
2    2      7    2
3    2      8    2
4    3      9    3

	one	three	two
count	5.00000	5.000000	5.00000
mean	1.80000	7.000000	1.80000
std	0.83666	1.581139	0.83666
min	1.00000	5.000000	1.00000
25%	1.00000	6.000000	1.00000
50%	2.00000	7.000000	2.00000
75%	2.00000	8.000000	2.00000
max	3.00000	9.000000	3.00000

我们可以按照某一列来进行去重

print(data.drop_duplicates([‘one‘]))

   one  three  two
0    1      5    1
2    2      7    2
4    3      9    3

去重默认是按照保留最先出现的一个, 我们也可以保留最后出现的一个.

作业3: 去重, 保留最后出现的一个.

对某一列运用函数

我们之前提到过, 对于一整列或者一整行, 可以用apply函数, 对于每个元素, 可以用applymap函数, 如果我们要对某一列的

每个元素进行运算, 我们可以用map函数.

data = DataFrame({‘one‘:[‘a‘, ‘b‘, ‘c‘],‘two‘:[‘e‘, ‘d‘, ‘f‘]})
print(data)

print(sep)

data[‘one‘] = data[‘one‘].map(str.upper)
print(data)

  one two
0   a   e
1   b   d
2   c   f
---------------------------------------------------------------------
  one two
0   A   e
1   B   d
2   C   f

如果我们只想把a变成大写呢, 我们可以用传入一个map的方法.

data = DataFrame({‘one‘:[‘a‘, ‘b‘, ‘c‘],‘two‘:[‘e‘, ‘d‘, ‘f‘]})
print(data)

print(sep)

data[‘one‘] = data[‘one‘].map({‘a‘:‘A‘, ‘b‘:‘b‘, ‘c‘:‘c‘})
print(data)

  one two
0   a   e
1   b   d
2   c   f
---------------------------------------------------------------------
  one two
0   A   e
1   b   d
2   c   f

在最后一个例子中, 我们发现要提供b和c的值, 太麻烦了, 可以用replace函数:


data[‘one‘] = data[‘one‘].replace(‘A‘, ‘a‘)
print(data)

  one two
0   a   e
1   b   d
2   c   f

重命名行和列名

这里我们来谈谈怎么重命名行或者列的名字. 我们可以用rename函数来完成, 比如我们希望把列名的首字母大写等等, 这个就留作作业.

作业4: 重命名行名和列名, 把首字母大写.

离散化

这里会讲一个很有用的技能, 就是离散化, 这个在我们后面处理特征的时候是非常有用的. 离散化主要是用到cut和qcut函数.

a = np.arange(20)
print(a)

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]

pd.cut(a, 4)  # 这个4将最大值和最小值间分成4等分

[(-0.019, 4.75], (-0.019, 4.75], (-0.019, 4.75], (-0.019, 4.75], (-0.019, 4.75], ..., (14.25, 19.0], (14.25, 19.0], (14.25, 19.0], (14.25, 19.0], (14.25, 19.0]]
Length: 20
Categories (4, interval[float64]): [(-0.019, 4.75] < (4.75, 9.5] < (9.5, 14.25] < (14.25, 19.0]]

pd.qcut(a, 4)  # 这个4按照个数分成四等分

[(-0.001, 4.75], (-0.001, 4.75], (-0.001, 4.75], (-0.001, 4.75], (-0.001, 4.75], ..., (14.25, 19.0], (14.25, 19.0], (14.25, 19.0], (14.25, 19.0], (14.25, 19.0]]
Length: 20
Categories (4, interval[float64]): [(-0.001, 4.75] < (4.75, 9.5] < (9.5, 14.25] < (14.25, 19.0]]

pd.qcut(a, 4).codes #输出codes

array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3], dtype=int8)

我们也可以按照我们指定的分割点来, 这个留作作业.

作业5: 按照自己定义的分割点来分割

过滤数据

这个小节的功能类似于select中的where语句, 但是要灵活的多, 我们先来看看怎么选出绝对值大于2的行.

data = DataFrame(np.random.randn(10, 10))
print(data)

          0         1         2         3         4         5         6  0 -0.064111 -1.237009  0.040219 -0.300265 -0.195558  0.018277 -0.484843   
1 -0.497673 -0.010135 -1.482219 -0.239210 -0.789893  0.593664  0.345015   
2 -1.818869  0.613175 -0.165610  0.649670 -1.364698  0.444785 -0.146202   
3 -0.274151  0.718986  0.321961 -0.416124 -0.275706 -0.738405 -0.260420   
4  1.980359 -0.429317 -0.964024 -1.474141  0.339342 -0.932012 -0.116387   
5 -0.518374 -0.224879 -1.517607 -0.079120  0.728408  1.218297  1.191882   
6 -0.508048  2.010942  1.338983  2.026203 -0.794110 -1.370830  1.364660   
7  0.855870 -0.804471  0.939610  0.796154  0.467878  0.362091 -1.892815   
8  1.059561  0.223369  1.098954  1.583732  0.865225 -0.597980 -1.853170   
9 -0.434388  0.475098 -0.103491 -0.735113  0.823425 -0.905158  0.145539   

          7         8         9  
0 -1.370281  0.112070 -0.387124  
1  0.049215  0.578946  0.462688  
2  0.085562  2.906838 -1.059603  
3 -0.327103  0.504234  0.192760  
4  0.826963  1.188256  0.590085  
5 -0.061007  1.955653 -0.984727  
6 -0.471252  1.067497  0.550022  
7 -0.503244 -0.288634  1.121110  
8 -0.650933  0.138730 -0.389139  
9 -2.078052  0.158038 -0.109184

print(data[np.abs(data) > 2])

    0         1   2         3   4   5   6         7         8   9
0 NaN       NaN NaN       NaN NaN NaN NaN       NaN       NaN NaN
1 NaN       NaN NaN       NaN NaN NaN NaN       NaN       NaN NaN
2 NaN       NaN NaN       NaN NaN NaN NaN       NaN  2.906838 NaN
3 NaN       NaN NaN       NaN NaN NaN NaN       NaN       NaN NaN
4 NaN       NaN NaN       NaN NaN NaN NaN       NaN       NaN NaN
5 NaN       NaN NaN       NaN NaN NaN NaN       NaN       NaN NaN
6 NaN  2.010942 NaN  2.026203 NaN NaN NaN       NaN       NaN NaN
7 NaN       NaN NaN       NaN NaN NaN NaN       NaN       NaN NaN
8 NaN       NaN NaN       NaN NaN NaN NaN       NaN       NaN NaN
9 NaN       NaN NaN       NaN NaN NaN NaN -2.078052       NaN NaN

完了, 居然是这幅德行

np.abs(data) > 2

	0	1	2	3	4	5	6	7	8	9
0	False	False	False	False	False	False	False	False	False	False
1	False	False	False	False	False	False	False	False	False	False
2	False	False	False	False	False	False	False	False	True	False
3	False	False	False	False	False	False	False	False	False	False
4	False	False	False	False	False	False	False	False	False	False
5	False	False	False	False	False	False	False	False	False	False
6	False	True	False	True	False	False	False	False	False	False
7	False	False	False	False	False	False	False	False	False	False
8	False	False	False	False	False	False	False	False	False	False
9	False	False	False	False	False	False	False	True	False	False

我们发现, false的这些地方, 都被设为NaN, 我们不想要这些false的数据, 我们只需要存在一个大于2的行, 我们看看apply函数行不行呢?

data[(np.abs(data) > 2).apply(lambda x: x.name if x.sum() > 0 else None, axis=1).notnull()]

	0	1	2	3	4	5	6	7	8	9
2	-1.818869	0.613175	-0.165610	0.649670	-1.364698	0.444785	-0.146202	0.085562	2.906838	-1.059603
6	-0.508048	2.010942	1.338983	2.026203	-0.794110	-1.370830	1.364660	-0.471252	1.067497	0.550022
9	-0.434388	0.475098	-0.103491	-0.735113	0.823425	-0.905158	0.145539	-2.078052	0.158038	-0.109184

这样看上去实在是太复杂了, 其实可以简化

(np.abs(data) > 2).any(1)

0    False
1    False
2     True
3    False
4    False
5    False
6     True
7    False
8    False
9     True
dtype: bool

data[(np.abs(data) > 2).any(1)] # 有一个真就是真

	0	1	2	3	4	5	6	7	8	9
2	-1.818869	0.613175	-0.165610	0.649670	-1.364698	0.444785	-0.146202	0.085562	2.906838	-1.059603
6	-0.508048	2.010942	1.338983	2.026203	-0.794110	-1.370830	1.364660	-0.471252	1.067497	0.550022
9	-0.434388	0.475098	-0.103491	-0.735113	0.823425	-0.905158	0.145539	-2.078052	0.158038	-0.109184

这里这个any(1)相当于是apply(lambda x: x.name if x.sum() > 0 else None, axis=1).notnull()

转换为onehot表示

下面我们来提一个东西, 就是怎么将数据转换为onehot的表示.

data = DataFrame({‘one‘: np.arange(20), ‘two‘: np.arange(20)})
data.join(pd.get_dummies(pd.cut(data[‘one‘],  4).values.codes, prefix="one_"))

	one	two	one__0	one__1	one__2	one__3
0	0	0	1	0	0	0
1	1	1	1	0	0	0
2	2	2	1	0	0	0
3	3	3	1	0	0	0
4	4	4	1	0	0	0
5	5	5	0	1	0	0
6	6	6	0	1	0	0
7	7	7	0	1	0	0
8	8	8	0	1	0	0
9	9	9	0	1	0	0
10	10	10	0	0	1	0
11	11	11	0	0	1	0
12	12	12	0	0	1	0
13	13	13	0	0	1	0
14	14	14	0	0	1	0
15	15	15	0	0	0	1
16	16	16	0	0	0	1
17	17	17	0	0	0	1
18	18	18	0	0	0	1
19	19	19	0	0	0	1

是不是超级简单.

字符串操作

我们来看看字符串的操作, 其实主要还是正则表达式, 我们来看一个例子:

data = DataFrame({‘a‘:["xiaoming@sina.com", "xiaozhang@gmail.com", "xiaohong@qq.com"], ‘b‘:[1, 2, 3]})
print(data)

                     a  b
0    xiaoming@sina.com  1
1  xiaozhang@gmail.com  2
2      xiaohong@qq.com  3

import re
pattern = r‘([A-Z]+)@([A-Z]+)\.([A-Z]{2,4})‘

data[‘a‘].str.findall(pattern, flags=re.IGNORECASE).str[0].str[1]

0     sina
1    gmail
2       qq
Name: a, dtype: object

我们看到, 我们可以用python的正则表达式来处理字符串问题.

**作业6: 熟悉python正则表达式. http://www.runoob.com/python3/python3-reg-expressions.html**

数据分析之pandas教程------数据处理

标签：2.2.3 inter only 运用个数 int range null 数据转换

原文地址：https://www.cnblogs.com/songfy/p/8447712.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

数据分析之pandas教程------数据处理

目录

数据合并

实现数据库表join功能

实现union功能

数据转换

轴旋转

数据转换

去重

对某一列运用函数

重命名行和列名

离散化

过滤数据

转换为onehot表示

字符串操作

	0	1	2
a	1.0	NaN	NaN
b	2.0	NaN	NaN
c	3.0	NaN	NaN
d	NaN	3.0	NaN
e	NaN	4.0	6.0
f	NaN	NaN	7.0

	one	two	three
a	1.0	NaN	NaN
b	2.0	NaN	NaN
c	3.0	NaN	NaN
d	NaN	3.0	NaN
e	NaN	4.0	6.0
f	NaN	NaN	7.0

	four	one	three	two
a	NaN	0.0	NaN	1.0
b	NaN	2.0	NaN	3.0
c	NaN	4.0	NaN	5.0
c	1.0	NaN	0.0	NaN
d	3.0	NaN	2.0	NaN

		four	one	three	two
1	a	NaN	0.0	NaN	1.0
	b	NaN	2.0	NaN	3.0
	c	NaN	4.0	NaN	5.0
2	c	1.0	NaN	0.0	NaN
2	d	3.0	NaN	2.0	NaN

	four	one	three	two
0	NaN	0.0	NaN	1.0
1	NaN	2.0	NaN	3.0
2	NaN	4.0	NaN	5.0
3	1.0	NaN	0.0	NaN
4	3.0	NaN	2.0	NaN

	one	two	one__0	one__1	one__2	one__3
0	0	0	1	0	0	0
1	1	1	1	0	0	0
2	2	2	1	0	0	0
3	3	3	1	0	0	0
4	4	4	1	0	0	0
5	5	5	0	1	0	0
6	6	6	0	1	0	0
7	7	7	0	1	0	0
8	8	8	0	1	0	0
9	9	9	0	1	0	0
10	10	10	0	0	1	0
11	11	11	0	0	1	0
12	12	12	0	0	1	0
13	13	13	0	0	1	0
14	14	14	0	0	1	0
15	15	15	0	0	0	1
16	16	16	0	0	0	1
17	17	17	0	0	0	1
18	18	18	0	0	0	1
19	19	19	0	0	0	1

	0	1	2
a	1.0	NaN	NaN
b	2.0	NaN	NaN
c	3.0	NaN	NaN
d	NaN	3.0	NaN
e	NaN	4.0	6.0
f	NaN	NaN	7.0

	one	two	three
a	1.0	NaN	NaN
b	2.0	NaN	NaN
c	3.0	NaN	NaN
d	NaN	3.0	NaN
e	NaN	4.0	6.0
f	NaN	NaN	7.0

	four	one	three	two
a	NaN	0.0	NaN	1.0
b	NaN	2.0	NaN	3.0
c	NaN	4.0	NaN	5.0
c	1.0	NaN	0.0	NaN
d	3.0	NaN	2.0	NaN

		four	one	three	two
1	a	NaN	0.0	NaN	1.0
	b	NaN	2.0	NaN	3.0
	c	NaN	4.0	NaN	5.0
2	c	1.0	NaN	0.0	NaN
2	d	3.0	NaN	2.0	NaN

	four	one	three	two
0	NaN	0.0	NaN	1.0
1	NaN	2.0	NaN	3.0
2	NaN	4.0	NaN	5.0
3	1.0	NaN	0.0	NaN
4	3.0	NaN	2.0	NaN

	one	two	one__0	one__1	one__2	one__3
0	0	0	1	0	0	0
1	1	1	1	0	0	0
2	2	2	1	0	0	0
3	3	3	1	0	0	0
4	4	4	1	0	0	0
5	5	5	0	1	0	0
6	6	6	0	1	0	0
7	7	7	0	1	0	0
8	8	8	0	1	0	0
9	9	9	0	1	0	0
10	10	10	0	0	1	0
11	11	11	0	0	1	0
12	12	12	0	0	1	0
13	13	13	0	0	1	0
14	14	14	0	0	1	0
15	15	15	0	0	0	1
16	16	16	0	0	0	1
17	17	17	0	0	0	1
18	18	18	0	0	0	1
19	19	19	0	0	0	1

	0	1	2
a	1.0	NaN	NaN
b	2.0	NaN	NaN
c	3.0	NaN	NaN
d	NaN	3.0	NaN
e	NaN	4.0	6.0
f	NaN	NaN	7.0

	one	two	three
a	1.0	NaN	NaN
b	2.0	NaN	NaN
c	3.0	NaN	NaN
d	NaN	3.0	NaN
e	NaN	4.0	6.0
f	NaN	NaN	7.0

	four	one	three	two
a	NaN	0.0	NaN	1.0
b	NaN	2.0	NaN	3.0
c	NaN	4.0	NaN	5.0
c	1.0	NaN	0.0	NaN
d	3.0	NaN	2.0	NaN

		four	one	three	two
1	a	NaN	0.0	NaN	1.0
	b	NaN	2.0	NaN	3.0
	c	NaN	4.0	NaN	5.0
2	c	1.0	NaN	0.0	NaN
2	d	3.0	NaN	2.0	NaN

	four	one	three	two
0	NaN	0.0	NaN	1.0
1	NaN	2.0	NaN	3.0
2	NaN	4.0	NaN	5.0
3	1.0	NaN	0.0	NaN
4	3.0	NaN	2.0	NaN

	one	two	one__0	one__1	one__2	one__3
0	0	0	1	0	0	0
1	1	1	1	0	0	0
2	2	2	1	0	0	0
3	3	3	1	0	0	0
4	4	4	1	0	0	0
5	5	5	0	1	0	0
6	6	6	0	1	0	0
7	7	7	0	1	0	0
8	8	8	0	1	0	0
9	9	9	0	1	0	0
10	10	10	0	0	1	0
11	11	11	0	0	1	0
12	12	12	0	0	1	0
13	13	13	0	0	1	0
14	14	14	0	0	1	0
15	15	15	0	0	0	1
16	16	16	0	0	0	1
17	17	17	0	0	0	1
18	18	18	0	0	0	1
19	19	19	0	0	0	1