就再次来到一个匹配对象,search()再次来到的目的就是合作对象

Python的 re 模块:主题函数和艺术

Python的 re 模块:宗旨函数和方法

1. 应用 compile()函数编译正则表明式

  导入 re 模块后,在compile()
中编译正则表达式,例如:pattern =
re.compile(‘正则表达式’,re.S),然后就足以应用pattern来展开匹配了。

  在compile
中还是可以带模块属性,即re.S,re.I,re.L,re.M,re.X等。

1. 选择 compile()函数编译正则表明式

  导入 re 模块后,在compile()
中编译正则表达式,例如:pattern =
re.compile(‘正则发挥式’,re.S),然后就足以运用pattern来拓展匹配了。

  在compile
中还足以带模块属性,即re.S,re.I,re.L,re.M,re.X等。

2.协作对象以及 group()和 groups()方法

  匹配对象有多少个重大的不二法门:group()和
groups()。 调用 match()或者
search()再次回到的靶子就是格外对象,group()要么再次回到整个匹配对象,要么依据需求回到特定子组。

  groups()则仅再次回到一个涵盖唯一或者全体子组的元组。假诺没有子组的必要,那么当group()照旧重临整个匹配时,groups()
重返一个空元组。

2.卓绝对象以及 group()和 groups()方法

  匹配对象有三个紧要的主意:group()和
groups()。 调用 match()或者
search()重返的目的就是合营对象,group()要么重回整个匹配对象,要么按照须求回到特定子组。

  groups()则仅重临一个富含唯一或者全体子组的元组。若是没有子组的需要,那么当group()依然重临整个匹配时,groups()
再次回到一个空元组。

3. 利用 match()方法匹配字符串

  match()
函数计算从字符串的苗子部分对方式开展匹配。如果合营成功,就回去一个匹配对象;若是匹配战败,就回到
None,匹配对象的 group()方法可以用于浮现这几个成功的合作。

 1 html = '<html><head>title</head><body>2333</body></html>'
 2 pattern = re.compile('<.*?head>(.*?)<.*?body>(.*?)<.*?>')
 3 
 4 m = re.match(pattern, html)
 5 
 6 print(m.group())
 7 print(m.group(1))
 8 print((m.group(2)))
 9 print(m.groups())
10 # 输出:
11 # <html><head>title</head><body>2333</body>
12 # title
13 # 2333
14 # ('title', '2333')

>>> re.match('foo', 'food on the table').group() 
'foo' 

3. 拔取 match()方法匹配字符串

  match()
函数计算从字符串的起尾部分对方式展开匹配。即使匹配成功,就赶回一个相当对象;若是协作失利,就回到
None,匹配对象的 group()方法能够用于浮现那多少个成功的匹配。

 1 html = '<html><head>title</head><body>2333</body></html>'
 2 pattern = re.compile('<.*?head>(.*?)<.*?body>(.*?)<.*?>')
 3 
 4 m = re.match(pattern, html)
 5 
 6 print(m.group())
 7 print(m.group(1))
 8 print((m.group(2)))
 9 print(m.groups())
10 # 输出:
11 # <html><head>title</head><body>2333</body>
12 # title
13 # 2333
14 # ('title', '2333')

>>> re.match('foo', 'food on the table').group() 
'foo' 

4. 运用 search()在一个字符串中搜索方式,(搜索)

  search()的行事章程与
match()完全一致,不一致之处在于
search()会用它的字符串参数
,在肆意地方对给定正则表明式情势寻找第两回出现的格外情状。

  如若搜索到成功的万分,就会再次回到一个匹配对象;否则,再次来到None。

  search() 和 match()
分歧之处在于,search() 会搜索字符串中间部分。

>>> m = re.match('foo', 'seafood')     # 匹配失败 
>>> m = re.search('foo', 'seafood')   # 使用 search() 代替 
>>> if m is not None: m.group() 
... 
'foo'     # 搜索成功,但是匹配失败,在seafood中搜索foo    

