Python之re模块 —— 正则表达式操作,pythonre

这个模块提供了与 Perl
相似l的正则表达式匹配操作。Unicode字符串也同样适用。

 

正则表达式使用反斜杠” \
“来代表特殊形式或用作转义字符,这里跟Python的语法冲突,因此,Python用” \\\\ “表示正则表达式中的”
\ “,因为正则表达式中如果要匹配” \ “,需要用\来转义,变成” \\
“,而Python语法中又需要对字符串中每一个\进行转义,所以就变成了” \\\\ “。

 

上面的写法是不是觉得很麻烦,为了使正则表达式具有更好的可读性,Python特别设计了原始字符串(raw
string),需要提醒你的是,在写文件路径的时候就不要使用raw
string了,这里存在陷阱。raw string就是用’r’作为字符串的前缀,如
r”\n”:表示两个字符”\”和”n”,而不是换行符了。Python中写正则表达式时推荐使用这种形式。

 

绝大多数正则表达式操作与 模块级函数或RegexObject方法
一样都能达到同样的目的。而且不需要你一开始就编译正则表达式对象,但是不能使用一些实用的微调参数。

 

这个模块提供了与 Perl
相似l的正则表达式匹配操作。Unicode字符串也同样适用。

Python的re模块正则表达式操作,pythonre

这个模块提供了与 Perl
相似l的正则表达式匹配操作。Unicode字符串也同样适用。

正则表达式使用反斜杠” \
“来代表特殊形式或用作转义字符,这里跟Python的语法冲突,因此,Python用”
\\\\ “表示正则表达式中的” \ “,因为正则表达式中如果要匹配” \
“,需要用\来转义,变成” \\
“,而Python语法中又需要对字符串中每一个\进行转义,所以就变成了”
\\\\ “。

上面的写法是不是觉得很麻烦,为了使正则表达式具有更好的可读性,Python特别设计了原始字符串(raw
string),需要提醒你的是,在写文件路径的时候就不要使用raw
string了,这里存在陷阱。raw string就是用’r’作为字符串的前缀,如
r”\n”:表示两个字符”\”和”n”,而不是换行符了。Python中写正则表达式时推荐使用这种形式。

绝大多数正则表达式操作与 模块级函数或RegexObject方法
一样都能达到同样的目的。而且不需要你一开始就编译正则表达式对象,但是不能使用一些实用的微调参数。

1.正则表达式语法

为了节省篇幅,这里不再叙述了。

2.martch和search的区别

Python提供了两种不同的原始操作:match和search。match是从字符串的起点开始做匹配,而search(perl默认)是从字符串做任意匹配。

注意:当正则表达式是’ ^
‘开头时,match与search是相同的。match只有当且仅当被匹配的字符串开头就能匹配
或 从pos参数的位置开始就能匹配 时才会成功。如下:

>>> import re
>>> re.match(“c”, “abcdef”)
>>> re.search(“c”,”abcdef”)
<_sre.SRE_Match object at 0x00A9A988>
>>> re.match(“c”, “cabcdef”)
<_sre.SRE_Match object at 0x00A9AB80>
>>> re.search(“c”,”cabcdef”)
<_sre.SRE_Match object at 0x00AF1720>
>>> patterm = re.compile(“c”)
>>> patterm.match(“abcdef”)
>>> patterm.match(“abcdef”,1)
>>> patterm.match(“abcdef”,2)
<_sre.SRE_Match object at 0x00A9AB80>

3.模块内容

re.compile(pattern, flags=0)

编译正则表达式,返回RegexObject对象,然后可以通过RegexObject对象调用match()和search()方法。

prog = re.compile(pattern)
result = prog.match(string)

result = re.match(pattern, string)

是等价的。

第一种方式能实现正则表达式的重用。

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

在字符串中查找,是否能匹配正则表达式。返回_sre.SRE_Match对象,如果不能匹配返回None。

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

字符串的开头是否能匹配正则表达式。返回_sre.SRE_Match对象,如果不能匹配返回None。

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

通过正则表达式将字符串分离。如果用括号将正则表达式括起来,那么匹配的字符串也会被列入到list中返回。maxsplit是分离的次数,maxsplit=1分离一次,默认为0,不限制次数。

