啃书：《利用python进行数据分析》第七章——数据清洗（三）

字符串操作

字符串操作是我们很常见的一种处理，在实际应用中，我们会经常使用到对字符串的处理，python本身就是对字符串处理非常擅长，非常多的库函数可以帮助我们解决绝大部分我们生产生活中的简单问题。对于更为复杂的模式匹配和文本操作，则可能需要用到正则表达式。pandas对此进行了加强，它使你能够对整组数据应用字符串表达式和正则表达式，而且能处理烦人的缺失数据。

字符串对象方法

对于许多字符串处理和脚本应用，内置的字符串方法已经能够满足要求了。例如，以逗号分隔的字符串可以用split拆分成数段：

In [134]: val = 'a,b,  guido'
In [135]: val.split(',')
Out[135]: ['a', 'b', '  guido']

split常常与strip一起使用，以去除空白符（包括换行符）：

In [136]: pieces = [x.strip() for x in val.split(',')]

In [137]: pieces
Out[137]: ['a', 'b', 'guido']

利用加法，可以将这些子字符串以双冒号分隔符的形式连接起来：

In [138]: first, second, third = pieces

In [139]: first + '::' + second + '::' + third
Out[139]: 'a::b::guido'

但这种方式并不是很实用。一种更快更符合Python风格的方式是，向字符串"::"的join方法传入一个列表或元组：

In [140]: '::'.join(pieces)
Out[140]: 'a::b::guido'

其它方法关注的是子串定位。检测子串的最佳方式是利用Python的in关键字，还可以使用index和find：

In [141]: 'guido' in val
Out[141]: True

In [142]: val.index(',')
Out[142]: 1

In [143]: val.find(':')
Out[143]: -1

注意find和index的区别：如果找不到字符串，index将会引发一个异常（而不是返回－1）

与此相关，count可以返回指定子串的出现次数：

In [145]: val.count(',')
Out[145]: 2

replace用于将指定模式替换为另一个模式。通过传入空字符串，它也常常用于删除模式：

In [146]: val.replace(',', '::')
Out[146]: 'a::b::  guido'

In [147]: val.replace(',', '')
Out[147]: 'ab  guido'

下图列出了Python内置的字符串方法。这些运算大部分都能使用正则表达式实现。

正则表达式

对于我们学习的每一种编程语言，都会有对应的正则表达式的讲解，这都要归功于它提供了一种文本中能够灵活查找与匹配字符串模式的方法。单个表达式通常被称为regex，是根据正则表达式语言形成的字符串。Python内建的re模块就是对于正则表达式进行处理的字符串库。这里会有一些简单的例子提供出来方便大家理解。

编写正则表达式的方式是完全可以自己独立为一个大的章节的，由于网上有很多的更加详细的教程，这里就不在这里进行过多的赘述，大家可以通过网上学习很多详细的正则表达式的视频进行学习。

re模块主要分为三个主题：模式匹配、替代、拆分。当然这三块主题都是相互关联呼应的。一个正则表达式描述了在文本中需要定位的模式，可以用于很多种载体目标。让我们看一个简单的例子：假设我们想将含有很多种空白字符（制表符、空格、换行符）的字符串进行拆分。描述一个或多个空白字符的正则表达式是“\s+”：

In [148]: import re

In [149]: text = "foo    bar\t baz  \tqux"

In [150]: re.split('\s+', text)
Out[150]: ['foo', 'bar', 'baz', 'qux']

当你调用re.split(‘\s+’, text)函数时候，正则表达式会首先被编译，然后再split方法传入文本上被调用，你可以使用re.compile自行编译，形成一个可重复使用的正则表达式对象：

In [151]: regex = re.compile('\s+')

In [152]: regex.split(text)
Out[152]: ['foo', 'bar', 'baz', 'qux']

如果你想获得这种匹配的所有情况的列表，你可以使用findall方法：

In [153]: regex.findall(text)
Out[153]: ['    ', '\t ', '  \t']

如果你需要将相同的表达式应用到多个字符串中，推荐你使用re.compile创建一个正则表达式对象，这样做有利于节约CPU周期。

match和search与findall相关性很大。findall返回的是字符串中所有的匹配项，而search返回的不仅仅是第一个匹配项。match更为严格，它只是在字符串的起始位置进行匹配。作为一个不重要的示例，我们考虑下一段文本以及一个可以识别大部分电子邮件地址的正则表达式：

text = """Dave dave@google.com
Steve steve@gmail.com
Rob rob@gmail.com
Ryan ryan@yahoo.com
"""
pattern = r'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}'

# re.IGNORECASE makes the regex case-insensitive
regex = re.compile(pattern, flags=re.IGNORECASE)

在上述文本中使用findall会生成一个电子邮件列表：

In [155]: regex.findall(text)
Out[155]: 
['dave@google.com',
 'steve@gmail.com',
 'rob@gmail.com',
 'ryan@yahoo.com']