4. 行使 search()在一个字符串中摸索情势,(搜索)

  search()的办事方法与
match()完全一致,不一样之处在于
search()会用它的字符串参数
,在肆意地方对给定正则表明式情势寻找首回面世的匹配情况。

  倘使搜索到成功的匹配,就会回去一个极度对象;否则,再次来到None。

  search() 和 match()
差距之处在于,search() 会搜索字符串中间部分。

>>> m = re.match('foo', 'seafood')     # 匹配失败 
>>> m = re.search('foo', 'seafood')   # 使用 search() 代替 
>>> if m is not None: m.group() 
... 
'foo'     # 搜索成功,但是匹配失败,在seafood中搜索foo    

 5.重复、特殊字符以及分组

  用一个极度电子邮件地址的正则表达式做例子。(\w+@\w+\.com),这一个正则表明式只可以合营简单的地点。

  为了在域名前添加主机名称协助,例如
www.xxx.com,必要采纳?,\w+@(\w+\.)?\w+\.com,让(\w+\.)可选。

>>> pattern = '\w+@(\w+\.)?\w+\.com' 
>>> re.match(pattern, 'nobody@xxx.com').group() 
'nobody@xxx.com' 
>>> re.match(pattern, 'nobody@www.xxx.com').group() 
'nobody@www.xxx.com' 

  进一步伸张该示例,允许擅自数量的高中级子域名存在。把?改为
* 号。\w+@(\w+\.)*\w+\.com

>>> patt = '\w+@(\w+\.)*\w+\.com' 
>>> re.match(patt, 'nobody@www.xxx.yyy.zzz.com').group() 
'nobody@www.xxx.yyy.zzz.com' 

  使用圆括号来合营和保存子组,以便于继续处理。

>>> m = re.match('(\w\w\w)-(\d\d\d)', 'abc-123') 
>>> m.group()                       # 完整匹配 
'abc-123' 
>>> m.group(1)                      # 子组 1 
'abc' 
>>> m.group(2)                      # 子组 2 
'123' 
>>> m.groups()                      # 全部子组 
('abc', '123') 

  group()平日用于以一般性格局显示所有的匹配部分,但也能用来获
取种种匹配的子组。可以使用
groups()方法来收获一个涵盖所有匹配子字符串的元组。

 5.重复、特殊字符以及分组

  用一个匹配电子邮件地址的正则表明式做例子。(\w+@\w+\.com),这一个正则表明式只可以合作简单的地方。

  为了在域名前添加主机名称帮衬,例如
www.xxx.com,必要利用?,\w+@(\w+\.)?\w+\.com,让(\w+\.)可选。

>>> pattern = '\w+@(\w+\.)?\w+\.com' 
>>> re.match(pattern, 'nobody@xxx.com').group() 
'nobody@xxx.com' 
>>> re.match(pattern, 'nobody@www.xxx.com').group() 
'nobody@www.xxx.com' 

  进一步壮大该示例,允许擅自数量的中间子域名存在。把?改为
* 号。\w+@(\w+\.)*\w+\.com

>>> patt = '\w+@(\w+\.)*\w+\.com' 
>>> re.match(patt, 'nobody@www.xxx.yyy.zzz.com').group() 
'nobody@www.xxx.yyy.zzz.com' 

  使用圆括号来协作和保存子组,以便于继续处理。

>>> m = re.match('(\w\w\w)-(\d\d\d)', 'abc-123') 
>>> m.group()                       # 完整匹配 
'abc-123' 
>>> m.group(1)                      # 子组 1 
'abc' 
>>> m.group(2)                      # 子组 2 
'123' 
>>> m.groups()                      # 全部子组 
('abc', '123') 

  group()平常用于以常备情势显示所有的相当部分,但也能用来获
取各种匹配的子组。可以采取groups()方法来得到一个饱含所有匹配子字符串的元组。

6.选取 sub()和 subn()搜索与替换

  有三个函数/方法用于落到实处搜索和替换功效:sub()和
