一、向量化操作概述

Python内置一系列强大的字符串处理方法，但这些方法只能处理单个字符串，处理一个序列的字符串时，需要用到循环。

那么，有没有办法，不用循环就能同时处理多个字符串呢，pandas的向量化操作就提供了这样的方法。

向量化的操作使我们不必担心数组的长度和维度，只需要关系操作功能，尤为强大的是，除了支持常用的字符串操作方法，还集成了正则表达式的大部分功能，这使得pandas在处理字符串列时，具有非常大的魔力。

例如，要计算每个单词中‘a’的个数，下面一行代码就可以搞定，非常高效

s = pd.Series(['amazon','alibaba','baidu'])
s.str.count('a')
0    2
1    3
2    1

假如用内置的字符串函数进行操作，需要进行遍历，且Python原生的遍历操作无法处理缺失值。

#用循环进行处理

s = ['amazon','alibaba','baidu']
[i.count('a') for i in s]
[2, 3, 1]

#存在缺失值时，打印报错

s = ['amazon','alibaba','baidu',None]
[i.count('a') for i in s]
AttributeError: 'NoneType' object has no attribute 'lower'

Pandas的向量化操作，能够正确的处理缺失值，无报错信息，如下

s = pd.Series(['amazon','alibaba','baidu',None])
s.str.count('a')
Out[36]:
0    2.0
1    3.0
2    1.0
3    NaN
dtype: float64

通过上面的例子，对向量化进行简单总结，向量化是一种同时操作整个数组而不是一次操作一个元素的方法，下面从看看具体怎么应用。

二、向量化的字符方法

Pandas的字符串属的方法几乎包括了大部分Python的内置字符串方法（内置共有45个方法）,下面将列举一些常见的方法的用法，例如上面的count()方法将会返回某个字符的个数,而len方法将会返回整个字符的长度。

下面选取部分函数举例，其他函数参考字符串模块：Python字符串的45个方法详解

len()

import pandas as pd
import numpy as np s = pd.Series(['amazon','alibaba','Baidu'])
s.str.len()
Out[5]:
0    6
1    7
2    5
dtype: int64

lower()

s = pd.Series(['amazon','alibaba','Baidu'])
s.str.lower()
0     amazon
1    alibaba
2      baidu

zfill()

右对齐，前面用0填充到指定字符串长度

s = pd.Series(['56783','34','987766721','326'])
s.str.zfill(10)
Out[53]:
0    0000056783
1    0000000034
2    0987766721
3    0000000326
dtype: object

三、向量化的正则表达式

Pandas的字符串方法根据Python标准库的re模块实现了正则表达式，下面将介绍Pandas的str属性内置的正则表达式相关方法

split()

split,按指定字符分割字符串，类似split的方法返回一个列表类型的序列

#按数字分割

pd.Series(['QQ1252号码','QQ1353加我','我389的']).str.split('\d+')
Out[39]:
0    [QQ, 号码]
1    [QQ, 加我]
2     [我, 的]
dtype: object

s=pd.Series(['a_b_c', 'c_d_e', np.nan, 'f_g_h'])
s.str.split('_')
Out[94]:
0    [a, b, c]
1    [c, d, e]
2          NaN
3    [f, g, h]
dtype: object

切分后的列表中的元素可以通过get方法或者 [] 方法进行读取

s.str.split('_').str.get(1)
Out[96]:
0      b
1      d
2    NaN
3      g
dtype: object

使用expand方法可以轻易地将这种返回展开为一个数据表

s.str.split('_', expand=True)
Out[97]: 0    1    2
0    a    b    c
1    c    d    e
2  NaN  NaN  NaN
3    f    g    h

同样，我们也可以限制切分的次数：

In [20]: s.str.split('_', expand=True, n=1)
Out[20]: 0    1
0    a  b_c
1    c  d_e
2  NaN  NaN
3    f  g_h

rsplit()

rsplit与split相似，不同的是，这个切分的方向是反的。即，从字串的尾端向首段切分

In [21]: s.str.rsplit('_', expand=True, n=1)
Out[21]: 0    1
0  a_b    c
1  c_d    e
2  NaN  NaN
3  f_g    h

replace ()

replace方法默认使用正则表达式

s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca','', np.nan, 'CABA', 'dog', 'cat'])s.str.replace('^.a|dog', 'XX-XX ', case=False)
Out[27]:
0           A
1           B
2           C
3    XX-XX ba
4    XX-XX ca
5
6         NaN
7    XX-XX BA
8      XX-XX
9     XX-XX t

findall()

提取聊天记录中的QQ号

s=pd.Series(['QQ号码123452124','QQ123356123','我的Q123356189','Q号123356111注意','加我Q号123356124有惊喜'])
s.str.findall('\d+')
0    [123452124]
1    [123356123]
2    [123356189]
3    [123356111]
4    [123356124]

四、其他向量化的方法

除了上面介绍的Pandas字符串的正常操作和正则表达式外，Pandas的str属性还提供了其他的一些方法，这些方法非常的有用，在进行特征提取或者数据清洗时，非常高效，具体如下：

