Python标准库中的re模块


      Python  的  re  模块(Regular  Expression  正则表达式)提供各种正则表达式的匹配操作,在文本解析、复杂字符串分析和信息提取时是一个非常有用的工具。

        正则表达式语法表如下:
语法 意义 说明

"."
匹配除“\n”之外的任何单个字符   

"^"
字符串开始 '^hello'匹配'helloworld'而不匹配'aaaahellobbb'

"$"
字符串结尾 'world$'匹配'helloworld'而不匹配'worldobbb'

"*"
匹配前面的子表达式任意次(贪婪匹配) zo*能匹配“z”,也能匹配“zo”以及“zoo”。*等价于o{0,}

"+"
匹配前面的子表达式一次或多次(大于等于1次)(贪婪匹配) “zo+”能匹配“zo”以及“zoo”,但不能匹配“z”。+等价于{1,}

"?"
匹配前面的子表达式零次或一次(贪婪匹配) “do(es)?”可以匹配“do”或“does”中的“do”。?等价于{0,1}

*?,  ?,??
尽可能少的匹配所搜索的字符串(非贪婪匹配) 对于字符串“oooo”,“o+”将尽可能多的匹配“o”,得到结果[“oooo”],而“o+?”将尽可能少的匹配“o”,得到结果['o',    'o',    'o',    'o']

{m,n}
m和n均为非负整数,其中n<=m。最少匹配n次且最多匹配m次 a{6}匹配6个a、a{2,4}匹配2到4个a

{m,n}?
对于前一个字符重复m到n次,并取尽可能少 ‘aaaaaa’中a{2,4}只会匹配2个

"\\"
特殊字符转义或者特殊序列  
  
[]
表示一个字符集 [0-9]、[a-z]、[A-Z]、[^0]

"|"
A|B,或运算

(...)
匹配括号中任意表达式  
  
