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

    目录

    数据合并

    实现数据库表join功能

    当我们有多张表的时候, 经常会遇到的一个问题就是, 如何把这些表关联起来, 我们可以想想我们在数据库的时候,
    进场会遇到表连接的问题, 比如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
    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
  • 相关阅读:
    新购服务器流程
    nginx代理证书使用方法
    一键部署lnmp脚本
    mysql主从库配置读写分离以及备份
    Linux入门教程（更新完毕）
    Git 工作流程
    Git远程操作
    常用Git命令
    js数组去重
    Sublime Text设置快捷键让html文件在浏览器打开
  • 原文地址：https://www.cnblogs.com/songfy/p/8447712.html
Copyright © 2020-2023  润新知