logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

利用Python进行数据分析 数据规整化：清理 转换 合并 重塑(七)(5)

 powerbaby 2016-03-16

1、字符串操作

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

2、字符串对象方法

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

1.In [81]: val = 'a,b, guido'
2. 
3.In [82]: val.split(',')
4.Out[82]: ['a', 'b', ' guido']
split常常结合strip（用于修剪空白符（包括换行符））一起使用：

1.In [83]: pieces = [x.strip() for x in val.split(',')]
2. 
3.In [84]: pieces
4.Out[84]: ['a', 'b', 'guido']
利用加法，可以将这些子字符串以双冒号分隔符的形式连接起来：

1.In [88]: first, second, third = pieces
2. 
3.In [89]: first + '::' + second + '::' + third
4.Out[89]: 'a::b::guido'
但这种方式并不是很实用。一种更快更符合Python风格的方式是，向字符串“::”的join方法传入一个列表或元组：

1.In [90]: '::'.join(pieces)
2.Out[90]: 'a::b::guido'
另一类方法关注的是子串定位。检测子串的最佳方式是利用Python的in关键字（当然还可以使用index和find）：

1.In [92]: 'guido' in val
2.Out[92]: True
3. 
4.In [93]: val.index(',')
5.Out[93]: 1
6. 
7.In [95]: val.find(':')
8.Out[95]: -1
注意find和index的区别：如果找不到字符串，index将会引发一个异常（而不是返回-1）：

1.In [96]: val.index(':')
2.---------------------------------------------------------------------------
3.ValueError                                Traceback (most recent call last)
4./home/wss/program/python/<ipython-input-96-280f8b2856ce> in <module>()
5.----> 1 val.index(':')
6. 
7.ValueError: substring not found
此外还有一个count函数，它可以返回指定子串的出现次数：

1.In [97]: val.count(',')
2.Out[97]: 2
replace用于将指定模式替换为另一个模式。它也常常用于删除模式：传入空字符串。

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

说明：

这些运算大部分都能使用正则表达式实现。

3、正则表达式

正则表达式（regex）提供了一种灵活的在文本中搜索或匹配字符串模式的方式。正则表达式是根据正则表达式语言编写的字符串。Python内置的re模块负责对字符串应用正则表达式。

推荐书籍：《Learn Regex The Hard Way》

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

1.In [100]: import re
2. 
3.In [101]: text = "foo bar\t baz \tqux"
4. 
5.In [102]: re.split('\s+', text)
6.Out[102]: ['foo', 'bar', 'baz', 'qux']
调用re.split('\s+', text)时，正则表达式会先被编译，然后再在text上调用其split方法。你可以用re.compile自己编译regex以得到一个可重用的regex对象：

1.In [103]: regex = re.compile('\s+')
2. 
3.In [104]: regex.split(text)
4.Out[104]: ['foo', 'bar', 'baz', 'qux']
如果只希望得到匹配regex的所有模式，则可以使用findall方法：
1.In [105]: regex.findall(text)
2.Out[105]: [' ', '\t ', ' \t']

注意：

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

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

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

01.In [106]: text = """Dave dave@google.com
02......:           Steve steve@gmail.com
03......:           Rob rob@gmail.com
04......:           Ryan ryan@yahoo.com
05......:        """
06. 
07.In [107]: pattern = r'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}'
08. 
09.In [108]: # re.IGNORECASE的作用是使用正则表达式对大小写不敏感
10. 
11.In [109]: regex = re.compile(pattern, flags=re.IGNORECASE)
对text使用findall将得到一组电子邮件地址：

1.In [116]: regex.findall(text)
2.Out[116]: ['dave@google.com', 'steve@gmail.com', 'rob@gmail.com', 'ryan@yahoo.com']
search返回的是文本中第一个电子邮件地址（以特殊的匹配项对象形式返回）。对于上面那个regex，匹配项对象只能告诉我们模式在原字符串中的起始和结束位置：

1.In [117]: m = regex.search(text)
2. 
3.In [118]: m
4.Out[118]: <_sre.SRE_Match at 0x9dc81e0>
5. 
6.In [119]: text[m.start():m.end()]
7.Out[119]: 'dave@google.com'
regex.match则将返回None，因为它只匹配出现在字符串开头的模式：

