python基础之re模块

正则匹配

re -- 正则表达式# re从字符串中获取想要的内容

1. w 匹配中文，字母，下划线

import re
name = "洲神-meet_123 "
print(re.findall("w",name))  # 参数1:要查找的内容,参数2:从哪查找
输出结果：['洲', '神', 'm', 'e', 'e', 't', '_', '1', '2', '3']

2. W 不匹配中文字母下划线

import re
name = "洲神-meet_123 "
print(re.findall("W",name))   #['-', ' ']

3. s 匹配任意空白符

name = "洲神-meet_123 "
print(re.findall("s",name))
输出结果 [' ']

4. S 匹配不是任意的空白符

name = "洲神-meet_123 "  123后边有个空格
print(re.findall("S",name))
输出结果 ['洲', '神', 'm', 'e', 'e', 't', '_', '1', '2', '3']
如果匹配不到是个[]空列表

5. d 匹配数字

name = "洲神-meet_123 " 
print(re.findall("d",name))
输出结果 ['1', '2', '3']

6. D 匹配非数字

name = "洲神-meet_123 " 
print(re.findall("d",name))
输出结果 ['洲', '神', '-', 'm', 'e', 'e', 't', '_', ' ']

7. A 与 ^ 从字符*串开头匹配

import rename = "meet_123 "
print(re.findall("^meet",name))
['meet']

8.  与 z 与 $ 字符串结尾匹配

import re
name = "阿萨德meet_123 "
print(re.findall("t_123 $",name))
['t_123 ']

9. 与 匹配换行符合制表符

import rename = "meet_123 	
"
print(re.findall("	",name))
['	']