>>> re.split(‘\W+’, ‘Words, words, words.’)
[‘Words’, ‘words’, ‘words’, ”]
>>> re.split(‘(\W+)’, ‘Words, words, words.’)
[‘Words’, ‘, ‘, ‘words’, ‘, ‘, ‘words’, ‘.’, ”]
>>> re.split(‘\W+’, ‘Words, words, words.’, 1)
[‘Words’, ‘words, words.’]
>>> re.split(‘[a-f]+’, ‘0a3B9’, flags=re.IGNORECASE)

注意:我使用的Python是2.6,查看源代码发现split()并没有flags的参数,2.7才增加。这种问题我发现不止一次了,官方的文档
跟 源码不一致的现象,如果发现异常,应该去源码中找找原因。

如果在字符串的开始或结尾就匹配,返回的list将会以空串开始或结尾。

>>> re.split(‘(\W+)’, ‘…words, words…’)
[”, ‘…’, ‘words’, ‘, ‘, ‘words’, ‘…’, ”]

如果字符串不能匹配,将会返回整个字符串的list。

>>> re.split(“a”,”bbb”)
[‘bbb’]

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

找到 RE
匹配的所有子串,并把它们作为一个列表返回。这个匹配是从左到右有序地返回。如果无匹配,返回空列表。

>>> re.findall(“a”,”bcdef”)
[]

>>> re.findall(r”\d+”,”12a32bc43jf3″)
[’12’, ’32’, ’43’, ‘3’]

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

找到 RE
匹配的所有子串,并把它们作为一个迭代器返回。这个匹配是从左到右有序地返回。如果无匹配,返回空列表。

>>> it = re.finditer(r”\d+”,”12a32bc43jf3″)
>>> for match in it:
print match.group()

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

找到 RE 匹配的所有子串,并将其用一个不同的字符串替换。可选参数 count
是模式匹配後替换的最大次数;count 必须是非负整数。缺省值是 0
表示替换所有的匹配。如果无匹配,字符串将会无改变地返回。

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

与re.sub方法作用一样,但返回的是包含新字符串和替换执行次数的两元组。

re.escape(string)

对字符串中的非字母数字进行转义

re.purge()

清空缓存中的正则表达式

4.正则表达式对象

re.RegexObject

re.compile()返回RegexObject对象

re.MatchObject

group()返回被 RE 匹配的字符串

start()返回匹配开始的位置

end()返回匹配结束的位置

span()返回一个元组包含匹配 (开始,结束) 的位置

5.编译标志

编译标志让你可以修改正则表达式的一些运行方式。在 re
模块中标志可以使用两个名字,一个是全名如
IGNORECASE,一个是缩写,一字母形式如 I。(如果你熟悉 Perl
的模式修改,一字母形式使用同样的字母;例如 re.VERBOSE的缩写形式是
re.X。)多个标志可以通过按位 OR-ing 它们来指定。如 re.I | re.M 被设置成
I 和 M 标志:

I
IGNORECASE

使匹配对大小写不敏感;字符类和字符串匹配字母时忽略大小写。举个例子,[A-Z]也可以匹配小写字母,Spam
可以匹配 “Spam”, “spam”, 或 “spAM”。这个小写字母并不考虑当前位置。

L
LOCALE

影响 “w, “W, “b, 和 “B,这取决于当前的本地化设置。

locales 是 C
语言库中的一项功能,是用来为需要考虑不同语言的编程提供帮助的。举个例子,如果你正在处理法文文本,你想用
“w+ 来匹配文字,但 “w 只匹配字符类 [A-Za-z];它并不能匹配 “é” 或
“?”。如果你的系统配置适当且本地化设置为法语,那么内部的 C 函数将告诉程序
“é” 也应该被认为是一个字母。当在编译正则表达式时使用 LOCALE
标志会得到用这些 C 函数来处理 “w
後的编译对象;这会更慢,但也会象你希望的那样可以用 “w+
来匹配法文文本。

M
MULTILINE

(此时 ^ 和 $ 不会被解释; 它们将在 4.1 节被介绍.)

使用 “^” 只匹配字符串的开始,而 $
则只匹配字符串的结尾和直接在换行前(如果有的话)的字符串结尾。当本标志指定後,
“^” 匹配字符串的开始和字符串中每行的开始。同样的, $
元字符匹配字符串结尾和字符串中每行的结尾(直接在每个换行之前)。