1.In [120]: print regex.match(text)
2.None
另外还有一个sub方法，它会将匹配到的模式替换为指定字符串，并返回所得到的新字符串：

1.In [121]: print regex.sub('REDACTED', text)
2.Dave REDACTED
3.Steve REDACTED
4.Rob REDACTED
5.Ryan REDACTED
假设你不仅想要找出电子邮件地址，还想将各个地址分成3个部分：用户名、域名以及域后缀。要实现此功能，只需将待分段的模式的各部分用圆括号包起来即可：

1.In [122]: pattern = r'([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})'
2. 
3.In [123]: regex = re.compile(pattern, flags=re.IGNORECASE)
由这种正则表达式所产生的匹配项对象，可以通过其groups方法返回一个由模式各段组成的元组：

1.In [124]: m = regex.match('wesm@bright.net')
2. 
3.In [125]: m.groups()
4.Out[125]: ('wesm', 'bright', 'net')
对于带有分组功能的模块，findall会返回一个元组列表：

1.In [126]: regex.findall(text)
2.Out[126]:
3.[('dave', 'google', 'com'),
4.('steve', 'gmail', 'com'),
5.('rob', 'gmail', 'com'),
6.('ryan', 'yahoo', 'com')]
sub还能通过诸如\1、\2之类的特殊符号访问各匹配项中的分组：

1.In [127]: 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
对上面那个电子邮件正则表达式做一点小变动：为各个匹配分组加上一个名称。如下所示：

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 [128]: m = regex.match('wesm@bright.net')
2. 
3.In [129]: m.groupdict()
4.Out[129]: {'domain': 'bright', 'suffix': 'net', 'username': 'wesm'}

4、pandas中矢量化的字符串函数

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

01.In [1]: data = {'Dave': 'dave@google.com', 'Steve': 'steve@gmail.com',
02....:         'Rob': 'rob@gmail.com', 'Wes': np.nan}
03. 
04.In [2]: data = pd.Series(data)
05. 
06.In [3]: data
07.Out[3]:
08.Dave   dave@google.com
09.Rob      rob@gmail.com
10.Steve  steve@gmail.com
11.Wes                NaN
12. 
13.In [4]: data.isnull()
14.Out[4]:
15.Dave   False
16.Rob    False
17.Steve  False
18.Wes     True
通过data.map，所有字符串和正则表达式方法都能被应用于（传入lambda表达式或其他函数）各个值，但是如果存在NA就会报错。为了解决这个问题，Series有一些能够跳过NA值的字符串操作方法。通过Series的str属性即可访问这些方法。例如，我们可以通过str.contains检查各个电子邮件地址是否含有“gmail”：

1.In [5]: data.str.contains('gmail')
2.Out[5]: 
3.Dave   False
4.Rob     True
5.Steve   True
6.Wes      NaN
这里也可以使用正则表达式，还可以加上任意re选项（如IGNORECASE）：

01.In [6]: pattern
02.Out[6]: '([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\\.([A-Z]{2,4})'
03. 
04.In [7]: data.str.findall(pattern, flags=re.IGNORECASE)
05.Out[7]: 
06.Dave   [('dave', 'google', 'com')]
07.Rob    [('rob', 'gmail', 'com')]
08.Steve  [('steve', 'gmail', 'com')]
09.Wes    NaN
有两个办法可以实现矢量化的元素获取操作：要么使用str.get，要么在str属性上使用索引。

01.In [8]: matches = data.str.match(pattern, flags=re.IGNORECASE)
02. 
03.In [9]: matches
04.Out[9]:
05.Dave  ('dave', 'google', 'com')
06.Rob     ('rob', 'gmail', 'com')
07.Steve ('steve', 'gmail', 'com')
08.Wes                         NaN
09. 
10.In [10]: matches.str.get(1)
11.Out[10]:
12.Dave    google
13.Rob      gmail
14.Steve    gmail
15.Wes        NaN
16. 
17.In [11]: matches.str[0]
18.Out[11]:
19.Dave    dave
20.Rob      rob
21.Steve  steve
22.Wes      NaN
你可以利用下面这种代码对字符串进行子串截取：

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

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： powerbaby > 《DataFrame》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多