21天学Python --- 打卡2:Regular Expression
测试工具: https://c.runoob.com/front-end/854/.
1.Common characters
| 模式 | 描述 |
|---|---|
^ |
匹配字符串的开头 |
$ |
匹配字符串的末尾。 |
. |
匹配除 “\n” 之外的任何单个字符。要匹配包括 ‘\n’ 在内的任何字符，请使用象 ‘[.\n]’ 的模式。 |
[...] |
用来表示一组字符,单独列出：[amk] 匹配 ‘a’，‘m’或’k’ |
[^...] |
不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。 |
re* |
匹配0个或多个的表达式。 |
re+ |
匹配1个或多个的表达式。 |
re? |
匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式 |
re{n} |
匹配n个前面表达式。例如，"o{2}“不能匹配"Bob"中的"o”，但是能匹配"food"中的两个o。 |
re{ n,} |
精确匹配n个前面表达式。例如，"o{2,}“不能匹配"Bob"中的"o”，但能匹配"foooood"中的所有o。"o{1,}“等价于"o+”。"o{0,}“则等价于"o*”。 |
re{ n, m} |
匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式 |
| `a | b` |
(re) |
匹配括号内的表达式，也表示一个组 |
(?imx) |
正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。 |
(?-imx) |
正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。 |
(?: re) |
类似 (…), 但是不表示一个组 |
(?imx: re) |
在括号中使用i, m, 或 x 可选标志 |
(?-imx: re) |
在括号中不使用i, m, 或 x 可选标志 |
(?#...) |
注释. |
(?= re) |
前向肯定界定符。如果所含正则表达式，以 … 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。 |
(?! re) |
前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功。 |
(?> re) |
匹配的独立模式，省去回溯。 |
\w |
匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]'。 |
\W |
匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]’。 |
\s |
匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。 |
\S |
匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 |
\d |
匹配任意数字，等价于 [0-9]。 |
\D |
匹配一个非数字字符。等价于 [^0-9]。 |
\A |
匹配字符串开始 |
\Z |
匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。 |
\z |
匹配字符串结束 |
\G |
匹配最后匹配完成的位置。 |
\b |
匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配"never" 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。 |
\B |
匹配非单词边界。‘er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。 |
\n, \t, 等。 |
匹配一个换行符。匹配一个制表符, 等 |
\1...\9 |
匹配第n个分组的内容。 |
\10 |
匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。 |
2.Priority
| 运算符 | 描述 |
|---|---|
\ |
转义符 |
(), (?:), (?=), [] |
圆括号和方括号 |
*, +, ?, {n}, {n,}, {n,m} |
限定符 |
^, $, \任何元字符、任何字符 |
定位点和序列（即：位置和顺序） |
3.Demo
3.1 普通字符
import re
a = "abc123+-*"
b = re.findall('abc',a)
print(b)
3.2 中括号
s = "a123456b"
rule = "a[0-9][1-6][1-6][1-6][1-6][1-6]b" #这里暂时先用这种麻烦点的方法，后面有更容易的，不用敲这么多[1-6]
l = re.findall(rule,s)
print(l)
['a123456b']
s = "abcabcaccaac"
rule = "a[a,b,c]c" # rule = "a[a-z0-9][a-z0-9][a-z0-9][a-z0-9]c"
l = re.findall(rule, s)
print(l)
['abc', 'abc', 'acc', 'aac']
print(re.findall("caa[a，^]", "caa^bcabcaabc"))
['caa^']
print(re.findall("caa[^,a]", "caa^bcabcaabc"))
['caa^', 'caab']
3.3 首字母匹配
print(re.findall("^abca", "abcabcabc"))
['abca']
3.4 结尾匹配
print(re.findall("abc$", "accabcabc"))
['abc']
3.5 反斜杠
- \d:匹配任何十进制数等价于[0-9]
print(re.findall("c\d\d\da", "abc123abc"))
['c123a']
- \可以转义成普通字符
print(re.findall("\^abc", "^abc^abc"))
['^abc', '^abc']
- \s:匹配任何的空白字符
print(re.findall("\s\s", "a c"))
[' ', ' ']
- \w匹配任何字母数字和下划线，等价于[a-zA-Z0-9_]
print(re.findall("\w\w\w", "abc12_"))
['abc', '12_']
3.6 {n}
- {n}可以避免重复写，比如前面我们用\w时写了3次\w，而这里我们这需要用用上{n}就可以，n表示匹配的次数
print(re.findall("\w{2}", "abc12_"))
['ab', 'c1', '2_']
3.7 *
- *表示匹配零次或多次（尽可能的多去匹配）
print(re.findall("010-\d*", "010-123456789"))
['010-123456789']
3.8 +
- +表示匹配一次或多次
print(re.findall("010-\d+", "010-123456789"))
['010-123456789']
3.9 .
- .用来操作除了换行符以外的任何字符
print(re.findall(".", "010\n?!"))
['0', '1', '0', '?', '!']
3.10 ?
- ？表示匹配一次或零次
print(re.findall("010-\d?", "010-123456789"))
['010-1']
- 贪婪模式：尽可能多的去匹配数据，表现为\d后面加某个元字符，例如\d*
print(re.findall("010-\d*", "010-123456789"))
['010-123456789']
- 非贪婪模式：尽可能少的去匹配数据，表现为\d后面加？，例如\d?
print(re.findall("010-\d*?", "010-123456789"))
['010-']
3.11 {m,n}
- m,n指的是十进制数,表示最少重复m次，最多重复n次
print(re.findall("010-\d{3,5}", "010-123456789"))
['010-12345']
- 加上？表示尽可能少的去匹配
print(re.findall("010-\d{3,5}?", "010-123456789"))
['010-123']
灵活用法：
{1,} 相当于前面提过的 + 的效果{0，1} 相当于前面提过的 ？ 的效果{0，} 相当于前面提过的 * 的效果
4.Share
4.1 compile
s = "010-123456789"
rule = "010-\d*"
rule_compile = re.compile(rule) #返回一个对象
# print(rule_compile)
s_compile = rule_compile.findall(s)
print(s_compile) #打印compile()返回的对象是什么
['010-123456789']
4.2 other methods
- findall()
找到re匹配的所有字符串，返回一个列表- search()
扫描字符串，找到这个re匹配的位置（仅仅是第一个查到的）- match()
决定re是否在字符串刚开始的位置（匹配行首）
s = "010-123456789"
rule = "010-\d*"
rule_compile = re.compile(rule) # 返回一个对象
# print(rule_compile)
s_compile = rule_compile.match(s)
print(s_compile) # 打印compile()返回的对象是什么
<re.Match object; span=(0, 13), match='010-123456789'>
5.Re model
- findall()
前面很多demo
- sub(正则,新字符串,原字符串)
s = "abcabcacc" #原字符串
l = re.sub("abc","ddd",s) #通过sub()处理过的字符串
print(l)
ddddddacc
- subn(正则,新字符串,原字符串)
s = "abcabcacc" #原字符串
l = re.subn("abc","ddd",s) #通过sub()处理过的字符串
print(l)
('ddddddacc', 2)
- split()
s = "abcabcacc"
l = re.split("b",s)
print(l)
['a', 'ca', 'cacc']
本文含有隐藏内容，请 开通VIP 后查看