S
DOTALL

使 “.” 特殊字符完全匹配任何字符,包括换行;没有这个标志, “.”
匹配除了换行外的任何字符。

X
VERBOSE

该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。当该标志被指定时,在
RE
字符串中的空白符被忽略,除非该空白符在字符类中或在反斜杠之後;这可以让你更清晰地组织和缩进
RE。它也可以允许你将注释写入 RE,这些注释会被引擎忽略;注释用 “#”号
来标识,不过该符号不能在字符串或反斜杠之後。

最后:如果能用字符串的方法,就不要选择正则表达式,因为字符串方法更简单快速。

这个模块提供了与 Perl
相似l的正则表达式匹配操作。Unicode字符串也同样适用。
正则表达式使用反斜…

 

1.正则表达式语法

        为了节省篇幅,这里不再叙述了。

 

 

这个模块提供了与 Perl
相似l的正则表达式匹配操作。Unicode字符串也同样适用。

2.martch和search的区别

       
Python提供了两种不同的原始操作:match和search。match是从字符串的起点开始做匹配,而search(perl默认)是从字符串做任意匹配。

 

        注意:当正则表达式是’ ^
‘开头时,match与search是相同的。match只有当且仅当被匹配的字符串开头就能匹配
或 从pos参数的位置开始就能匹配 时才会成功。如下:

>>> import re 
>>> re.match(“c”, “abcdef”) 
>>> re.search(“c”,”abcdef”) 
<_sre.SRE_Match object at 0x00A9A988>

>>> re.match(“c”, “cabcdef”) 
<_sre.SRE_Match object at 0x00A9AB80>

>>> re.search(“c”,”cabcdef”) 
<_sre.SRE_Match object at 0x00AF1720>

>>> patterm = re.compile(“c”) 
>>> patterm.match(“abcdef”) 
>>> patterm.match(“abcdef”,1) 
>>> patterm.match(“abcdef”,2) 
<_sre.SRE_Match object at 0x00A9AB80>

正则表达式使用反斜杠” \
“来代表特殊形式或用作转义字符,这里跟Python的语法冲突,因此,Python用” \\\\ “表示正则表达式中的”
\ “,因为正则表达式中如果要匹配” \ “,需要用\来转义,变成” \\
“,而Python语法中又需要对字符串中每一个\进行转义,所以就变成了” \\\\ “。

 

3.模块内容

 

正则表达式使用反斜杠” \
“来代表特殊形式或用作转义字符,这里跟Python的语法冲突,因此,Python用”
\\\\ “表示正则表达式中的” \ “,因为正则表达式中如果要匹配” \
“,需要用\来转义,变成” \\
“,而Python语法中又需要对字符串中每一个\进行转义,所以就变成了”
\\\\ “。

re.compile(pattern, flags=0)

 

编译正则表达式,返回RegexObject对象,然后可以通过RegexObject对象调用match()和search()方法。

 

prog = re.compile(pattern)

result = prog.match(string)

result = re.match(pattern, string)

是等价的。

 

第一种方式能实现正则表达式的重用。

 

上面的写法是不是觉得很麻烦,为了使正则表达式具有更好的可读性,Python特别设计了原始字符串(raw
string),需要提醒你的是,在写文件路径的时候就不要使用raw
string了,这里存在陷阱。raw string就是用’r’作为字符串的前缀,如
r”\n”:表示两个字符”\”和”n”,而不是换行符了。Python中写正则表达式时推荐使用这种形式。

 

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

 

在字符串中查找,是否能匹配正则表达式。返回_sre.SRE_Match对象,如果不能匹配返回None。

 

 

上面的写法是不是觉得很麻烦,为了使正则表达式具有更好的可读性,Python特别设计了原始字符串(raw
string),需要提醒你的是,在写文件路径的时候就不要使用raw
string了,这里存在陷阱。raw string就是用’r’作为字符串的前缀,如
r”\n”:表示两个字符”\”和”n”,而不是换行符了。Python中写正则表达式时推荐使用这种形式。

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

 

字符串的开头是否能匹配正则表达式。返回_sre.SRE_Match对象,如果不能匹配返回None。

 

绝大多数正则表达式操作与 模块级函数或RegexObject方法
一样都能达到同样的目的。而且不需要你一开始就编译正则表达式对象,但是不能使用一些实用的微调参数。

 

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

 