(?#...)
注释,可忽略  

(?=...)
非获取匹配,正向肯定预查,在任何匹配pattern的字符串开始处匹配查找字符串,该匹配不需要获取供以后使用 '(?=test)'    在hellotest中匹配hello

(?!...)
  非获取匹配,正向否定预查,在任何不匹配pattern的字符串开始处匹配查找字符串,该匹配不需要获取供以后使用 '(?!=test)'    若hello后面不为test,匹配hello

(?  <  =...)
非获取匹配,反向肯定预查,与正向肯定预查类似,只是方向相反。 '(?  <  =hello)test'    在hellotest中匹配test

(?  <  !...)
非获取匹配,反向否定预查,与正向否定预查类似,只是方向相反。 '(?  <  !hello)test'    在hellotest中不匹配test


        正则表达式特殊序列表如下:
特殊序列符号      意义
\A                        只在字符串开始进行匹配
\Z                        只在字符串结尾进行匹配
\b                        匹配位于开始或结尾的空字符串
\B                        匹配不位于开始或结尾的空字符串
\d                        相当于[0-9]
\D                        相当于[^0-9]
\s                        匹配任意空白字符:[\t\n\r\r\v]
\S                        匹配任意非空白字符:[^\t\n\r\r\v]
\w                        匹配任意数字和字母:[a-zA-Z0-9]
\W                        匹配任意非数字和字母:[^a-zA-Z0-9]

re的主要功能函数

        常用的功能函数包括:compile、search、match、split、findall(finditer)、sub(subn)

compile

        re.compile(pattern[,  flags])
        作用:把正则表达式语法转化成正则表达式对象
            flags定义包括:
                re.I:忽略大小写
                re.L:表示特殊字符集  \w,  \W,  \b,  \B,  \s,  \S  依赖于当前环境
                re.M:多行模式
                re.S:’  .  ’并且包括换行符在内的任意字符(注意:’  .  ’不包括换行符)
                re.U:  表示特殊字符集  \w,  \W,  \b,  \B,  \d,  \D,  \s,  \S  依赖于  Unicode  字符属性数据库

search

        re.search(pattern,  string[,  flags])
        search  (string[,  pos[,  endpos]])
        作用:在字符串中查找匹配正则表达式模式的位置,返回  MatchObject  的实例,如果没有找到匹配的位置,则返回  None。

match
        re.match(pattern,  string[,  flags])
        match(string[,  pos[,  endpos]])
        作用:match()  函数只在字符串的开始位置尝试匹配正则表达式,也就是只报告从位置  0  开始的匹配情况,而  search()  函数是扫描整个字符串来查找匹配。如果想要搜索整个字符串来寻找匹配,应当用  search()。

        下面是几个例子:
        例:最基本的用法
>>>  import  re
>>>  r1  =  re.compile(r'world')
>>>  print(r1.match('helloworld'))
None
>>>  print(r1.search('helloworld'))
<_sre.SRE_Match  object;  span=(5,  10),  match='world'>
>>>  

        r是raw(原始)的意思。因为在表示字符串中有一些转义符,如表示回车'\n'。如果要表示\表需要写为'\\'。但如果我就是需要表示一个'\'+'n',不用r方式要写为:'\\n'。但使用r方式则为r'\n'这样清晰多了。

        例:设置flag

>>>  r2  =  re.compile(r'n$',  re.S)
>>>  print(r2.search('helloworld'))
None
>>>  r2  =  re.compile('\n$',  re.S)
>>>  print(r2.search('helloworld'))
None
>>>  r2  =  re.compile(r'd$',  re.S)
>>>  print(r2.search('helloworld'))
<_sre.SRE_Match  object;  span=(9,  10),  match='d'>
>>>  r2  =  re.compile('World$',  re.I)
>>>  print(r2.search('helloworld'))
<_sre.SRE_Match  object;  span=(5,  10),  match='world'>
>>>  r2  =  re.compile(r'n$',  re.S)
>>>  print(r2.search('helloworld\n'))
None
>>>  r2  =  re.compile('\n$',  re.S)
>>>  print(r2.search('helloworld\n'))
<_sre.SRE_Match  object;  span=(10,  11),  match='\n'>
>>>  r2  =  re.compile('World$',  re.I)
>>>  print(r2.search('helloworld\n'))
<_sre.SRE_Match  object;  span=(5,  10),  match='world'>
>>>  

        例:直接调用
>>>  print(re.search(r'abc','helloaaabcdworldn'))
<_sre.SRE_Match  object;  span=(7,  10),  match='abc'>

split

        re.split(pattern,  string[,  maxsplit=0,  flags=0])
        split(string[,  maxsplit=0])
        作用:可以将字符串匹配正则表达式的部分割开并返回一个列表
        例:简单分析ip
>>>  print  (re.split('(\W+)','192.168.1.1',1))
['192',  '.',  '168.1.1']
>>>  print  (re.split('(\W+)','192.168.1.1'))
['192',  '.',  '168',  '.',  '1',  '.',  '1']
>>>  r1  =  re.compile('\W+')
>>>  print  (r1.split('192.168.1.1'))
['192',  '168',  '1',  '1']
>>>  

findall

        re.findall(pattern,  string[,  flags])
        findall(string[,  pos[,  endpos]])
        作用:在字符串中找到正则表达式所匹配的所有子串,并组成一个列表返回
        例:查找[]包括的内容(贪婪和非贪婪查找)
>>>  r1  =  re.compile('([.*])')
>>>  print  (re.findall(r1,"hello[hi]heldfsdsf[iwonder]lo"))
[]
>>>  print  (re.findall(r1,"hello.[hi]heldfsdsf[iwonder]lo"))
['.']
>>>  r1  =  re.compile('([.*?])')
>>>  print  (re.findall(r1,"hello[hi]heldfsdsf[iwonder]lo"))
[]
>>>  print  (re.findall(r1,"hello.[hi]heldfsdsf[iwonder]lo"))
['.']
>>>  r1  =  re.compile('([s*])')
>>>  print  (re.findall(r1,"hello[hi]heldfsdsf[iwonder]lo"))
['s',  's']
>>>  r1  =  re.compile('([s*?])')
>>>  print  (re.findall(r1,"hello[hi]heldfsdsf[iwonder]lo"))
['s',  's']
>>>  print  (re.findall('[0-9]{2}',"fdskfj1323jfkdj"))
['13',  '23']
>>>  print  (re.findall('[0-9]{3}',"fdskfj1323jfkdj"))
['132']
>>>  print  (re.findall('([0-9][a-z])',"fdskfj1323jfkdj"))
['3j']
>>>  print  (re.findall('(?=www)',"afdsfwwwfkdjfsdfsdwww"))
['',  '']
>>>  print  (re.findall('(?<=www)',"afdsfwwwfkdjfsdfsdwww"))
['',  '']

finditer

        re.finditer(pattern,  string[,  flags])
        finditer(string[,  pos[,  endpos]])
        说明:和  findall  类似,在字符串中找到正则表达式所匹配的所有子串,并组成一个迭代器返回。

sub
        re.sub(pattern,  repl,  string[,  count,  flags])
        sub(repl,  string[,  count=0])
        说明:在字符串  string  中找到匹配正则表达式  pattern  的所有子串,用另一个字符串  repl  进行替换。如果没有找到匹配  pattern  的串,则返回未被修改的  string。repl  既可以是字符串也可以是一个函数。
        例:
>>>  p  =  re.compile('(one|two|three)')
>>>  print  (p.sub('num','one  word  two  words  three  words  apple',  2))
num  word  num  words  three  words  apple
>>>  print  (p.sub('num','one  word  two  words  three  words  apple',  1))
num  word  two  words  three  words  apple
>>>  print  (p.sub('num','one  word  two  words  three  words  apple',  3))
num  word  num  words  num  words  apple

subn
        re.subn(pattern,  repl,  string[,  count,  flags])
        subn(repl,  string[,  count=0])
        说明:该函数的功能和  sub()  相同,但它还返回新的字符串以及替换的次数。
 


 
展开阅读全文

没有更多推荐了,返回首页