字符串操作
Python有简单易用的字符串和文本处理功能，大部分文本运算都直接做成了字符串对象的内置方法。对于更为复杂的模式匹配和文本操作，则可能需要用到正则表达式。
字符串对象方法
以逗号分隔的字符串可以用split拆分成数段
In [4]: val='a,bc,c, gudio'
In [5]: val.split(',')
Out[5]: ['a', 'bc', 'c', ' gudio']
In [6]: val='a,bc ,c, gudio'
In [7]: val.split(',')
Out[7]: ['a', 'bc ', 'c', ' gudio']
split常常结合strip（用于修剪空白符（包括换行符））一起使用
In [8]: pieces=[x.strip() for x in val.split(',')]
In [9]: pieces
Out[9]: ['a', 'bc', 'c', 'gudio']
利用加法，可以将这些子字符串以双冒号分隔符的形式连接起来
In [13]: first,second,third,four=pieces
In [14]: first +'::'+ second +'::'+ third +'::'+four
Out[14]: 'a::bc::c::gudio'
向字符串"::"的join方法传入一个列表或元组
In [15]: '::'.join(pieces)
Out[15]: 'a::bc::c::gudio'
检测子串的最佳方式是利用Python的in关键字（还可以使用index和find）
In [16]: 'guido' in val
Out[16]: False
In [17]: 'gudio' in val
Out[17]: True
In [18]: val.index(',')
Out[18]: 1
In [19]: val.find(':')
Out[19]: -1
In [20]: val.find('bc')
Out[20]: 2
In [21]: val.find('c')
Out[21]: 3
In [22]: val.index('c')
Out[22]: 3
注意find和index的区别：如果找不到字符串，index将会引发一个异常（而不是返回－1）
In [23]: val.index(':')
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-23-280f8b2856ce> in <module>()
----> 1 val.index(':')
ValueError: substring not found
count函数，它可以返回指定子串的出现次数
In [24]: val.count(',')
Out[24]: 3
replace用于将指定模式替换为另一个模式。它也常常用于删除模式：传入空字符串
In [25]: val.replace(',','::')
Out[25]: 'a::bc ::c:: gudio'
In [26]: val.replace(',','')
Out[26]: 'abc c gudio'
In [27]: val
Out[27]: 'a,bc ,c, gudio'
In [28]: val.replace('c','m')
Out[28]: 'a,bm ,m, gudio'
In [29]: val.replace('bc','abcd')
Out[29]: 'a,abcd ,c, gudio'
字母转换为大写
In [30]: val.upper()
Out[30]: 'A,BC ,C, GUDIO'
Python内置的字符串方法如表7-3所示
正则表达式
正则表达式（通常称作regex）提供了一种灵活的在文本中搜索或匹配字符串模式的方式。正则表达式是根据正则表达式语言编写的字符串。Python内置的re模块负责对字符串应用正则表达式。
re模块的函数可以分为三个大类：模式匹配、替换以及拆分。当然，它们之间是相辅相成的。一个regex描述了需要在文本中定位的一个模式，它可以用于许多目的。我们先来看一个简单的例子：假设我想要拆分一个字符串，分隔符为数量不定的一组空白符（制表符、空格、换行符等）。描述一个或多个空白符的regex是\s+：
In [35]: import re
In [36]: text="foo bar\t baz \tqux"
In [37]: re.split('\s+',text)
Out[37]: ['foo', 'bar', 'baz', 'qux']
调用re.split('\s+',text)时，正则表达式会先被编译，然后再在text上调用其split方法。你可以用re.compile自己编译regex以得到一个可重用的regex对象
In [38]: regex=re.compile('\s+')
In [39]: regex.split(text)
Out[39]: ['foo', 'bar', 'baz', 'qux']
如果只希望得到匹配regex的所有模式，则可以使用findall方法
In [40]: regex.findall(text)
Out[40]: [' ', '\t ', ' \t']
注意： 如果想避免正则表达式中不需要的转义（\），则可以使用原始字符串字面量如r'C:\x'（也可以编写其等价式'C:\x'）。
如果打算对许多字符串应用同一条正则表达式，强烈建议通过re.compile创建regex对象。这样将可以节省大量的CPU时间。
match和search跟findall功能类似。findall返回的是字符串中所有的匹配项，而search则只返回第一个匹配项。match更加严格，它只匹配字符串的首部。来看一个小例子，假设我们有一段文本以及一条能够识别大部分电子邮件地址的正则表达式：
In [41]: text = """Dave dave@google.com
...: Steve steve@gmail.com
...: Rob rob@gmail.com
...: Ryan ryan@yahoo.com"""
In [42]: pattern = r'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}'
re.IGNORECASE的作用是使正则表达式对大小写不敏感
In [43]: regex=re.compile(pattern,flags=re.IGNORECASE)
对text使用findall将得到一组电子邮件地址
In [44]: regex.findall(text)
Out[44]: ['dave@google.com', 'steve@gmail.com', 'rob@gmail.com', 'ryan@yahoo.com']
search返回的是文本中第一个电子邮件地址（以特殊的匹配项对象形式返回）。对于上面那个regex，匹配项对象只能告诉我们模式在原字符串中的起始和结束位置
In [45]: m=regex.search(text)
In [46]: m
Out[46]: <_sre.SRE_Match object; span=(5, 20), match='dave@google.com'>
regex.match则将返回None，因为它只匹配出现在字符串开头的模式
In [47]: print(regex.match(text))
None
sub方法，它会将匹配到的模式替换为指定字符串，并返回所得到的新字符串
In [48]: print(regex.sub('REDACTED',text))
Dave REDACTED
Steve REDACTED
Rob REDACTED
Ryan REDACTED
假设你不仅想要找出电子邮件地址，还想将各个地址分成3个部分：用户名、域名以及域后缀。要实现此功能，只需将待分段的模式的各部分用圆括号包起来即可
In [49]: pattern = r'([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})'
In [50]: regex = re.compile(pattern, flags=re.IGNORECASE)
由这种正则表达式所产生的匹配项对象，可以通过其groups方法返回一个由模式各段组成的元组
In [51]: m=regex.match('wesm@bright.net')
In [52]: m.groups()
Out[52]: ('wesm', 'bright', 'net')
对于带有分组功能的模式，findall会返回一个元组列表
In [53]: regex.findall(text)
Out[53]:
[('dave', 'google', 'com'),
('steve', 'gmail', 'com'),
('rob', 'gmail', 'com'),
('ryan', 'yahoo', 'com')]
sub还能通过诸如\1、\2之类的特殊符号访问各匹配项中的分组
In [54]: 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
对上面那个电子邮件正则表达式做一点小变动：为各个匹配分组加上一个名称
In [55]: regex = re.compile(r"""(?P<username>[A-Z0-9._%+-]+)
...: @(?P<domain>[A-Z0-9.-]+)\.
...: (?P<suffix>[A-Z]{2,4})""",
...: flags=re.IGNORECASE|re.VERBOSE)
由这种正则表达式所产生的匹配项对象可以得到一个简单易用的带有分组名称的字典
In [56]: m = regex.match('wesm@bright.net')
In [57]: m
Out[57]: <_sre.SRE_Match object; span=(0, 15), match='wesm@bright.net'>
In [58]: m.groupdict()
Out[58]: {'domain': 'bright', 'suffix': 'net', 'username': 'wesm'}
正则表达式的方法与说明如表所示
pandas中矢量化的字符串函数
含有字符串的列有时还含有缺失数据，清理待分析的散乱数据时，常常需要做一些字符串规整化工作。
In [59]: data = {'Dave': 'dave@google.com', 'Steve': 'steve@gmail.com',
...: 'Rob': 'rob@gmail.com', 'Wes': np.nan}
In [60]: data=Series(data)
In [61]: data
Out[61]:
Dave dave@google.com
Rob rob@gmail.com
Steve steve@gmail.com
Wes NaN
dtype: object
In [62]: data.isnull()
Out[62]:
Dave False
Rob False
Steve False
Wes True
dtype: bool
通过data.map，所有字符串和正则表达式方法都能被应用于（传入lambda表达式或其他函数）各个值，但是如果存在NA就会报错。为了解决这个问题，Series有一些能够跳过NA值的字符串操作方法。通过Series的str属性即可访问这些方法。例如，我们可以通过str.contains检查各个电子邮件地址是否含有"gmail"
In [63]: data.str.contains('gmail')
Out[63]:
Dave False
Rob True
Steve True
Wes NaN
dtype: object
可以使用正则表达式，还可以加上任意re选项（如IGNORECASE）
In [64]: pattern
Out[64]: '([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\\.([A-Z]{2,4})'
In [65]: data.str.findall(pattern,flags=re.IGNORECASE)
Out[65]:
Dave [(dave, google, com)]
Rob [(rob, gmail, com)]
Steve [(steve, gmail, com)]
Wes NaN
dtype: object
有两个办法可以实现矢量化的元素获取操作：要么使用str.get，要么在str属性上使用索引
In [66]: matches=data.str.match(pattern,flags=re.IGNORECASE)
In [67]: matches
Out[67]:
Dave True
Rob True
Steve True
Wes NaN
dtype: object
以下的str.get()方法和str()方法结果和书上不同，可能是版本问题。
In [71]: matches.str.get(1)
Out[71]:
Dave NaN
Rob NaN
Steve NaN
Wes NaN
dtype: float64
In [72]: matches.str[0]
Out[72]:
Dave NaN
Rob NaN
Steve NaN
Wes NaN
dtype: float64
可以利用对字符串进行子串截取
In [73]: data.str[:5]
Out[73]:
Dave dave@
Rob rob@g
Steve steve
Wes NaN
dtype: object
表7-5介绍了矢量化的字符串方法
完成本章的练习了，接下来继续学习下章的可视化知识。
