• 7.3 字符串操作
    • 字符串对象方法
    • 正则表达式
    • pandas的矢量化字符串函数

    7.3 字符串操作

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

    字符串对象方法

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

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

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

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

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

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

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

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

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

    1. In [141]: 'guido' in val
    2. Out[141]: True
    4. In [142]: val.index(',')
    5. Out[142]: 1
    7. In [143]: val.find(':')
    8. Out[143]: -1

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

    1. In [144]: val.index(':')
    2. ---------------------------------------------------------------------------
    3. ValueError                                Traceback (most recent call last)
    4. <ipython-input-144-280f8b2856ce> in <module>()
    5. ----> 1 val.index(':')
    6. ValueError: substring not found

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

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

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

    1. In [146]: val.replace(',', '::')
    2. Out[146]: 'a::b::  guido'
    4. In [147]: val.replace(',', '')
    5. Out[147]: 'ab  guido'

    表7-3列出了Python内置的字符串方法。

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

    7.3 字符串操作 - 图1

    7.3 字符串操作 - 图2

    casefold 将字符转换为小写，并将任何特定区域的变量字符组合转换成一个通用的可比较形式。

    正则表达式

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

    笔记：正则表达式的编写技巧可以自成一章，超出了本书的范围。从网上和其它书可以找到许多非常不错的教程和参考资料。

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

    1. In [148]: import re
    3. In [149]: text = "foo    bar\t baz  \tqux"
    5. In [150]: re.split('\s+', text)
    6. Out[150]: ['foo', 'bar', 'baz', 'qux']

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

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

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

    1. In [153]: regex.findall(text)
    2. Out[153]: ['    ', '\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}'
    8. # re.IGNORECASE makes the regex case-insensitive
    9. regex = re.compile(pattern, flags=re.IGNORECASE)

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

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

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

    1. In [156]: m = regex.search(text)
    3. In [157]: m
    4. Out[157]: <_sre.SRE_Match object; span=(5, 20), match='dave@google.com'>
    6. In [158]: text[m.start():m.end()]
    7. Out[158]: 'dave@google.com'

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

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

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

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

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

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

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

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

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

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

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

    1. In [166]: 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中还有许多的正则表达式，但大部分都超出了本书的范围。表7-4是一个简要概括。

    7.3 字符串操作 - 图3

    pandas的矢量化字符串函数

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

    1. In [167]: data = {'Dave': 'dave@google.com', 'Steve': 'steve@gmail.com',
    2.    .....:         'Rob': 'rob@gmail.com', 'Wes': np.nan}
    4. In [168]: data = pd.Series(data)
    6. In [169]: data
    7. Out[169]: 
    8. Dave     dave@google.com
    9. Rob        rob@gmail.com
    10. Steve    steve@gmail.com
    11. Wes                  NaN
    12. dtype: object
    14. In [170]: data.isnull()
    15. Out[170]: 
    16. Dave     False
    17. Rob      False
    18. Steve    False
    19. Wes       True
    20. dtype: bool

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

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

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

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

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

    1. In [174]: matches = data.str.match(pattern, flags=re.IGNORECASE)
    3. In [175]: matches
    4. Out[175]: 
    5. Dave     True
    6. Rob      True
    7. Steve    True
    8. Wes       NaN
    9. dtype: object

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

    1. In [176]: matches.str.get(1)
    2. Out[176]: 
    3. Dave    NaN
    4. Rob     NaN
    5. Steve   NaN
    6. Wes     NaN
    7. dtype: float64
    9. In [177]: matches.str[0]
    10. Out[177]: 
    11. Dave    NaN
    12. Rob     NaN
    13. Steve   NaN
    14. Wes     NaN
    15. dtype: float64

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

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

    表7-5介绍了更多的pandas字符串方法。

    表7-5 部分矢量化字符串方法