通过正则表达式将字符串分离。如果用括号将正则表达式括起来,那么匹配的字符串也会被列入到list中返回。maxsplit是分离的次数,maxsplit=1分离一次,默认为0,不限制次数。

>>> re.split(‘\W+’, ‘Words, words, words.’) 
[‘Words’, ‘words’, ‘words’, ”] 
>>> re.split(‘(\W+)’, ‘Words, words, words.’) 
[‘Words’, ‘, ‘, ‘words’, ‘, ‘, ‘words’, ‘.’, ”] 
>>> re.split(‘\W+’, ‘Words, words, words.’, 1) 
[‘Words’, ‘words, words.’] 
>>> re.split(‘[a-f]+’, ‘0a3B9’, flags=re.IGNORECASE)

 

注意:我使用的Python是2.6,查看源代码发现split()并没有flags的参数,2.7才增加。这种问题我发现不止一次了,官方的文档
跟 源码不一致的现象,如果发现异常,应该去源码中找找原因。

 

如果在字符串的开始或结尾就匹配,返回的list将会以空串开始或结尾。

>>> re.split(‘(\W+)’, ‘…words, words…’) 
[”, ‘…’, ‘words’, ‘, ‘, ‘words’, ‘…’, ”]

 

如果字符串不能匹配,将会返回整个字符串的list。

>>> re.split(“a”,”bbb”) 
[‘bbb’]

 

 

绝大多数正则表达式操作与 模块级函数或RegexObject方法
一样都能达到同样的目的。而且不需要你一开始就编译正则表达式对象,但是不能使用一些实用的微调参数。

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

 

找到 RE
匹配的所有子串,并把它们作为一个列表返回。这个匹配是从左到右有序地返回。如果无匹配,返回空列表。

>>> re.findall(“a”,”bcdef”) 
[]

>>> re.findall(r”\d+”,”12a32bc43jf3″) 
[’12’, ’32’, ’43’, ‘3’]

 

1.正则表达式语法

        为了节省篇幅,这里不再叙述了。

 

 

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

 

找到 RE
匹配的所有子串,并把它们作为一个迭代器返回。这个匹配是从左到右有序地返回。如果无匹配,返回空列表。

>>> it = re.finditer(r”\d+”,”12a32bc43jf3″) 
>>> for match in it: 
              print match.group()

12 
32 
43 
3

 

2.martch和search的区别

       
Python提供了两种不同的原始操作:match和search。match是从字符串的起点开始做匹配,而search(perl默认)是从字符串做任意匹配。

 

        注意:当正则表达式是’ ^
‘开头时,match与search是相同的。match只有当且仅当被匹配的字符串开头就能匹配
或 从pos参数的位置开始就能匹配 时才会成功。如下:

>>> import re 
>>> re.match(“c”, “abcdef”) 
>>> re.search(“c”,”abcdef”) 
<_sre.SRE_Match object at 0x00A9A988>

>>> re.match(“c”, “cabcdef”) 
<_sre.SRE_Match object at 0x00A9AB80>

>>> re.search(“c”,”cabcdef”) 
<_sre.SRE_Match object at 0x00AF1720>

>>> patterm = re.compile(“c”) 
>>> patterm.match(“abcdef”) 
>>> patterm.match(“abcdef”,1) 
>>> patterm.match(“abcdef”,2) 
<_sre.SRE_Match object at 0x00A9AB80>

1.正则表达式语法

        为了节省篇幅,这里不再叙述了。

 

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

 

找到 RE 匹配的所有子串,并将其用一个不同的字符串替换。可选参数 count
是模式匹配後替换的最大次数;count 必须是非负整数。缺省值是 0
表示替换所有的匹配。如果无匹配,字符串将会无改变地返回。

 

3.模块内容

2.martch和search的区别

       
Python提供了两种不同的原始操作:match和search。match是从字符串的起点开始做匹配,而search(perl默认)是从字符串做任意匹配。

 

        注意:当正则表达式是’ ^
‘开头时,match与search是相同的。match只有当且仅当被匹配的字符串开头就能匹配
或 从pos参数的位置开始就能匹配 时才会成功。如下:

>>> import re
>>> re.match(“c”, “abcdef”)
>>> re.search(“c”,”abcdef”)
<_sre.SRE_Match object at 0x00A9A988>