subn()。两者大约一样,都是将某字符串中装有匹配正则表明式的部分开展某种方式的替换。

  用来替换的片段日常是一个字符串,
但它也可能是一个函数,该函数重临一个用来替换的字符串。

  subn()和 sub()的差异点是subn()
还回去一个象征替换的总数,替换后的字符串和表示替换总数的数字一起作为一个富有四个元素的元组返回。

>>> re.sub('X', 'Mr. Smith', 'attn: X\n\nDear X,\n') 
'attn: Mr. Smith\012\012Dear Mr. Smith,\012' 
>>> 
>>> re.subn('X', 'Mr. Smith', 'attn: X\n\nDear X,\n') 
('attn: Mr. Smith\012\012Dear Mr. Smith,\012', 2) 
>>> 
>>> print(re.sub('X', 'Mr. Smith', 'attn: X\n\nDear X,\n'))
attn: Mr. Smith 

Dear Mr. Smith, 

>>> re.sub('[ae]', 'X', 'abcdef') 
'XbcdXf' 
>>> re.subn('[ae]', 'X', 'abcdef') 
('XbcdXf', 2) 

6.应用 sub()和 subn()搜索与替换

  有几个函数/方法用于落实搜索和替换功效:sub()和
subn()。两者大致一模一样,都是将某字符串中具有匹配正则表明式的一部分举办某种方式的交替。

  用来替换的有些常见是一个字符串,
但它也可能是一个函数,该函数重回一个用来替换的字符串。

  subn()和 sub()的不相同点是subn()
还回到一个意味着替换的总数,替换后的字符串和象征替换总数的数字一起作为一个有所四个元素的元组重临。

>>> re.sub('X', 'Mr. Smith', 'attn: X\n\nDear X,\n') 
'attn: Mr. Smith\012\012Dear Mr. Smith,\012' 
>>> 
>>> re.subn('X', 'Mr. Smith', 'attn: X\n\nDear X,\n') 
('attn: Mr. Smith\012\012Dear Mr. Smith,\012', 2) 
>>> 
>>> print(re.sub('X', 'Mr. Smith', 'attn: X\n\nDear X,\n'))
attn: Mr. Smith 

Dear Mr. Smith, 

>>> re.sub('[ae]', 'X', 'abcdef') 
'XbcdXf' 
>>> re.subn('[ae]', 'X', 'abcdef') 
('XbcdXf', 2) 

7.恢弘符号

   通过采用 (?iLmsux)
种类选项,用户可以直接在正则表明式里面指定一个要么三个标志,而不是经过
compile()或者其他 re 模块函数。

  上面为部分施用 re.I/IGNORECASE
的以身作则, 最终一个演示在 re.M/MULTILINE 已毕多行混合:

>>> re.findall(r'(?i)yes', 'yes? Yes. YES!!')  # (?i) 不区分大小写 
['yes', 'Yes', 'YES'] 
>>> re.findall(r'(?i)th\w+', 'The quickest way is through this tunnel.') ['The', 'through', 'this'] 
>>> re.findall(r'(?im)(^th[\w ]+)', """ 
... This line is the first, 
... another line, 
... that line, it's the best 
... """) 
['This line is the first', 'that line'] 

 

7.扩展符号

   通过利用 (?iLmsux)
连串选项,用户可以从来在正则表明式里面指定一个要么两个记号,而不是经过
compile()或者其余 re 模块函数。

  下边为部分行使 re.I/IGNORECASE
的以身作则, 最终一个演示在 re.M/MULTILINE 完结多行混合:

>>> re.findall(r'(?i)yes', 'yes? Yes. YES!!')  # (?i) 不区分大小写 
['yes', 'Yes', 'YES'] 
>>> re.findall(r'(?i)th\w+', 'The quickest way is through this tunnel.') ['The', 'through', 'this'] 
>>> re.findall(r'(?im)(^th[\w ]+)', """ 
... This line is the first, 
... another line, 
... that line, it's the best 
... """) 
['This line is the first', 'that line']