字符串操作

Python能够成为流行的数据处理语言，部分原因是其简单易用的字符串和文本处理功能。大部分文本运算都直接做成了字符串对象的内置方法。对于更为复杂的模式匹配和文本操作，则可能需要用到正则表达式。pandas对此进行了加强，它使你能够对整组数据应用字符串表达式和正则表达式，而且能处理烦人的缺失数据。

字符串对象方法

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

  1. In [208]: val = 'a,b,  guido'
  2.  
  3. In [209]: val.split(',')
  4. Out[209]: ['a', 'b', '  guido']

split常常结合strip（用于修剪空白符（包括换行符））一起使用：

  1. In [210]: pieces = [x.strip() for x in val.split(',')]
  2.  
  3. In [211]: pieces
  4. Out[211]: ['a', 'b', 'guido']

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

  1. In [212]: first, second, third = pieces
  2.  
  3. In [213]: first + '::' + second + '::' + third
  4. Out[213]: 'a::b::guido'

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

  1. In [214]: '::'.join(pieces)
  2. Out[214]: 'a::b::guido'

另一类方法关注的是子串定位。检测子串的最佳方式是利用Python的in关键字（当然还可以使用index和find）：

  1. In [215]: 'guido' in val
  2. Out[215]: True
  3.  
  4. In [216]: val.index(',')
  5. Out[216]: 1
  6. In [217]: val.find(':')
  7. Out[217]: -1

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

  1. In [218]: val.index(':')

ValueError Traceback (most recent call last) <ipython-input-218-280f8b2856ce> in <module>() ——> 1 val.index(':') ValueError: substring not found

此外还有一个count函数，它可以返回指定子串的出现次数：

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

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

  1. In [220]: val.replace(',', '::')
  2. Out[220]: 'a::b::  guido'
  3. In [221]: val.replace(',', '')
  4. Out[221]: 'ab  guido'

这些运算大部分都能使用正则表达式实现（马上就会看到）。

Python内置的字符串方法如表7-3所示。

字符串操作 - 图1

字符串操作 - 图2

译注10：这里的说法有误。字符串的各个元素不就是字符吗？这里不是矢量化的，当涉及pandas中的这几个函数的矢量版时才应该加上后面这句。

正则表达式

正则表达式（通常称作regex）提供了一种灵活的在文本中搜索或匹配字符串模式的方式。正则表达式是根据正则表达式语言编写的字符串。Python内置的re模块负责对字符串应用正则表达式。我将通过一些例子说明其使用方法。

注意： 正则表达式的编写技巧可以自成一章译注11，因此超出了本书的范围。网上可以找到许多非常不错的教程和参考资料，比如Zed Shaw的《Learn Regex The Hard Way》（http://regex.learncodethehardway.org/book/）。

re模块的函数可以分为三个大类：模式匹配、替换以及拆分。当然，它们之间是相辅相成的。一个regex描述了需要在文本中定位的一个模式，它可以用于许多目的。我们先来看一个简单的例子：假设我想要拆分一个字符串，分隔符为数量不定的一组空白符（制表符、空格、换行符等）。描述一个或多个空白符的regex是\s+：

  1. In [222]: import re
  2.  
  3. In [223]: text = "foo   bar\t baz  \tqux"
  4.  
  5. In [224]: re.split('\s+', text)
  6. Out[224]: ['foo', 'bar', 'baz', 'qux']

调用re.split('\s+',text)时，正则表达式会先被编译，然后再在text上调用其split方法。你可以用re.compile自己编译regex以得到一个可重用的regex对象：

  1. In [225]: regex = re.compile('\s+')
  2.  
  3. In [226]: regex.split(text)
  4. Out[226]: ['foo', 'bar', 'baz', 'qux']

如果只希望得到匹配regex的所有模式，则可以使用findall方法：

  1. In [227]: regex.findall(text)
  2. Out[227]: ['       ', '\t ', '  \t']

注意： 如果想避免正则表达式中不需要的转义（\），则可以使用原始字符串字面量如r'C:\x'（也可以编写其等价式'C:\x'）。

如果打算对许多字符串应用同一条正则表达式，强烈建议通过re.compile创建regex对象。这样将可以节省大量的CPU时间。

match和search跟findall功能类似。findall返回的是字符串中所有的匹配项，而search则只返回第一个匹配项。match更加严格，它只匹配字符串的首部。来看一个小例子，假设我们有一段文本以及一条能够识别大部分电子邮件地址的正则表达式：

  1. text = """Dave dave@google.com
  2. Steve steve@gmail.com
  3. Rob rob@gmail.com
  4. Ryan ryan@yahoo.com
  5. """
  6. pattern = r'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}'
  7.  
  8. # re.IGNORECASE的作用是使正则表达式对大小写不敏感
  9. regex = re.compile(pattern, flags=re.IGNORECASE)

对text使用findall将得到一组电子邮件地址：

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