>>> re.match(“c”, “cabcdef”)
<_sre.SRE_Match object at 0x00A9AB80>

>>> re.search(“c”,”cabcdef”)
<_sre.SRE_Match object at 0x00AF1720>

>>> patterm = re.compile(“c”)
>>> patterm.match(“abcdef”)
>>> patterm.match(“abcdef”,1)
>>> patterm.match(“abcdef”,2)
<_sre.SRE_Match object at 0x00A9AB80>

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

re.compile(pattern, flags=0)

 

编译正则表达式,返回RegexObject对象,然后可以通过RegexObject对象调用match()和search()方法。

 

prog = re.compile(pattern)

result = prog.match(string)

result = re.match(pattern, string)

是等价的。

 

第一种方式能实现正则表达式的重用。

例如:

  curLine = “/* 0 */     {“32_2.C_CRYSTAL”, &tPanelData[4],
 /*HA_AUO_320XVN02_C*/  &SpeakerData[0],  
/*SPEAKER_4E_CRYSTAL*/   POSITION_BOTTOMCENTER,  0, 1,         0,
KEYCOUNT_7,   &tKeypadDisply[0]},”

pat = re.compile(".*?(\d+).*\{.*\"((\d+)_.*)\",\s+&\w+\[\d+\],\s+/\*(.*?)\*/\s+&\w+\[\d+\],\s+/\*(.*)\*/.*")

list.append(pat.search(curLine).group(2))   #结果为:32_2.C_CRYSTAL
list.append(pat.search(curLine).group(3))   #  32
list.append(pat.search(curLine).group(4))   #  HA_AUO_320XVN02_C
list.append(pat.search(curLine).group(5))   #  SPEAKER_4E_CRYSTAL

 

3.模块内容

 

与re.sub方法作用一样,但返回的是包含新字符串和替换执行次数的两元组。

 

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

 

在字符串中查找,是否能匹配正则表达式。返回_sre.SRE_Match对象,如果不能匹配返回None。

所以这里要注意,如果匹配,返回的是一个SRE_Match对象,作用在这个对象的方法是可用的。

如果不匹配,返回None,不能调用方法。例如:

binDir = “%s” %re.search(“.*_(\d*xd*).*”,data).group(1)

系统报错如下:

AttributeError: ‘NoneType’
object has no attribute ‘group’

 报错的原因是,如果不匹配,re.search()返回的是None类型,就相当于None.group(1),None类型调用group方法是不正确的。

所以在调用re.search()的方法之前,要先判断re.search()返回的类型:

if re.search() is None:

re.compile(pattern, flags=0)

 

编译正则表达式,返回RegexObject对象,然后可以通过RegexObject对象调用match()和search()方法。

 

prog = re.compile(pattern)

result = prog.match(string)

result = re.match(pattern, string)

是等价的。

 

第一种方式能实现正则表达式的重用。

 

re.escape(string)

 

对字符串中的非字母数字进行转义

 

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

 

字符串的开头是否能匹配正则表达式。返回_sre.SRE_Match对象,如果不能匹配返回None。

 

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

 

在字符串中查找,是否能匹配正则表达式。返回_sre.SRE_Match对象,如果不能匹配返回None。

 

re.purge()

 

清空缓存中的正则表达式

 

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

 

通过正则表达式将字符串分离。如果用括号将正则表达式括起来,那么匹配的字符串也会被列入到list中返回。maxsplit是分离的次数,maxsplit=1分离一次,默认为0,不限制次数。

>>> re.split(‘\W+’, ‘Words, words, words.’) 
[‘Words’, ‘words’, ‘words’, ”] 
>>> re.split(‘(\W+)’, ‘Words, words, words.’) 
[‘Words’, ‘, ‘, ‘words’, ‘, ‘, ‘words’, ‘.’, ”] 
>>> re.split(‘\W+’, ‘Words, words, words.’, 1) 
[‘Words’, ‘words, words.’] 
>>> re.split(‘[a-f]+’, ‘0a3B9’, flags=re.IGNORECASE)

 

注意:我使用的Python是2.6,查看源代码发现split()并没有flags的参数,2.7才增加。这种问题我发现不止一次了,官方的文档
跟 源码不一致的现象,如果发现异常,应该去源码中找找原因。

 