wrap()

s = pd.Series(['0000056783','0000000034','0987766721'])
s.str.wrap(5)
Out[68]:
0    00000\n56783
1    00000\n00034
2    09877\n66721
dtype: object

pad()

s = pd.Series(['A','E','C','D','E'])
s.str.pad(5)
Out[65]:
0        A
1        E
2        C
3        D
4        E
dtype: object

slice()

Series_1 = pd.Series(['马 云：2000亿','马化腾：1800亿','王健林：1200亿','小伍哥：0.000012亿'])
Series_1.str.slice(0,3)
Out[33]:
0    马 云
1    马化腾
2    王健林
3    小伍哥
dtype: object

get()

Series_1.str.get(0)
Out[34]:
0    马
1    马
2    王
3    小
dtype: object

slice_replace()

切片替换

Series_1.str.slice_replace(0,3,'小伍哥')
Out[36]:
0        小伍哥：2000亿
1        小伍哥：1800亿
2        小伍哥：1200亿
3    小伍哥：0.000012亿
dtype: objectSeries_1.str.join('-')
Out[41]:
0            马- -云-：-2-0-0-0-亿
1            马-化-腾-：-1-8-0-0-亿
2            王-健-林-：-1-2-0-0-亿
3    小-伍-哥-：-0-.-0-0-0-0-1-2-亿
dtype: objectSeries_1 = pd.Series(['A','E','C','D','E'])
Series_1.str.get_dummies()A  C  D  E
0  1  0  0  0
1  0  0  0  1
2  0  1  0  0
3  0  0  1  0
4  0  0  0

get_dummies()

另一个需要好好解释的是get_dummies()方法，举个例子：假如我们用A，B，C，D来表示一个人的某个特征：

monte = pd.Series(['Graham Chapman', 'John Cleese', 'Terry Gilliam','Eric Idle', 'Terry Jones', 'Michael Palin'])
full_monte = pd.DataFrame({'name': monte,'info': ['B|C|D', 'B|D', 'A|C','B|D', 'B|C', 'B|C|D']})
full_montename   info
0  Graham Chapman  B|C|D
1     John Cleese    B|D
2   Terry Gilliam    A|C
3       Eric Idle    B|D
4     Terry Jones    B|C
5   Michael Palin  B|C|D
可以看到比如Graham Chapman有B，C，D三种特征，而John Cleese有B和D两种特征。这时我们可以用get_dummies('|')以|作为分隔符，将这些特征进行one-hotfull_monte['info'].str.get_dummies('|')
Out[52]: A  B  C  D
0  0  1  1  1
1  0  1  0  1
2  1  0  1  0
3  0  1  0  1
4  0  1  1  0
5  0  1  1  1

repeat()

s = pd.Series(['A','E','C','D','E'])
s.str.repeat(2)
Out[62]:
0    AA
1    EE
2    CC
3    DD
4    EE
dtype: object

cat()

作用：连接字符串

用法：Series.str.cat(others=None, sep=None, na_rep=None)

参数:

• others : 列表或复合列表,默认为None,如果为None则连接本身的元素

• sep : 字符串 或者None,默认为None

• na_rep : 字符串或者 None, 默认 None。如果为None缺失值将被忽略。

返回值: concat : 序列(Series)/索引(Index)/字符串(str)

#如果连接的是两个序列，则会一一对应连接
s1 = pd.Series(['A','E','C','D','E'])
s2 = pd.Series(['1','2','3','4','5'])
s1.str.cat(s2)
Out[74]:
0    A1
1    E2
2    C3
3    D4
4    E5
dtype: object#只提供一个序列，则只连接自己，默认为空格
s1.str.cat()
'AECDE'
s1.str.cat(sep='-')
'A-E-C-D-E'#也可以同时复核连接，参数可以是二维的
d = pd.concat([s1, s2], axis=1)
s3.str.cat(d, na_rep='-')
Out[87]:
0    xA1
1    xE2
2    yC3
3    yD4
4    yE5
dtype: objec

五、Pandas学习文档

官方文档

链接：https://pandas.pydata.org/pandas-docs/stable/index.html

官方文档，每个函数和方法，都有详细的介绍，对于英语比较好的同学，强烈推荐直接看官方文档，非常清晰，完整。

中文文档

文档链接：https://www.pypandas.cn/docs/

对于英语不好的同学，可以看国内翻译过来的文档，还是比较全面的，基本上也能获得比较好的学习效果。

接口文档

https://pandas.pydata.org/pandas-docs/version/0.17.0/#

往期精彩回顾适合初学者入门人工智能的路线及资料下载机器学习及深度学习笔记等资料打印机器学习在线手册深度学习笔记专辑《统计学习方法》的代码复现专辑
AI基础下载机器学习的数学基础专辑
获取本站知识星球优惠券，复制链接直接打开：
https://t.zsxq.com/y7uvZF6
本站qq群704220115。加入微信群请扫码：