pandas 之 字符串处理

import numpy as np 
import pandas as pd

Python has long been a popular raw data manipulation language in part due to its ease of use for string and text processing.(Python非常流行的一个原因在于它对字符串处理提供了非常灵活的操作方式). Most text operations are made simple with string object's built-in methods. For more complex pattern matching and text manipulations, reqular expressions may be needed(对于非常复杂的字符串操作,正则还是非常必要的). pandas adds to the mix by enabling you to apply string and reqular expressions concisely(简明地) on whole arrays of data, additionally handling the annonyance(烦恼) of missing data.

字符串对象常用方法

In many string munging and scriptiong applications, built-in methods are sufficient(内置的方法就已够用). As a example, a comma-separated string can be broken into pieces with split:

val = 'a,b,    guido'

val.split(',')

['a', 'b', '    guido']

split is offen combined with strip to trim whitesplace(including line breaks): (split 通常和strip配合使用哦)

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

pieces

['a', 'b', 'guido']

These subtrings could be concatenated together with a two-colon delimiter using additon:

first, second, thrid = pieces  # 拆包

first + "::" + second + "::" + thrid

'a::b::guido'

But this isn't a practical(实际有效) generic mathod. A faster and more Pythonic way is to pass a list or tuple to the join method on the string "::".

'::'.join(pieces)

'a::b::guido'

Other methods are concerned with locating substrings. Using Python's in keyword is the best way to detect a substring, though index and find can also be used:

"guido" in val

True

val.index(',')  # 下标索引位置

1

val.find(":") # 返回第一次出现的下标, 没有则返回 -1

-1

Note the difference between find and index is that index raises an exception if the string isn't found (versus 相对于index的报错, find 返回 -1, 健壮性好)

val.index(':')

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-37-2c016e7367ac> in <module>
----> 1 val.index(':')


ValueError: substring not found

val.find(":")

Relatedly, count returns the number of occurrences of a particular substring:

val.count(',')

replace will substitute(替换) occurrences of one pattern for another. It is commonly used to delete patterns, too, by passing an empty string:

val

val.replace(',', ':')  # 是深拷贝, 创建新对象了哦

'a:b:    guido'

val  # 原来的没变哦

'a,b,    guido'

val.replace(',', '') # 替换为空

'ab    guido'

See Table 7-3 for a listing of some of Python's string methods.

Regular expressions can also be used with many of these operations, as you'll see.

Argument	Description
count	计数某元素出现的次数
endswith	Return True if string ends with suffix
startswith	判断是否以某元素结尾
join	字符串拼接
index	返回某元素第一次出现的下标, 没有则报错
find	返回某元素第一次出现的下标,没有则返回-1
rfind	从右边往左开始寻找
replace	替换某元素
strip	清除两侧空白符
rstrip	for each element
lstrip
split	分割
lower	小写
upper	大写
casefold	将字符转换为小写，并将任何特定于区域的变量字符组合转换为常见形式
ljust	调整字符距离
rjust

正则表达式

Regular expression provide a flexible way to search or match(often more complex) string patterns in text. A single expression, commonly called a regex, is a string formed(形成的) according to the regular expression language. Python's built-in re module is responsible for applying regular expressions to strings; I'll give a number of examples of its use here.

The art of writing regular expressions could be a chapter of its own and thus is outside the book's scope. There are many excellent tutorials and references available on the internet and in other books.

The re module functions fall into three categories:pattern matching, substitution, and splitting. Naturally these are all related; a regex describes a pattern to locate in the text, which can then be used for many purposes. Let's look at a simple example:
Suppose we want to split a string with a variable number of whitespace characters(tabs, spaces, and newlines). The regex describing one or more whitespace characters is "\s+":

import re 

text = "foo    bar\t  baz   \tqux"

re.split("\s+", text) # 按空白符分割

['foo', 'bar', 'baz', 'qux']

When you call re.split('\s+', text), the regular expression is first compiled, and then its split method method is called on the passed text. You can complie the regex yourself with re.compile forming a reusable regex object:

regex = re.compile('\s+')  # cj 编译模式在代码复用时挺好

regex.split(text)

['foo', 'bar', 'baz', 'qux']

If, instead(替换), you want to get a list of all patterns matching the regex, you can use the findall method:

regex.findall(text)  # cj,匹配所有满足要求的, 并返回列表

['    ', '\t  ', '   \t']

To avoid unwanted escaping with  in a regular expression, use raw string literals(原生字面符) like r'C:\x' instead of the equivalent 'C:\x'

Creating a regex object with re.complie is highly recommended if you intent to apply the same expression to many strings; doing so will save CPU cycles(周期)
(提高代码复用, 节省CPU空间)

match and search are closely related to findall. While findall returns all matches in a string, search returns only the first match. More rigidly(严格地), match only matches at the beginning of the string. As a less trivial(不重要地)example, let's consider a block of text and a regular expression capable(能干的) of identifying most email addresses:

text = """Dave [email protected]
Steve [email protected]
Rob [email protected]
Ryan [email protected]
"""

"匹配出所有邮箱"
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)

'匹配出所有邮箱'

Using findall on the text produces a list of the email addresses:

regex.findall(text)

['[email protected]', '[email protected]', '[email protected]', '[email protected]']

search returns a special match object for the first email address in the text. For the preceding regex, the match object can only tell us the start and end position of the pattern in the string:

m = regex.search(text) # 只返回第一个匹配到的结果
m  # 是一个Match对象

<_sre.SRE_Match object; span=(5, 20), match='[email protected]'>

text[m.start():m.end()]

'[email protected]'

regex.match returns None, as it only will mathch if the pattern occurs at the start of the string:

# 第一个参数必须是正则表达式, 没有匹配则None
print(regex.match(text)) 

None

Relatedly, sub will return a new string with occurrences of the pattern replaced by the a new string.

# 参数: pattern, replace_value, text, count
print(regex.sub('REDACTED', text)) 

Dave REDACTED
Steve REDACTED
Rob REDACTED
Ryan REDACTED

​

Suppose you wanted to find email addresses and simultaneously(同时地) segment each address into its three components(部分): username, domain name, and domain suffix. To do this, put parentheses around the parts of pattern to segment:

pattern = r'([a-z0-9+_.%-]+)@([a-z0-9+-._]+)\.([a-z0-9]{2,4})'  # () 用来分组

regex = re.compile(pattern, flags=re.IGNORECASE) 

A match object produced by this modified regex return a tuple of the pattern components with its groups method:

m = regex.match("[email protected]")

m.groups()

('wesm', 'bring', 'net')

findall returns a list of tuples when the pattern has groups:

regex.findall(text)  # 数据清洗非常有用啊,正则

[('dave', 'google', 'com'),
 ('steve', 'gmail', 'com'),
 ('rob', 'gmail', 'com'),
 ('ryan', 'yahoo', 'com')]

sub also has access to groups in each match using special symbols like \1 and \2. The symbol \1 correspons to the first matched group, \2 corresponds to the second, and so forth:

"感觉真的是数据清洗的利器"

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

​

There is much more to regular expression in Python, most of which is outside the book's scope, Table 7-4 provides a brief summary.

Argument	Description
findall	匹配所有满足条件的元素, 返回是个列表
finditer	Like findall, but returns an iterator
match	从头开始严格匹配, 一旦匹配到则返回match对象, 否则None
search	所有满足条件的元素从任意位置, 匹配放回match对象, 否则None
split	按正则表达式分割
sub, subn	替换匹配字串,返回新字串, \1, \2..分组显示等

批量字符串处理

Cleaning up a messy dataset for analysis often requires a lot of string munging and regularization. To complicate matters, a column containing strings will sometimes have missing data:

data = {'Dave': '[email protected]', 'Steve': '[email protected]',
 'Rob': '[email protected]', 'Wes': np.nan}

data = pd.Series(data)

data

Dave     [email protected]
Steve    [email protected]
Rob        [email protected]
Wes                  NaN
dtype: object

data.isnull()

Dave     False
Steve    False
Rob      False
Wes       True
dtype: bool

You can apply string and regular expression methods can be applied(passing a lambda or other function) to each value using data.map, but it will fail on the NA values(apply能传一个方法去处理去映射每个元素, 但缺失值就麻爪了). To cope with(处理)this, Series has array-oriented methods for string operations that skip NA values. These are accessed through Series's str attribute; for example, we could check whether each email address has 'gmail' in it with str.contains

data.str.contains("gmail")  # like 'in'

Dave     False
Steve     True
Rob       True
Wes        NaN
dtype: object

Regular expressions can be used, too, along with any re option like IGNORECASE:

pattern

'([a-z0-9+_.%-]+)@([a-z0-9+-._]+)\\.([a-z0-9]{2,4})'

data.str.findall(pattern, flags=re.IGNORECASE)  # 映射每个元素

Dave     [(dave, google, com)]
Steve    [(steve, gmail, com)]
Rob        [(rob, gmail, com)]
Wes                        NaN
dtype: object

There are a couple of(一对) ways to do vectorized element retrieval. Either use str.get or index into the str attribute:

matches = data.str.match(pattern, flags=re.IGNORECASE)

matches

Dave     True
Steve    True
Rob      True
Wes       NaN
dtype: object

To access elements in the embedded lists(列表嵌套), we can pass an index to either of these functions:

matches.str.get(1)

Dave    NaN
Steve   NaN
Rob     NaN
Wes     NaN
dtype: float64

matches.str[0]

Dave    NaN
Steve   NaN
Rob     NaN
Wes     NaN
dtype: float64

You can similarly slice strings using this syntax:

data.str[:5]

Dave     dave@
Steve    steve
Rob      rob@g
Wes        NaN
dtype: object

See Table 7-5 for more pandas string methods

• cat
• contains
• count
• extract 用正则表达式提取
• endswith
• startswith
• findall
• get index into each element
• isalnum 判断是否为字母or数字
• islaph
• isdecimal
• isdigit
• islower
• isupper
• isnumeric
• join
• len
• lower/ upper
• match
• pad Add whitespace to left, right or both sides of strings
• repeat
• replace
• slice
• split
• strip
• rstrip
• lstrip

小结

Effective data preparation can significantly improve productive by enabling you to spend more time analyzing data and less time getting it ready for analyingsis.
(能高效便捷进行数据清洗和预处理能让我们有更多的时间去分析问题而非一直在处理数据)
We have explored a number of tools in this chapter, but the coverage here is by no means comprehensive. In the next chapter, we will explore pandas's joining and grouping functionality.