如果在字符串的开始或结尾就匹配,返回的list将会以空串开始或结尾。

>>> re.split(‘(\W+)’, ‘…words, words…’) 
[”, ‘…’, ‘words’, ‘, ‘, ‘words’, ‘…’, ”]

 

如果字符串不能匹配,将会返回整个字符串的list。

>>> re.split(“a”,”bbb”) 
[‘bbb’]

 

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

 

字符串的开头是否能匹配正则表达式。返回_sre.SRE_Match对象,如果不能匹配返回None。

 

4.正则表达式对象

 

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

 

找到 RE
匹配的所有子串,并把它们作为一个列表返回。这个匹配是从左到右有序地返回。如果无匹配,返回空列表。

>>> re.findall(“a”,”bcdef”) 
[]

>>> re.findall(r”\d+”,”12a32bc43jf3″) 
[’12’, ’32’, ’43’, ‘3’]

 

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

 

通过正则表达式将字符串分离。如果用括号将正则表达式括起来,那么匹配的字符串也会被列入到list中返回。maxsplit是分离的次数,maxsplit=1分离一次,默认为0,不限制次数。

>>> re.split(‘\W+’, ‘Words, words, words.’)
[‘Words’, ‘words’, ‘words’, ”]
>>> re.split(‘(\W+)’, ‘Words, words, words.’)
[‘Words’, ‘, ‘, ‘words’, ‘, ‘, ‘words’, ‘.’, ”]
>>> re.split(‘\W+’, ‘Words, words, words.’, 1)
[‘Words’, ‘words, words.’]
>>> re.split(‘[a-f]+’, ‘0a3B9’, flags=re.IGNORECASE)

 

注意:我使用的Python是2.6,查看源代码发现split()并没有flags的参数,2.7才增加。这种问题我发现不止一次了,官方的文档
跟 源码不一致的现象,如果发现异常,应该去源码中找找原因。

 

如果在字符串的开始或结尾就匹配,返回的list将会以空串开始或结尾。

>>> re.split(‘(\W+)’, ‘…words, words…’)
[”, ‘…’, ‘words’, ‘, ‘, ‘words’, ‘…’, ”]

 

如果字符串不能匹配,将会返回整个字符串的list。

>>> re.split(“a”,”bbb”)
[‘bbb’]

 

re.RegexObject

 

re.compile()返回RegexObject对象

 

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

 

找到 RE
匹配的所有子串,并把它们作为一个迭代器返回。这个匹配是从左到右有序地返回。如果无匹配,返回空列表。

>>> it = re.finditer(r”\d+”,”12a32bc43jf3″) 
>>> for match in it: 
              print match.group()

12 
32 
43 
3

 

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

 

找到 RE
匹配的所有子串,并把它们作为一个列表返回。这个匹配是从左到右有序地返回。如果无匹配,返回空列表。

>>> re.findall(“a”,”bcdef”)
[]

>>> re.findall(r”\d+”,”12a32bc43jf3″)
[’12’, ’32’, ’43’, ‘3’]

 

re.MatchObject

 

group()返回被 RE 匹配的字符串

start()返回匹配开始的位置

end()返回匹配结束的位置

span()返回一个元组包含匹配 (开始,结束) 的位置

 

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

 

找到 RE 匹配的所有子串,并将其用一个不同的字符串替换。可选参数 count
是模式匹配後替换的最大次数;count 必须是非负整数。缺省值是 0
表示替换所有的匹配。如果无匹配,字符串将会无改变地返回。

 

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

 

找到 RE
匹配的所有子串,并把它们作为一个迭代器返回。这个匹配是从左到右有序地返回。如果无匹配,返回空列表。

>>> it = re.finditer(r”\d+”,”12a32bc43jf3″)
>>> for match in it:
              print match.group()

12
32
43
3

 

5.编译标志

编译标志让你可以修改正则表达式的一些运行方式。在 re
模块中标志可以使用两个名字,一个是全名如
IGNORECASE,一个是缩写,一字母形式如 I。(如果你熟悉 Perl
的模式修改,一字母形式使用同样的字母;例如 re.VERBOSE的缩写形式是
re.X。)多个标志可以通过按位 OR-ing 它们来指定。如 re.I | re.M 被设置成
I 和 M 标志:

I 
IGNORECASE