name = "宝元-meet_123	 
"
print(re.findall("
",name))
结果 ['
']

**匹配任意字符（除换行符外） **

import re
name = "meet_123 	
"
print(re.findall(".",name))
['m', 'e', 'e', 't', '_', '1', '2', '3', ' ', '	']

*匹配 * 前面元素0个或多个 [贪婪匹配]

    import re
    name = "m-e-me-meet-meet_123	 
"
    print(re.findall("m*",name))
    # 结果
	['m', 'me', 'mee', 'mee']

+匹配 +前面元素1个或多个 [贪婪匹配]

import re
name = "m-e-me-meet-meet_123	 
"
print(re.findall("me+",name))
# 结果
['me', 'mee', 'mee']

{n,m} 匹配n到m个元素

import re
name = "m-e-me-meet-meet_123	 
"
print(re.findall("e{1,2}",name))
# 结果
['e', 'e', 'ee', 'ee']

.* 任意内容0个或多个

import re
name = "m-e-me-meet-meet_123	 
"
print(re.findall(".*",name))
# 结果
['m-e-me-meet-meet_123	 ', '', '']

s = "alex121me1et11123,wusir324"
s1 = "alex121meeeeeeeet11123,wusir324"
print(re.findall("e",s))
print(re.findall("e*",s))        # *  0 - n  贪婪匹配
print(re.findall('e+',s1))       # +  1 - n  贪婪匹配
print(re.findall('e?',s1))       # ?  e * 0 -  e * 1 非贪婪
结果

['e', 'e', 'e']
['', '', 'e', '', '', '', '', '', 'e', '', 'e', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '']
['e', 'eeeeeeee']
['', '', 'e', '', '', '', '', '', 'e', 'e', 'e', 'e', 'e', 'e', 'e', 'e', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '']

# s = 'alex_sb wusir_sb 的 alex wusir '
# import re
# print(re.findall("(.*)_sb",s))
# print(re.findall("(.+?)_sb",s))   # .... * 0 or .... 1
# print(re.findall("(.............)_sb",s))
['alex_sb wusir']
['alex', ' wusir']
['alex_sb wusir']

练习

 s1 = "1-2*(60+(-40.35/5)-(-4*3))"
 print(re.findall("d+",s1))
 结果： ['1', '2', '60', '40', '35', '5', '4', '3']
 print(re.findall("d+.d+|d+",s1))
 结果：['1', '2', '60', '40.35', '5', '4', '3']
 print(re.findall("-d+.d+|-d+|d+",s1))
 结果：['1', '-2', '60', '-40.35', '5', '-4', '3']
 print(re.findall("-d+.d+",s1))
 结果、：['-40.35']

练习2

import re

s3 = ''' 时间就是1995-04-27,2005-04-27
 1999-04-27 xxx教育创始人
 xxx老师 洲神 1980-04-27:1980-04-27
2018-12-08
 '''
print(re.findall('d+-d+-d+',s3))  
结果：['1995-04-27', '2005-04-27', '1999-04-27', '1980-04-27', '1980-04-27', '2018-12-08']

 print(re.findall('d+-d+-d+:d+-d+-d+',s3))
结果：['1980-04-27:1980-04-27']

print(re.findall("x (S+)
",s3))  
结果：['时间就是1995-04-27,2005-04-27', 'xxx教育创始人', '1980-04-27:1980-04-27', '2018-12-08']

print(re.findall('d{4}-d{2}-d{2}', s3))
结果:['1995-04-27', '2005-04-27', '1999-04-27', '1980-04-27', '1980-04-27', '2018-12-08']

re.compile()

编译正则表达式模式，返回一个对象。可以把常用的正则表达式编译成正则表达式对象，方便后续调用及提高效率。

re.compile(pattern,flags=0)

pattern 指定编译时的表达式字符串

flags 编译标志位，用来修改正则表达式的匹配方式。支持 re.L|re.M 同时匹配

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

import re
content = 'Citizen wang , always fall in love with neighbour，WANG'
rr = re.compile(r'wanw', re.I) # 不区分大小写
print(type(rr))
a = rr.findall(content)
print(type(a))
print(a)
[python@master test]$ python3 b.py 
<class 're.Pattern'>
<class 'list'>
['wang', 'WANG']

re.match()

尝试从一个字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，则返回None。

import re
# 将正则表达式编译成Pattern对象，注意hello前面的r的意思是“原生字符串”
pattern = re.compile(r'hello')  #正则表达式
# 使用re.match匹配文本，获得匹配结果，无法匹配时将返回None
result1 = re.match(pattern, 'hello').span()  span()所在字符的位置
result2 = re.match(pattern, 'sasahelloo CQC! hello')
result3 = re.match(pattern, 'helo CQC!')
result4 = re.match(pattern, 'hello CQC!')

结果：<(0，5), match='hello'> None None <_sre.SRE_Match object; span=(0, 5), match='hello'>  第二个和第三个为None, 第二个是开头不是hello虽然后边有hello，但是match只是从起始位置匹配，第三个差不多起始位置不是hello，不符合匹配规则

group(num=0)    匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。

groups()    返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

import re
line = "Cats are smarter than dogs";
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"

# 执行结果
searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

re.search()

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

import re
# 将正则表达式编译成Pattern对象，注意hello前面的r的意思是“原生字符串”
pattern = re.compile(r'hello')  #正则表达式
# 使用re.serach匹配文本，获得匹配结果，无法匹配时将返回None
result1 = re.search(pattern, 'hello').span()
result2 = re.search(pattern, 'sasahelloo CQC! hello')
result3 = re.search(pattern, 'helo CQC!')
print(result1,result2,result3)
结果：(0, 5) <_sre.SRE_Match object; span=(4, 9), match='hello'> None

finditer

finditer返回一个迭代器，遍历迭代器可以得到一个SRE_Match对象，比如下面的例子
re_str = "what is a different between python 2.7.14 and python 3.5.4"
re_obj = re.compile("d{1,}.d{1,}.d{1,}")
for i in re_obj.finditer(re_str):
    print(i)
  <_sre.SRE_Match object; span=(35, 41), match='2.7.14'>
 <_sre.SRE_Match object; span=(53, 58), match='3.5.4'>