RegularExpressionCheatsheet

基本函数

匹配用的特殊符号

1. .匹配除\n之外的所有单字符

import re
txt = 'aaa\nasdd'
findall_result = re.findall(r'.', txt)
match_result = re.match(r'.', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result)
print(match_result)

['a', 'a', 'a', 'a', 's', 'd', 'd']
<_sre.SRE_Match object; span=(0, 1), match='a'>

2. *匹配其前方字符的零次或n次重复

import re
txt = 'a00daaab00aa0acb'
findall_result = re.findall(r'a*', txt)
match_result = re.match(r'a*', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result)
print(match_result)

['a', '', '', '', 'aaa', '', '', '', 'aa', '', 'a', '', '', '']
<_sre.SRE_Match object; span=(0, 1), match='a'>

txt = 'a00daaab00aa0acb'
findall_result = re.findall(r'.*', txt)
match_result = re.match(r'.*', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result)
print(match_result)

['a00daaab00aa0acb', '']
<_sre.SRE_Match object; span=(0, 16), match='a00daaab00aa0acb'>

3. +匹配其前方字符的一次或多次重复

import re
txt = 'a00daaab00aa0acb'
findall_result = re.findall(r'a+', txt)
match_result = re.match(r'a+', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result)
print(match_result)

['a', 'aaa', 'aa', 'a']
<_sre.SRE_Match object; span=(0, 1), match='a'>

4. []中括号内的内容被分成字符,任意匹配其中的每个字符,字符间无先后,是‘或’的关系。

import re
txt = 'a00daaab00aa0acb'
findall_result = re.findall(r'[ab0]', txt)
match_result = re.match(r'[cba]', txt)
match_result2 = re.match(r'[cb]', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result)
print(match_result)
print(match_result2)

['a', '0', '0', 'a', 'a', 'a', 'b', '0', '0', 'a', 'a', '0', 'a', 'b']
<_sre.SRE_Match object; span=(0, 1), match='a'>
None

5. ()标识一个子表达式的范围,可用(表达式1|表达式2)同时进行多个表达式的匹配,匹配其中的任意一个。另外,注意表达式有()时,例如(aa)bc,将只能匹配字符串中caabcnaadd中的aa(即函数只返回()里的部分)。有多个(),则分别返回每个括号匹配到的值

import re
txt = 'a00daaab00aa0acb'
findall_result = re.findall(r'(da|a0)aa', txt)
findall_result2 = re.findall(r'(da)(aa)', txt)
findall_result3 = re.findall(r'(da)(ab)', txt)
match_result = re.match(r'(b0|a0)', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result)
print(findall_result2)
print(findall_result3)
print(match_result)

['da']
[('da', 'aa')]
[]
<_sre.SRE_Match object; span=(0, 2), match='a0'>

6. \ 用来匹配特殊字符(如换行符\n),或用来匹配模式符号的原本含义:如,\*匹配*

import re
txt = 'a00d*aa\nab00aa0acb\n'
findall_result = re.findall(r'\*', txt)
match_result = re.match(r'.*(\*)', txt)
match_result2 = re.match(r'\*', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result)
print(match_result)
print(match_result2)

['*']
<_sre.SRE_Match object; span=(0, 5), match='a00d*'>
None

7. ?出现在*、+后时,标记前面的子表达式是非贪婪的(意思是最小匹配,原字符串中连续重复多次,但只会匹配其中第一个)

import re
txt = 'a00da*aab00aa0acb'
findall_result = re.findall(r'a.*?b', txt)
findall_result2 = re.findall(r'a(.*?)b', txt)
match_result = re.match(r'a.*?b', txt)
match_result2 = re.match(r'.*', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result)
print(findall_result2)
print(match_result)
print(match_result2)

['a00da*aab', 'aa0acb']
['00da*aa', 'a0ac']
<_sre.SRE_Match object; span=(0, 9), match='a00da*aab'>
<_sre.SRE_Match object; span=(0, 17), match='a00da*aab00aa0acb'>

8. {n}、{n, n+}表示匹配的次数的限制

import re
txt = 'a00da*aab00aa0acb'
findall_result = re.findall(r'a0{2}', txt)
findall_result2 = re.findall(r'a0{1}', txt)
match_result = re.match(r'a{2}', txt)
match_result2 = re.match(r'a{1}', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result)
print(findall_result2)
print(match_result)
print(match_result2)

['a00']
['a0', 'a0']
None
<_sre.SRE_Match object; span=(0, 1), match='a'>

9. ^用于限制正则匹配只能匹配字符串的开始位置的相应字符串

import re
txt = 'a00da*aab00aa0acb'
findall_result = re.findall(r'^a0', txt)
findall_result2 = re.findall(r'a0', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result)
print(findall_result2)

['a0']
['a0', 'a0']

10. ^在表达式[^a-z]中,表示一个取反的正则表达式,匹配a-z以外的所有字符,其中[]的用法,参照第3条

import re
txt = 'a00da*aab00aa0acb'
findall_result = re.findall(r'[^0]', txt)
findall_result2 = re.findall(r'[0]', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result)
print(findall_result2)

['a', 'd', 'a', '*', 'a', 'a', 'b', 'a', 'a', 'a', 'c', 'b']
['0', '0', '0', '0', '0']

11. txt='adb00000000acb', ab=re.findall( r'a(.*?)b', txt),返回字符串中匹配了表达式()中的部分的子串

import re
txt = 'a00da*aab00aa0acb'
findall_result = re.findall(r'a(.*?)b', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result)

['00da*aa', 'a0ac']

12. **高难度用法**:(1号表达式)(2号表达式)(3号表达式),这样用()括号,将不同正则表达式括起来后,对字符串进行匹配后,可以用re.group(1或2或3)单独获取到三个表达式对应匹配到的字符串。(re.group(0)或者不使用group则获取整个全局的正则匹配)

import re
txt = 'a00da*aab00aa0acb'
findall_result = re.search(r'(a.*a)(b.*a)(0.*b)', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result.group(1))
print(findall_result.group(2))
print(findall_result.group(3))

a00da*aa
b00aa
0acb

13. **高难度用法**:python版命名组方法(?P<name>正则表达式) 使用re.group('name'),可以用指定的name匹配某个字符串

import re
txt = 'a00da*aab00aa0acb'
findall_result = re.search(r'(?P<ZhangZhe>d.*)00', txt)
# findall返回一个list
# match返回一个对象,其内容为表达式在字符串开头能匹配到的部分
print(findall_result.group('ZhangZhe'))

da*aab

注意: 网上一些代码类似,reg = /a-zA-z/ 其中 /符号是某些编程语言中,指示一个正则表达式起止的记号

获得英文标点符号

from string import punctuation as en_punc
print(en_punc)

!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~