使匹配对大小写不敏感;字符类和字符串匹配字母时忽略大小写。举个例子,[A-Z]也可以匹配小写字母,Spam
可以匹配 “Spam”, “spam”, 或 “spAM”。这个小写字母并不考虑当前位置。

L 
LOCALE

影响 “w, “W, “b, 和 “B,这取决于当前的本地化设置。

locales 是 C
语言库中的一项功能,是用来为需要考虑不同语言的编程提供帮助的。举个例子,如果你正在处理法文文本,你想用
“w+ 来匹配文字,但 “w 只匹配字符类 [A-Za-z];它并不能匹配 “é” 或
“?”。如果你的系统配置适当且本地化设置为法语,那么内部的 C 函数将告诉程序
“é” 也应该被认为是一个字母。当在编译正则表达式时使用 LOCALE
标志会得到用这些 C 函数来处理 “w
後的编译对象;这会更慢,但也会象你希望的那样可以用 “w+ 来匹配法文文本。

M 
MULTILINE

(此时 ^ 和 $ 不会被解释; 它们将在 4.1 节被介绍.)

使用 “^” 只匹配字符串的开始,而 $
则只匹配字符串的结尾和直接在换行前(如果有的话)的字符串结尾。当本标志指定後,
“^” 匹配字符串的开始和字符串中每行的开始。同样的, $
元字符匹配字符串结尾和字符串中每行的结尾(直接在每个换行之前)。

S 
DOTALL

使 “.” 特殊字符完全匹配任何字符,包括换行;没有这个标志, “.”
匹配除了换行外的任何字符。

X 
VERBOSE

该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。当该标志被指定时,在
RE
字符串中的空白符被忽略,除非该空白符在字符类中或在反斜杠之後;这可以让你更清晰地组织和缩进
RE。它也可以允许你将注释写入 RE,这些注释会被引擎忽略;注释用 “#”号
来标识,不过该符号不能在字符串或反斜杠之後。

 

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

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

 

找到 RE 匹配的所有子串,并将其用一个不同的字符串替换。可选参数 count
是模式匹配後替换的最大次数;count 必须是非负整数。缺省值是 0
表示替换所有的匹配。如果无匹配,字符串将会无改变地返回。

 

最后:如果能用字符串的方法,就不要选择正则表达式,因为字符串方法更简单快速。

—— 正则表达式操作,pythonre
这个模块提供了与 Perl
相似l的正则表达式匹配操作。Unicode字符串也同样适用。
正则表达式使用…

 

与re.sub方法作用一样,但返回的是包含新字符串和替换执行次数的两元组。

 

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

re.escape(string)

 

对字符串中的非字母数字进行转义

 

 

与re.sub方法作用一样,但返回的是包含新字符串和替换执行次数的两元组。

 

re.purge()

 

清空缓存中的正则表达式

 

re.escape(string)

 

对字符串中的非字母数字进行转义

 

4.正则表达式对象

 

re.purge()

 

清空缓存中的正则表达式

 

re.RegexObject

 

re.compile()返回RegexObject对象

 

4.正则表达式对象

 

re.MatchObject

 

group()返回被 RE 匹配的字符串

start()返回匹配开始的位置

end()返回匹配结束的位置

span()返回一个元组包含匹配 (开始,结束) 的位置

 

re.RegexObject

 

re.compile()返回RegexObject对象

 

5.编译标志

编译标志让你可以修改正则表达式的一些运行方式。在 re
模块中标志可以使用两个名字,一个是全名如
IGNORECASE,一个是缩写,一字母形式如 I。(如果你熟悉 Perl
的模式修改,一字母形式使用同样的字母;例如 re.VERBOSE的缩写形式是
re.X。)多个标志可以通过按位 OR-ing 它们来指定。如 re.I | re.M 被设置成
I 和 M 标志:

I 
IGNORECASE

使匹配对大小写不敏感;字符类和字符串匹配字母时忽略大小写。举个例子,[A-Z]也可以匹配小写字母,Spam
可以匹配 “Spam”, “spam”, 或 “spAM”。这个小写字母并不考虑当前位置。

L 
LOCALE

影响 “w, “W, “b, 和 “B,这取决于当前的本地化设置。

