re 模块 常规方法使用

前情提要:

　　　　re模块主要用于正则,用的好了秒杀一切匹配的规则,这里主要是介绍基本用法

　　　　　　一:元字符

　　　　　　　　1:\w 匹配字符,包含中文,数字或下划线

 

l ='早乙女露依 123  是我的 321 心目中的 222 女神 666 女神 '

# print(re.findall('\w',l))    # ['早', '乙', '女', '露', '依', '是', '我', '的', '心', '目', '中', '的', '女', '神', '女', '神']

 

 

 

　　　　　　　　2:\W 匹配非字符,包含中文,数字或下划线

 

l ='早乙女露依 123  是我的 321 心目中的 222 女神 666 女神 '

# print(re.findall('\W',l)) #[' ', ' ', ' ', ' ', ' ', ' ', ' ']

 

 

 

　　　　　　　　3:\s 匹配任意的空白符

 

#\s 匹配任意的空白符
# print(re.findall('\s',l))   #[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']

 

　　

 

　　　　　　　　4:\S 匹配任意的空白符

　　

#\S 匹配任意非空白符
# print(re.findall('\S',l))   #['早', '乙', '女', '露', '依', '1', '2', '3', '是', '我', '的', '3', '2', '1', '心', '目', '中', '的', '2', '2', '2', '女', '神', '6', '6', '6', '女', '神']

 

 

 

　　　　　　　　5:\d 匹配任意的数字

 

#\d 匹配数字
# print(re.findall('\d',l))  #['1', '2', '3', '3', '2', '1', '2', '2', '2', '6', '6', '6']

 

 

 

　　　　　　　　6:\D匹配任意的非数字

 

#\D 匹配非数字
# print(re.findall('\D',l))  #['早', '乙', '女', '露', '依', ' ', ' ', ' ', '是', '我', '的', ' ', ' ', '心', '目', '中', '的', ' ', ' ', '女', '神', ' ', ' ', '女', '神', ' ']

 

 

 

　　　　　　　　7:\A ^  匹配任意字符串的开始

 

# \A   ^ 匹配字符串的开始
# print(re.findall('\A早',l)) #['早']

 

 

 

　　　　　　　　8:\Z  $ 匹配任意字符串的结尾

 

#\Z    $ 匹配字符串的结尾
# print(re.findall('神 $',l))  #['神 ']

 

　　

 

　　　　　　　　9: \t  \ n 匹配任意空白符

 

#\n  \t  匹配空白符
# print(re.findall('\n',l))

 

　　

 

　　　　　　二:重复匹配

　　　　　　　　1:  . 匹配任意字符

 

#. 匹配任意字符
# print(re.findall('早.女',l)) # ['早乙女']

 

 

 

　　　　　　　　2: ? 匹配0个或者一个左面的定义规则内容

 

#? 匹配0个或者1一个由左面字符定义的片段
# l ='abbzab abb aab'
# print(re.findall('a?b',l))

 

 

 

　　　　　　　　3: * 匹配0 个或者多个左面的定义规则内容

 

#* 匹配0个或者多个左面字符表达式
# l ='b ab aaaaaab abbbabaabbabbba'
# print(re.findall('a*b',l))          #['b', 'ab', 'aaaaaab', 'ab', 'b', 'b', 'ab', 'aab', 'b', 'ab', 'b', 'b']

 

 

 

　　　　　　　　4: + 匹配1 个或者多个左面的定义规则内容

 

 

# +匹配1个或者多个左面字符表达式
# l ='b ab aaaaaab abbbabaabbabbba'
# print(re.findall('a+b',l))      #['ab', 'aaaaaab', 'ab', 'ab', 'aab', 'ab']

 

 

 

 

　　　　　　　　5: {n,m} 匹配n 至m 个左面的定义规则内容

 

#{n,m} 匹配n至m个左面字符的表达式
# l ='b ab aaaaaab abbbabaabbabbba'
# print(re.findall('a{4,5}b',l))          #['aaaaab']

 

 

 

　　　　　　　　6: .* 贪婪匹配 从头匹配到尾巴

 

# .* 贪婪匹配  从头匹配到尾巴
# l ='b ab aaaaaab abbbabaabbabbba'
# print(re.findall('a.*b',l))      # ['ab aaaaaab abbbabaabbabbb']

 

 

 

　　　　　　　　7: .*? 非贪婪匹配  从头匹配到尾巴

 

#.*?非贪婪匹配 ，从头匹配到尾巴
# l ='b ab aaaaaab abbbabaabbabbba'
# print(re.findall('a.*?b',l))      #['ab', 'aaaaaab', 'ab', 'ab', 'aab', 'ab']

 

 

 

　　　　　　　　8:[    ]  加入参数 匹配

 

[]      加入参数
# print(re.findall('a[abc]b','aab abb acb aaacb'))   #['aab', 'abb', 'acb', 'acb']

 

 

　　　　　　　　9:[0-9] 加入数字 匹配

 

#[0-9]
# print(re.findall('a[0-9]b','a2b a3b a0b aaf  aab'))   #['a2b', 'a3b', 'a0b']

 

 

 

　　　　　　　　10:[a-z] 加入小写字母匹配

 

#[a-z]
# print(re.findall('a[a-z]b','abb bcb acb  afb asssddb')) #['abb', 'acb', 'afb']

 

 

 

　　　　　　　　11:[A-Z] 加入大写字母匹配

 

#[A-Z]
# print(re.findall('a[A-Z]b','aAb aCb Abb ABB'))      #['aAb', 'aCb']

 

 

 

　　　　　　　　12:[a-zA-Z]  注意不能倒过来, 需要小的在前面

 

# print(re.findall('a[a-zA-Z]b','aAb aCb Abb ABB'))    #['aAb', 'aCb']

 

 

 

　　　　　　　　13: ()  定制一个规则, 将满足的规则匹配出来

 

# print(re.findall('(.*?)_b','wo_b chi_b hhe_b  fas adadas_bd')) #['wo', ' chi', ' hhe', '  fas adadas']

 

 

 

　　　　　　三:  常用方法总结

　　　　　　　　　　1:search 找到第一个规则,找不到则返回None

　　　　　　　　　　　　对象.group() 调用

 

# print(re.search('alex','re alex alex 太白').group())        #alex
# print(re.search('alex','re aaleex aaleex 太白'))     #None

 

 

 

　　　　　　　　　　2:match 匹配开头文字,如果匹配不到就None

# print(re.match('alex','alex alex 太白').group())     #alex
# print(re.match('alex','re alex alex 太白')) #None

 

　　　　　　　　　　3:spilt 切割

 

# s1 = 'wusir;太白,alex|日天!小虎'
# print(re.split(';,|!',s1))    #['wusir;太白,alex|日天', '小虎']

 

 

 

　　　　　　　　　　4:compile() 制定一个规则

 

# 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, \B.
#
# re.X(re.VERBOSE)
# 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。