search返回的是文本中第一个电子邮件地址（以特殊的匹配项对象形式返回）。对于上面那个regex，匹配项对象只能告诉我们模式在原字符串中的起始和结束位置：

  1. In [230]: m = regex.search(text)
  2.  
  3. In [231]: m
  4. Out[231]: <_sre.SRE_Match at 0x10a05de00>
  5.  
  6. In [232]: text[m.start():m.end()]
  7. Out[232]: 'dave@google.com'

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

  1. In [233]: print regex.match(text)
  2. None

另外还有一个sub方法，它会将匹配到的模式替换为指定字符串，并返回所得到的新字符串：

  1. In [234]: print regex.sub('REDACTED', text)
  2. Dave REDACTED
  3. Steve REDACTED
  4. Rob REDACTED
  5. Ryan REDACTED

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

  1. In [235]: pattern = r'([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})'
  2.  
  3. In [236]: regex = re.compile(pattern, flags=re.IGNORECASE)

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

  1. In [237]: m = regex.match('wesm@bright.net')
  2.  
  3. In [238]: m.groups()
  4. Out[238]: ('wesm', 'bright', 'net')

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

  1. In [239]: regex.findall(text)
  2. Out[239]:
  3. [('dave', 'google', 'com'),
  4.  ('steve', 'gmail', 'com'),
  5.  ('rob', 'gmail', 'com'),
  6.  ('ryan', 'yahoo', 'com')]

sub还能通过诸如\1、\2之类的特殊符号访问各匹配项中的分组：

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

Python中还有许多的正则表达式，但大部分都超出了本书的范围。为了给你一点感觉，我对上面那个电子邮件正则表达式做一点小变动：为各个匹配分组加上一个名称。

  1. regex = re.compile(r"""
  2.      (?P<username>[A-Z0-9._%+-]+)
  3.      @
  4.       (?P<domain>[A-Z0-9.-]+)
  5.      \.
  6.       (?P<suffix>[A-Z]{2,4})""", flags=re.IGNORECASE|re.VERBOSE)

由这种正则表达式所产生的匹配项对象可以得到一个简单易用的带有分组名称的字典：

  1. In [242]: m = regex.match('wesm@bright.net')
  2.  
  3. In [243]: m.groupdict()
  4. Out[243]: {'domain': 'bright', 'suffix': 'net', 'username': 'wesm'}

前面提及的正则表达式的方法与说明如表7-4所示。

字符串操作 - 图3

译注12：这个表达式要么是字符串要么是函数返回值。

pandas中矢量化的字符串函数

清理待分析的散乱数据时，常常需要做一些字符串规整化工作。更为复杂的情况是，含有字符串的列有时还含有缺失数据：

  1. In [244]: data = {'Dave': 'dave@google.com', 'Steve': 'steve@gmail.com',
  2.      ...:         'Rob': 'rob@gmail.com', 'Wes': np.nan}
  3.  
  4. In [245]: data = Series(data)
  5.  
  6. In [246]: data
  7. Out[246]:
  8. Dave     dave@google.com
  9. Rob        rob@gmail.com
  10. Steve    steve@gmail.com
  11. Wes                  NaN
  12. In [247]: data.isnull()
  13. Out[247]:
  14. Dave     False
  15. Rob      False
  16. Steve    False
  17. Wes       True

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

  1. In [248]: data.str.contains('gmail')
  2. Out[248]:
  3. Dave     False
  4. Rob       True
  5. Steve     True
  6. Wes        NaN

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

  1. In [249]: pattern
  2. Out[249]: '([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\\.([A-Z]{2,4})'
  3.  
  4. In [250]: data.str.findall(pattern, flags=re.IGNORECASE)
  5. Out[250]:
  6. Dave     [('dave', 'google', 'com')]
  7. Rob        [('rob', 'gmail', 'com')]
  8. Steve    [('steve', 'gmail', 'com')]
  9. Wes                              NaN

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

  1. In [251]: matches = data.str.match(pattern, flags=re.IGNORECASE)
  2.  
  3. In [252]: matches
  4. Out[252]:
  5. Dave     ('dave', 'google', 'com')
  6. Rob        ('rob', 'gmail', 'com')
  7. Steve    ('steve', 'gmail', 'com')
  8. Wes                            NaN
  9.  
  10. In [253]: matches.str.get(1)
  11. Out[253]:
  12. Dave     google
  13. Rob       gmail
  14. Steve     gmail
  15. Wes         NaN
  16. In [254]: matches.str[0]
  17. Out[254]:
  18. Dave      dave
  19. Rob        rob
  20. Steve    steve
  21. Wes        NaN

你可以利用下面这种代码对字符串进行子串截取：

  1. In [255]: data.str[:5]
  2. Out[255]:
  3. Dave     dave@
  4. Rob      rob@g
  5. Steve    steve
  6. Wes        NaN

表7-5介绍了矢量化的字符串方法。

字符串操作 - 图4

字符串操作 - 图5

译注9：其实什么分隔符都行，原文有歧义。

译注11：别说一章，目前市面上专门介绍正则表达式的书非常多。