子字符串检索：find（）和re正则匹配

 一、find（）方法

1、基本语法

S.find(sub， start=None, end=None) -> int

参数解释：
S：被检索的字符串
sub：子字符串
start：在S中检索的起始位置
end：在S中检索的结束位置
返回结果是int类型

2.用法示例

line = "this is fish."
print line.find('fish')
#8
#<type 'int'>

返回int类型的数字8，fish最先出现在line下标为8的时候。

line = "this is fish."
print line.find('sss')
print type(line.find('sss'))
#-1
#<type 'int'>

当检索的子字符串不在line中，则返回int类型的-1.

line = "this is fish."
print line.find('is')
#2

为什么结果是2，而不是5.

因为find方法只会返回第一个检索的到子字符串，也就是“this”中的“is”。

line中一共有三个包含“is”的子串，如何全部找出，我们可以用re模块找子字符串。

 

二、re模块（正则表达式）

1、匹配规则

正则表达式匹配规则

字符    功能
.       匹配任意1个字符(除了\n)
[]      匹配[]中列举的一个字符
\d      匹配数字,也就是0-9
\D      匹配非数字,也就是匹配不是数字的字符,\d取反
\s      匹配空白符,也就是空格\tab
\S      匹配非空白符,\s取反
\w      陪陪单词字符, a-z, A-Z, 0-9, _
\W      匹配非单词字符, \w取反
*       匹配前一个字符出现0次到无限次
+       匹配前一个字符出现1次到无限次
?       匹配前一个字符出现1次或者0次
{m}     匹配前一个字符出现m次
{m,}    匹配前一个字符至少出现m次
{m,n}   匹配前一个字符出现m到n次
^或\A   匹配字符串的开头
$或\Z   匹配字符串的结尾
\b      匹配\w和\W之间，即匹配单词边界
\B      \b取反

2、常用函数

(1)

re.compile(pattern, flags=0)

#pattern：正则表达字符串，也就是经过正则表达的子串
#flags：编译标志位，用于修改正则表达式的匹配方式

执行后，返回一个正则匹配的对象。

关于flags，常用的 标志

标志	    含义
re.S    (DOTALL)使.匹配包括换行在内的所有字符
re.I    （IGNORECASE）使匹配对大小写不敏感
re.L    （LOCALE）做本地化识别（locale-aware)匹配，法语等
re.M    (MULTILINE)多行匹配，影响^和$
re.X    (VERBOSE)该标志通过给予更灵活的格式以便将正则表达式写得更易于理解
re.U    根据Unicode字符集解析字符，这个标志影响\w,\W,\b,\B

比如，利用falgs忽略子串大小写

import re
line = "this is fish."
patt = re.compile("fish")
print patt.search(line).group()
#"fish"
patt1 = re.compile("FISH", re.I)
print patt1.search(line).group()
#"fish"

 (2)

re.match(pattern, string, flags=0)

pattern: 正则模式的子串
string：父串
flags：编译标志位

从父串的第一个字符开始匹配。如果匹配不到返回None。

import re
line = "this is fish."
print re.match("fish",line)
#None
print re.match("this",line).group()
#"this"

 (3)

re.search(pattern, string, flags=0)

pattern: 正则模式的子串
string：父串
flags：编译标志位

若string中包含pattern子串，则返回Match对象，否则返回None.

如果string中有多个pattern子串，只匹配第一个。

import re
line = "this is fish."
print re.search("is",line).group()
#"is"
print re.search("is",line).start()
#2

结果只返回一个，也就是第一个“is”。

 (4)

re.findall(pattern, string, flags=0)

pattern: 正则模式的子串
string：父串
flags：编译标志位

匹配string中所有的子串，返回结果是一个列表。

import re
line = "this is fish."
print re.findall("is",line)
#['is', 'is', 'is']

 (5)

re.finditer(pattern, string, flags=0)

pattern: 正则模式的子串
string：父串
flags：编译标志位

返回一个匹配对象的迭代器。

import re
line = "this is fish."
iter = re.finditer("is", line)
for i in iter:
    print i.group()
    print i.span()
# is
# (2, 4)
# is
# (5, 7)
# is
# (9, 11)

 (6)

re.split(pattern, string, maxsplit=0, flags=0)

pattern: 正则模式的子串
string：父串
maxsplit：最大分裂次数
flags：编译标志位

pattern子串将string分裂成多个字符串，结果以列表形式返回。

import re
line = "this is fish."
print re.split("\s+", line, maxsplit=1)
# ['this', 'is fish.']
print re.split("\s+", line)
# ['this', 'is', 'fish.']

 (7)

re.sub(pattern, repl, string, count=0, flags=0)

pattern: 正则模式的子串
string：父串
count：替换次数
flags：编译标志位

将pattern子串替换成repl子串，返回的结果是替换后的字符换。

import re
line = "this is fish."
print re.sub('\s+', '{}', line)
# this{}is{}fish.
print re.sub('\s+', '{}', line, count=1)
# this{}is fish.

当coun=0，表示全部替换。

 

结合以上两种检索子串的方法，当要查看父串中所有的子串的位置，可以用re.finditer（）函数来实现。