locales 是 C
语言库中的一项功能,是用来为需要考虑不同语言的编程提供帮助的。举个例子,如果你正在处理法文文本,你想用
“w+ 来匹配文字,但 “w 只匹配字符类 [A-Za-z];它并不能匹配 “é” 或
“?”。如果你的系统配置适当且本地化设置为法语,那么内部的 C 函数将告诉程序
“é” 也应该被认为是一个字母。当在编译正则表达式时使用 LOCALE
标志会得到用这些 C 函数来处理 “w
後的编译对象;这会更慢,但也会象你希望的那样可以用 “w+ 来匹配法文文本。

M 
MULTILINE

(此时 ^ 和 $ 不会被解释; 它们将在 4.1 节被介绍.)

使用 “^” 只匹配字符串的开始,而 $
则只匹配字符串的结尾和直接在换行前(如果有的话)的字符串结尾。当本标志指定後,
“^” 匹配字符串的开始和字符串中每行的开始。同样的, $
元字符匹配字符串结尾和字符串中每行的结尾(直接在每个换行之前)。

S 
DOTALL

使 “.” 特殊字符完全匹配任何字符,包括换行;没有这个标志, “.”
匹配除了换行外的任何字符。

X 
VERBOSE

该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。当该标志被指定时,在
RE
字符串中的空白符被忽略,除非该空白符在字符类中或在反斜杠之後;这可以让你更清晰地组织和缩进
RE。它也可以允许你将注释写入 RE,这些注释会被引擎忽略;注释用 “#”号
来标识,不过该符号不能在字符串或反斜杠之後。

 

re.MatchObject

 

group()返回被 RE 匹配的字符串

start()返回匹配开始的位置

end()返回匹配结束的位置

span()返回一个元组包含匹配 (开始,结束) 的位置

 

最后:如果能用字符串的方法,就不要选择正则表达式,因为字符串方法更简单快速。

 

5.编译标志

编译标志让你可以修改正则表达式的一些运行方式。在 re
模块中标志可以使用两个名字,一个是全名如
IGNORECASE,一个是缩写,一字母形式如 I。(如果你熟悉 Perl
的模式修改,一字母形式使用同样的字母;例如 re.VERBOSE的缩写形式是
re.X。)多个标志可以通过按位 OR-ing 它们来指定。如 re.I | re.M 被设置成
I 和 M 标志:

I
IGNORECASE

使匹配对大小写不敏感;字符类和字符串匹配字母时忽略大小写。举个例子,[A-Z]也可以匹配小写字母,Spam
可以匹配 “Spam”, “spam”, 或 “spAM”。这个小写字母并不考虑当前位置。

L
LOCALE

影响 “w, “W, “b, 和 “B,这取决于当前的本地化设置。

locales 是 C
语言库中的一项功能,是用来为需要考虑不同语言的编程提供帮助的。举个例子,如果你正在处理法文文本,你想用
“w+ 来匹配文字,但 “w 只匹配字符类 [A-Za-z];它并不能匹配 “é” 或
“?”。如果你的系统配置适当且本地化设置为法语,那么内部的 C 函数将告诉程序
“é” 也应该被认为是一个字母。当在编译正则表达式时使用 LOCALE
标志会得到用这些 C 函数来处理 “w
後的编译对象;这会更慢,但也会象你希望的那样可以用 “w+ 来匹配法文文本。

M
MULTILINE

(此时 ^ 和 $ 不会被解释; 它们将在 4.1 节被介绍.)

使用 “^” 只匹配字符串的开始,而 $
则只匹配字符串的结尾和直接在换行前(如果有的话)的字符串结尾。当本标志指定後,
“^” 匹配字符串的开始和字符串中每行的开始。同样的, $
元字符匹配字符串结尾和字符串中每行的结尾(直接在每个换行之前)。

S
DOTALL

使 “.” 特殊字符完全匹配任何字符,包括换行;没有这个标志, “.”
匹配除了换行外的任何字符。

X
VERBOSE

该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。当该标志被指定时,在
RE
字符串中的空白符被忽略,除非该空白符在字符类中或在反斜杠之後;这可以让你更清晰地组织和缩进
RE。它也可以允许你将注释写入 RE,这些注释会被引擎忽略;注释用 “#”号
来标识,不过该符号不能在字符串或反斜杠之後。

 

最后:如果能用字符串的方法,就不要选择正则表达式,因为字符串方法更简单快速。


发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图