search返回的是文本中第一个匹配到的电子邮件地址。对于前面的正则表达式，匹配对象只能告诉我们模式在字符串中起始和结束位置：

In [156]: m = regex.search(text)

In [157]: m
Out[157]: <_sre.SRE_Match object; span=(5, 20), match='dave@google.com'>

In [158]: text[m.start():m.end()]
Out[158]: 'dave@google.com'

regex.match则将返回None，因为它只匹配出现在字符串开头的模式：

In [159]: print(regex.match(text))
None

相关的，sub方法可以将匹配到的模式替换为指定字符串，并返回所得到的新字符串：

In [160]: print(regex.sub('REDACTED', text))
Dave REDACTED
Steve REDACTED
Rob REDACTED
Ryan REDACTED

假设你不仅想要找出电子邮件地址，还想将各个地址分成3个部分：用户名、域名以及域后缀。要实现此功能，只需将待分段的模式的各部分用圆括号包起来即可：

In [161]: pattern = r'([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})'

In [162]: regex = re.compile(pattern, flags=re.IGNORECASE)

由这种修改过的正则表达式所产生的匹配项对象，可以通过其groups方法返回一个由模式各段组成的元组：

In [163]: m = regex.match('wesm@bright.net')

In [164]: m.groups()
Out[164]: ('wesm', 'bright', 'net')

对于带有分组功能的模式，findall会返回一个元组列表：

In [165]: regex.findall(text)
Out[165]:
[('dave', 'google', 'com'),
 ('steve', 'gmail', 'com'),
 ('rob', 'gmail', 'com'),
 ('ryan', 'yahoo', 'com')]

sub还能通过诸如\1、\2之类的特殊符号访问各匹配项中的分组。符号\1对应第一个匹配的组，\2对应第二个匹配的组，以此类推：

In [166]: print(regex.sub(r'Username: \1, Domain: \2, Suffix: \3', text))
Dave Username: dave, Domain: google, Suffix: com
Steve Username: steve, Domain: gmail, Suffix: com
Rob Username: rob, Domain: gmail, Suffix: com
Ryan Username: ryan, Domain: yahoo, Suffix: com

Python中还有许多的正则表达式，但大部分都超出了本书的范围。下图是一个简要概括。

pandas中的向量化字符串函数

为了清理杂乱数据集用于分析通常需要大量的字符串处理和正则化。包含字符串的列有时会含有缺失数据，使事情变得复杂：

In [167]: data = {'Dave': 'dave@google.com', 'Steve': 'steve@gmail.com',
   .....:         'Rob': 'rob@gmail.com', 'Wes': np.nan}

In [168]: data = pd.Series(data)

In [169]: data
Out[169]: 
Dave     dave@google.com
Rob        rob@gmail.com
Steve    steve@gmail.com
Wes                  NaN
dtype: object

In [170]: data.isnull()
Out[170]: 
Dave     False
Rob      False
Steve    False
Wes       True
dtype: bool

通过data.map，所有字符串和正则表达式方法都能被应用于（传入lambda表达式或其他函数）各个值，但是如果存在NA（null）就会报错。为了解决这个问题，Series有一些能够跳过NA值的面向数组方法，进行字符串操作。通过Series的str属性即可访问这些方法。例如，我们可以通过str.contains检查各个电子邮件地址是否含有"gmail"：

In [171]: data.str.contains('gmail')
Out[171]: 
Dave     False
Rob       True
Steve     True
Wes        NaN
dtype: object

也可以使用正则表达式，还可以加上任意re选项（如IGNORECASE）：

In [172]: pattern
Out[172]: '([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\\.([A-Z]{2,4})'

In [173]: data.str.findall(pattern, flags=re.IGNORECASE)
Out[173]: 
Dave     [(dave, google, com)]
Rob        [(rob, gmail, com)]
Steve    [(steve, gmail, com)]
Wes                        NaN
dtype: object

有两个办法可以实现矢量化的元素获取操作：要么使用str.get，要么在str属性上使用索引：

In [174]: matches = data.str.match(pattern, flags=re.IGNORECASE)

In [175]: matches
Out[175]: 
Dave     True
Rob      True
Steve    True
Wes       NaN
dtype: object

要访问嵌入列表中的元素，我们可以传递索引到这两个函数中：

In [176]: matches.str.get(1)
Out[176]: 
Dave    NaN
Rob     NaN
Steve   NaN
Wes     NaN
dtype: float64

In [177]: matches.str[0]
Out[177]: 
Dave    NaN
Rob     NaN
Steve   NaN
Wes     NaN
dtype: float64

你可以利用这种方法对字符串进行截取：

In [178]: data.str[:5]
Out[178]: 
Dave     dave@
Rob      rob@g
Steve    steve
Wes        NaN
dtype: object

下图介绍了更多的pandas字符串方法。