python3基础知识复习 --正则表达式(RE)
正则表达式 (import re)
https://docs.python.org/zh-cn/3.9/howto/regex.html
正则表达式（Regular expressions 也称为 REs，或 regexes 或 regex patterns）本质上是一个微小的且高度专业化的编程语言。它被嵌入到 Python 中，并通过 re 模块提供给程序猿使用。
- Re.search() – 用于在字符串中搜索正则表达式第一次出现的位置，匹配成功显示位置和target，否则什么都没有
re.search(r'p', 'apple')
<re.Match object; span=(1, 2), match='p'>
-
正则表达式默认区分大小写，后面需要该XXXX
-
元字符并不能匹配自身，需要"\元字符"来匹配自身，元字符列表 . ^ $ + ? { } [ ] \ | ( )
-
Re.findall(r'[a-z]', 'Peanutfish')— 查到所有满足条件的字符并以列表形式返回
字符匹配
“.” 通配符
匹配除了换行符外的任意一个字符,**如果设置了 re.DOTALL 标志，.将匹配包括换行符在内的任何字符。
re.search(r'p.', 'apple')
“\”用法
| \ | 1. 将一个普通字符变成特殊字符，例如\d表示匹配所有十进制数字 2. 解除元字符的特殊功能，例如\.表示匹配点号本身 3. 引用序号对应的子组所匹配的字符串 |
|---|
反斜杠真牛逼，反斜杠后边跟元字符去除特殊功能，反斜杠后边跟普通字符实现特殊功能。
如果要搜索".“，需要在前面加”\"
re.search(r’\.', ‘apple.com’)
| 特殊字符 | 含义 |
|---|---|
| \d | 匹配任何十进制数字；相当于类[0-9] |
| \D | 与\d相反，匹配任何非十进制数字的字符；相当于类[^0-9] |
| \s | 匹配任何空白字符（包含空格、换行符、制表符等）；相当于类[ \t\n\r\f\v] |
| \S | 与\s相反，匹配任何非空白字符；相当于类[^ \t\n\r\f\v] |
| \w | 匹配任何单词字符。如果正则表达式以字节的形式表示，这相当于字符类[a-zA-Z0-9_]；如果正则表达式是一个字符串，\w会匹配所有 Unicode 数据库（unicodedata 模块提供）中标记为字母的字符。re.ASCII 标志使得 \w 只能匹配 ASCII 字符，不要忘了，Python3 是 Unicode 的。 |
| \W | 于\w相反 |
| \b | 匹配单词的开始或结束，即一个单词边界，单词被定义为 Unicode 的字母数字或下横线字符 举个栗子：\bFishC\b会匹配字符串 "love FishC"、FishC." 或 "(FishC)" |
| \B | 与\b相反 |
它们可以包含在一个字符类中，并且一样拥有特殊含义。例如[\s,.]是一个字符类，它将匹配任何空白字符（\s的特殊含义），‘,‘或’.’。
“\d” — 匹配任意一个数字，匹配多个使用"\d\d\d…"
re.search(r’\d\d\d’, ‘I have 256 iphones’)
*关于反斜杠的用法 *3. 引用序号对应的子组所匹配的字符串
| \序号 | 1. 引用序号对应的子组所匹配的字符串，子组的序号范围从 1 - 99开始计算 2. 如果序号是以 0 开头，或者 3 个数字的长度表示的是八进制数，表示这个八进制数表示的ASCII对应的字符。那么不会被用于引用对应的子组，而是用于匹配八进制数字所表示的 ASCII 码值对应的字符 |
|---|
# 比较好理解的解释方法学会了，粘贴在这里方便以后的朋友：
（原帖地址https://www.cnblogs.com/gddcz/p/9131597.html）
关于正则表达式 \1 \2之类的问题
我们创建一个正则表达式
var RegExp = /^(123)(456)\2\1$/;
这个正则表达式匹配到的字符串就是
123456456123
创建另外第二正则表达式
var RegExp1 = /^(123)(456)\1$/;
这个正则表达式匹配到的字符串是
123456123
创建另外第三正则表达式
var RegExp1 = /^(123)(456)\2$/;
这个正则表达式匹配到的字符串是
123456456
这个\1 \2...... 都要和正则表达式集合()一起使用
简单的说就是
\1表示重复正则第一个圆括号内匹配到的内容
\2表示重复正则第二个圆括号内匹配到的内容
…
"""
# 三位数的时候表示八进制代表的ascii，101(o)-->65(d)-->A
>>> re.search(r'(123)\101', '123A')
<re.Match object; span=(0, 4), match='123A'>
"[]"字符类
“[]” — 两个元字符创建一个字符类，用来表示范围，匹配该类中任意一个数字就是匹配
注1：连字符 - 如果出现在字符串中间表示字符范围描述；如果如果出现在首位则仅作为普通字符
注2：特殊字符仅有反斜线 \ 保持特殊含义，用于转义字符。其它特殊字符如 *、+、? 等均作为普通字符匹配，r’[\n]’ — 表示匹配转义字符回车
注3：脱字符 ^ 如果出现在首位则表示匹配不包含其中的任意字符，例如 [^5] 会匹配除了 '5' 之外的任何字符；如果 ^ 出现在字符串中间就仅作为普通字符匹配
>>> re.search(r'^Pea', 'Peanut.com')
<re.Match object; span=(0, 3), match='Pea'>
>>> re.search(r'[^5]', '552345')
<re.Match object; span=(2, 3), match='2'>
"$" --- 匹配输入字符的结束位置
>>> re.search(r'pea$', 'This is pea')
<re.Match object; span=(8, 11), match='pea'>
Re.search(r'[0-9]', '1234') --- 注意只能匹配一个数字0-9，[0-255]并不能匹配0-255，而是匹配0-2,和5和5的一个数字
>>> re.search(r'[0-255]', '188')
<re.Match object; span=(0, 1), match='1'>
>>> re.search(r'[0-255]', '358')
<re.Match object; span=(1, 2), match='5'>
re.search(r'[a-zA-Z]', 'The pig')
<re.Match object; span=(0, 1), match='T'>
重复的事情
区别：
* 匹配的是零次或者多次，所以被重复的内容可能压根儿不会出现；例如 ca*t 将匹配 ct（0 个字符 a），cat（1 个字符 a），caaat（3 个字符 a）…
+ 匹配至少需要出现一次。例如 ca+t 会匹配 cat 和 caaat，但不会匹配 ct。
? 匹配前一个字符匹配零次或者一次。你可以这么想，它的作用就是把某种东西标志位可选的。例如 小?甲鱼 可以匹配 小甲鱼，也可以匹配 甲鱼
C 语言的 int 类型大小的内部限制，正则表达式引擎会限制字符 ‘a’ 的重复个数不超过 20 亿个.
正则表达式默认的重复规则是贪婪的，当你重复匹配一个 RE 时，匹配引擎会尝试尽可能多的去匹配。直到 RE 不匹配或者到了结尾，匹配引擎就会回退一个字符，然后再继续尝试匹配。
EG:
先考虑一下表达式 a[bcd]*b，首先需要匹配字符 ‘a’，然后是零个到多个 [bcd]，最后以 ‘b’ 结尾。那现在想象一下，这个 RE 匹配字符串 abcbd 会怎样？
| 步骤 | 匹配 | 说明 |
|---|---|---|
| 1 | a | 匹配 RE 的第一个字符 ‘a’ |
| 2 | abcbd | 引擎在符合规则的情况下尽可能地匹配 [bcd]*，直到该字符串的结尾 |
| 3 | 失败 | 引擎尝试匹配 RE 最后一个字符 ‘b’，但当前位置已经是字符串的结尾‘’，所以失败告终 |
| 4 | abcb | 回退，所以 [bcd]* 匹配少一个字符 |
| 5 | 失败 | 再一次尝试匹配 RE 最后一个字符 ‘b’，但字符串最后一个字符是 ‘d’，所以失败告终 |
| 6 | abc | 再次回退，所以 [bcd]* 这次只匹配 ‘bc’ |
| 7 | abcb | 再一次尝试匹配字符 ‘b’，这一次字符串当前位置指向的字符正好是 ‘b’，匹配成功 |
最终，RE 匹配的结果是 abcb。
启用非贪婪模式：在表示重复次数的元字符后面加一个"?"表示非贪婪模式，
非贪婪的限定符 *?、+?、?? 或 {m,n}?，尽可能地匹配小的文本。
>>> re.search(r'a[bcd]*?b', 'abcbd')
<re.Match object; span=(0, 2), match='ab'>
最灵活的应该是元字符 {m,n}（m 和 n 都是十进制整数）
其实 *、+ 和 ? 都可以使用 {m,n} 来代替。{0,} 跟 * 是一样的；{1,} 跟 + 是一样的；{0,1} 跟 ? 是一样的。不过还是鼓励大家记住并使用 、+ 和 ?，因为这些字符更短并且更容易阅读。还有一个原因是匹配引擎对 ** + ? 做了优化，效率要更高些。
“{}” — 重复匹配的次数
>>> re.search(r'b{3}', 'abbbbbbbbbbbbbbbbc') --- 只要满足b有3次就能匹配
<re.Match object; span=(1, 4), match='bbb'>
Re.search(r'ab{3,5}c', 'xxxxxx') -- 匹配的b出现3到10次都可以，显示最大匹配字符串
>>> re.search(r'b{3,5}', 'abbbbbbbbbbbbbbbbc')
<re.Match object; span=(1, 6), match='bbbbb'>
编译正则表达式
正则表达式被编译为模式对象，该对象拥有各种方法供你操作字符串，如查找模式匹配或者执行字符串替换。
re.compile() 也可以接受 flags 参数，用于开启各种特殊功能和语法变化
>>> p = re.compile(‘ab*’, re.IGNORECASE)
>>> p
<_sre.SRE_Pattern object at 0x…>
*模式对象*，下面是其常用方法
| 方法 | 功能 |
|---|---|
| match() | 判断一个正则表达式是否从开始处匹配一个字符串 |
| search() | 遍历字符串，找到正则表达式匹配的第一个位置 |
| findall() | 遍历字符串，找到正则表达式匹配的所有位置，并以列表的形式返回 |
| finditer() | 遍历字符串，找到正则表达式匹配的所有位置，并以迭代器的形式返回 |
如果没有找到任何匹配的话，match() 和 search() 会返回 None；如果匹配成功，则会返回一个匹配对象（match object），包含所有匹配的信息：例如从哪儿开始，到哪儿结束，匹配的子字符串等等。
\>>> a = re.compile('[a-z]+')
\>>> a.match("")
\>>> print(a.match(""))
None
\>>> print(a.match("abc"))
<re.Match object; span=(0, 3), match='abc'>
Findall 用法
If there are no groups, return a list of strings matching the whole pattern. If there is exactly one group, return a list of strings matching that group. If multiple groups are present, return a list of tuples of strings matching the groups.
Eg1: download pic from tieba
import urllib.request
import re
import os
def get_html(url):
request = urllib.request.Request(url)
request.add_header('User-Agent', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.163 Safari/537.36')
html = urllib.request.urlopen(request).read().decode('utf-8')
return html
def download_pic(url):
html = get_html(url)
pic_addr = re.findall(r'bpic="([^"]+\.jpg)"', html) # () 自组的内容在使用findall时直接返回列表,多个自组就以元祖形式返回
for each in pic_addr:
name = each.split('/')[-1]
urllib.request.urlretrieve(each, os.getcwd()+os.sep+"tieba"+os.sep+name, None) #urlretrieve可直接下载
print('All pictures are saved!')
if __name__ == "__main__":
print('starting!')
url = "https://tieba.baidu.com/f?ie=utf-8&kw=%E6%A8%B1%E6%9C%A8%E8%8A%B1%E9%81%93&fr=search"
download_pic(url)
Eg2:''' list IP list from a website'''
import urllib.request
import re
url = "https://www.89ip.cn/"
request = urllib.request.Request(url)
request.add_header('User-Agent', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.163 Safari/537.36')
html = urllib.request.urlopen(request).read().decode('utf-8')
ip_re = re.compile(r'(?:(?:[01]?\d?\d|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d?\d|2[0-4]\d|25[0-5])') # (?:…)表示非捕获组，避免了findall的元祖返回
# ip_re = re.compile(r'\d+\.\d+\.\d+\.\d+')
ip_list = ip_re.findall(html)
for each in ip_list:
print(each)
匹配对象方法：
| 方法 | 功能 |
|---|---|
| group() | 返回匹配的字符串 |
| start() | 返回匹配的开始位置 |
| end() | 返回匹配的结束位置 |
| span() | 返回一个元组表示匹配位置（开始，结束） |
>>> a = re.compile(r'[0-9]')
>>> b = a.match('abcd1234')
>>> print(b)
None
>>> c= a.search('abcd1234')
>>> print(c)
<re.Match object; span=(4, 5), match='1'>
>>> c.group()
'1'
>>> c.start()
4
>>> c.end()
5
>>> c.span()
(4, 5)
在实际应用中，最常用的方式是将匹配对象存放在一个局部变量中，并检查其返回值是否为 None。
p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
print('Match found: ', m.group())
else:
print('No match')
编译标志
编译标志让你可以修改正则表达式的工作方式。
完整名和简写， 多个标志还可以同时使用（通过“|”），如：re.I | re.M 就是同时设置 I 和 M 标志。
下边列举一些支持的编译标志：
| 标志 | 含义 |
|---|---|
| ASCII, A | 使得转义符号如 \w，\b，\s 和 \d 只能匹配 ASCII 字符, 而不匹配完整的 Unicode 字符 |
| DOTALL, S | 使得 . 匹配任何符号，包括换行符 |
| IGNORECASE, I | 匹配的时候不区分大小写, 如果你不设置 LOCALE，则不会考虑语言（区域）设置这方面的大小写问题。 |
| LOCALE, L | 支持当前的语言（区域）设置, 使得 \w，\W，\b 和 \B 依赖当前的语言（区域）环境，而不是 Unicode 数据库。区域设置是 C 语言的一个功能，主要作用是消除不同语言之间的差异。例如你正在处理的是法文文本，你想使用 \w+ 来匹配单词，但是 \w 只是匹配 [A-Za-z] 中的单词，并不会匹配 ‘é’ 或 ‘ç’。如果你的系统正确的设置了法语区域环境，那么 C 语言的函数就会告诉程序 ‘é’ 或 ‘ç’ 也应该被认为是一个字符。当编译正则表达式的时候设置了 LOCALE 的标志，\w+ 就可以识别法文了，但速度多少会受到影响。 |
| MULTILINE, M | 多行匹配，影响 ^ 和 $. 通常 ^ 只匹配字符串的开头，而 $ 则匹配字符串的结尾。当这个标志被设置的时候，^ 不仅匹配字符串的开头，还匹配每一行的行首；& 不仅匹配字符串的结尾，还匹配每一行的行尾。 |
| VERBOSE, X (for ‘extended’) | 启用详细的正则表达式, 使用了这个标志，空格会被忽略（除了出现在字符类中和使用反斜杠转义的空格）；这个标志同时允许你在正则表达式字符串中使用注释，# 符号后边的内容是注释，不会递交给匹配引擎（除了出现在字符类中和使用反斜杠转义的 #）。 |
下边是使用 re.VERBOSE 的例子，大家看下正则表达式的可读性是不是提高了不少：
charref = re.compile(r"""
&[#] # 开始数字引用
(
0[0-7]+ # 八进制格式
| [0-9]+ # 十进制格式
| x[0-9a-fA-F]+ # 十六进制格式
)
; # 结尾分号
""", re.VERBOSE)
如果没有设置 VERBOSE 标志，那么同样的正则表达式会写成：
charref = re.compile("&#(0[0-7]+|[0-9]+|x[0-9a-fA-F]+);")
元字符 - 零宽断言
不匹配任何字符，只是简单地表示成功或失败。
\b 表示当前位置位于一个单词的边界，但 \b 并不能改变位置。因此零宽断言不应该被重复使用，因为 \b 并不会修改当前位置，所以 \b\b 跟 \b 是没什么两样的，
理解“改变位置”和“零宽断言”的意思？比如 abc 匹配完 a 之后，咱的当前位置就会移动，才能继续匹配 b*，依次类推**…但是 \babc *的话，\b* 表示当前位置在单词的边界（单词的第一个字母或者最后一个字母），这时候当前位置不会发生改变，接着将 a 与当前位置的字符进行匹配…*
|
或操作符，对两个正则表达式进行或操作。如果 A 和 B 是正则表达式，A | B 会匹配 A 或 B 中出现的任何字符。
使用 \| 或 [|] 来匹配 '|' 字符本身。
^
匹配字符串的起始位置。如果设置了 MULTILINE 标志，就会变成匹配每一行的起始位置。在 MULTILINE 中，每当遇到换行符就会立刻进行匹配。
>>> a = ‘’’ this is a test
from where you typed
to you come from’‘’
>>> r = re.compile(r’^from’, re.MULTILINE)
>>> r.search(a)
$
匹配字符串的结束位置，每当遇到换行符也会离开进行匹配。
>>> print(re.search(‘}$’, ‘{block}\n’))
<_sre.SRE_Match object; span=(6, 7), match=‘}’>
同样，我们使用 \$ or [$] 来匹配 '$' 字符本身.
\A
只匹配字符串的起始位置。如果没有设置 MULTILINE 标志的时候，\A 和 ^ 的功能是一样的；但如果设置了 MULTILINE 标志：\A 还是匹配字符串的起始位置，但 ^ 会对字符串中的每一行都进行匹配。
\Z
只匹配字符串的结束位置。同$一致
\b --> \B 相反，表示非单词边界
单词边界，这是一个只匹配单词的开始和结尾的零宽断言。“单词”定义为一个字母数字的序列，所以单词的结束指的是空格或者非字母数字的字符。
在使用这些特殊的序列的时候，有两点是需要注意的：第一点需要注意的是，Python 的字符串跟正则表达式在有些字符上是有冲突的（回忆之前反斜杠的例子）。比如说在 Python 中，\b 表示的是退格符（ASCII 码值是 8）。所以，你如果不使用原始字符串，Python 会将 \b 转换成退格符处理，这样就肯定跟你的预期不一样了。
下边的例子中，我们故意不写表示原始字符串的 'r'，结果确实大相庭径：
>>> p = re.compile('\bclass\b')
>>> print(p.search('\b' + 'class' + '\b'))
<_sre.SRE_Match object; span=(0, 7), match='\x08class\x08'>
“()” — 表示分组
Eg:查找IP, "|"表示或，[01]{0,1}表示数字0或1出现0次或一次，由于ip可以为个位数，所有前两位是重复{0,1}, ([01]{0,1}\d{0,1}\d|2[0-4]\d|25[0-5])是一个整体来匹配，这个整体加上"."重复3次{3}
>>> re.search(r'(([01]{0,1}\d{0,1}\d|2[0-4]\d|25[0-5])\.){3}([01]{0,1}\d{0,1}\d|2[0-4]\d|25[0-5])', '192.168.11.1')
<re.Match object; span=(0, 12), match='192.168.11.1'>
a = re.compile('(([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5]).){3}([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])')
a = re.compile('(([01]?\d?\d|2[0-4]\d|25[0-5]).){3}([01]?\d?\d|2[0-4]\d|25[0-5])')
>> 网页快速查找IP(但不保证满足IP要求)ip_re = re.compile(r'\d+\.\d+\.\d+\.\d+')
使用 ( ) 表示的子组我们还可以对它进行按层次索引，可以将索引值作为参数传递给这些方法：group()，start()，end() 和 span()。序号 0 表示第一个分组（这个是默认分组，一直存在的，所以不传入参数相当于默认值 0）, 序号1,2…表示子组：
提取子串非常有用。来看一个凶残的例子：
# 这个正则表达式可以直接识别合法的时间。
>>> t = '19:05:30'
>>> m = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', t)
>>> m.groups() # 返回所有子组
('19', '03', '02')
>>> m.group(0) # 返回完整结果
'19:03:02'
>>> m.group(1) # 返回第一个子组
'19'
>>> m.group(2) # 返回第二个子组
'03'
>>> m.group(3)
'02'
>>> m.group(4) # 没有第4个子组，报IndexError
Traceback (most recent call last):
File "" , line 1, in <module>
IndexError: no such group
正则表达式的扩展语法
非捕获组 (?:…)
有时候你只需要用一个组来表示部分正则表达式，你并不需要这个组去匹配任何东西，这时你可以通过非捕获组来明确表示你的意图。
>>> m = re.match("([abc])+", "abc")
>>> m.groups()
('c',)
>>> m = re.match("(?:[abc])+", "abc")
>>> m.groups()
()
除了你不能从非捕获组获得匹配的内容之外，其他的非捕获组跟普通子组没有什么区别了。你可以在里边放任何东西，使用重复功能的元字符，或者跟其他子组进行嵌套（捕获的或者非捕获的子组都可以）。
作用:
当你需要修改一个现有的模式的时候，(?:…) 是非常有用的。原始是添加一个非捕获组并不会影响到其他（捕获）组的序号。值得一提的是，在搜索的速度上，捕获组和非捕获组的速度是没有任何区别的。
命名组 (?P)
命名组除了有一个名字标识之外，跟其他捕获组是一样的。
匹配对象的所有方法不仅可以处理那些由数字引用的捕获组，还可以处理通过字符串引用的命名组。除了使用名字访问，命名组仍然可以使用数字序号进行访问：
>>> p = re.compile(r’(?P<word>\b\w+\b)')
>>> m = p.search( ‘(((( Lots of punctuation )))’ )
>>> m.group(‘word’)
‘Lots’
>>> m.group(1)
‘Lots’
命名组非常好用，因为它让你可以使用一个好记的名字代替一些毫无意义的数字。下边是来自 imaplib 模块的例子：
InternalDate = re.compile(r'INTERNALDATE "'
r'(?P[ 123][0-9])-(?P[A-Z][a-z][a-z])-'
r'(?P[0-9][0-9][0-9][0-9])'
r' (?P[0-9][0-9]):(?P[0-9][0-9]):(?P[0-9][0-9])'
r' (?P[-+])(?P[0-9][0-9])(?P[0-9][0-9])'
r'"')
很明显，使用 m.group(‘zonem’) 访问匹配内容要比使用数字 9 更简单明了。
正则表达式中，反向引用的语法像 (…)\1 是使用序号的方式来访问子组；在命名组里，显然也是有对应的变体：使用名字来代替序号。其扩展语法是 (?P=name)，含义是该 name 指向的组需要在当前位置再次引用。那么搜索两个单词的正则表达式可以写成 (\b\w+)\s+\1，也可以写成 (?P\b\w+)\s+(?P=word)：
>>> p = re.compile(r’(?P\b\w+)\s+(?P=word)')
>>> p.search(‘Paris in the the spring’).group()
‘the the’
前向断言
属于零宽断言，分为前向肯定断言和前向否定断言两种形式。
(?=…)
前向肯定断言。如果当前包含的正则表达式（这里以 … 表示）在当前位置成功匹配，则代表成功，否则失败。一旦该部分正则表达式被匹配引擎尝试过，就不会继续进行匹配了；剩下的模式在此断言开始的地方继续尝试。
(?!..)
前向否定断言。这跟前向肯定断言相反（不匹配则表示成功，匹配表示失败）。
eg:
匹配扩展名不是 bat 的文件
.*[.](?!bat$).*$
同时排除 bat 和 exe 扩展名
.*[.](?!bat$|exe$).*$
修改字符串
| 方法 | 用途 |
|---|---|
| split() | 在正则表达式匹配的地方进行分割，并返回一个列表 |
| sub() | 找到所有匹配的子字符串，并替换为新的内容 |
| subn() | 跟 sub() 干一样的勾当，但返回新的字符串以及替换的数目 |
分割字符串
re.split(string[, maxsplit=0])
正则表达式的 split() 方法将字符串在匹配的地方进行分割，并将分割后的结果作为列表返回。它的做法其实很像字符串的 split() 方法，但这个可以使用更加广泛的分隔符。你猜的没错，它同时提供了一个模块级别的函数：re.split()
如果在 RE 中，你使用了捕获组，那么它们的内容会作为一个列表返回。你可以通过传入一个 maxsplit 参数来设置分割的数量。如果 maxsplit 的值是非 0，表示至多有 maxsplit 个分割会被处理，剩下的内容作为列表的最后一个元素返回。
\>>> p = re.compile(r'\W+')
\>>> p.split('this is a test, short and sweet, of split().')
['this', 'is', 'a', 'test', 'short', 'and', 'sweet', 'of', 'split', '']
\>>> p.split('this is a test, short and sweet, of split().', 3)
['this', 'is', 'a', 'test, short and sweet, of split().']
用正则表达式切分字符串比用固定的字符更灵活，请看正常的切分代码：
>>> 'a b c'.split(' ')
['a', 'b', '', '', 'c']
嗯，无法识别连续的空格，用正则表达式试试：
>>> re.split(r'\s+', 'a b c')
['a', 'b', 'c']
>>> re.split(r'[\s\,]+', 'a,b, c d') # 加入","可以正常分割
['a', 'b', 'c', 'd']
>>> re.split(r'[\s\,\;]+', 'a,b;; c d') # 加入";"可以正常分割
['a', 'b', 'c', 'd']
如果用户输入了一组标签，下次记得用正则表达式来把不规范的输入转化成正确的数组。
搜索和替换
sub 方法有一个 replacement 参数，它可以是一个待替换的字符串，或者一个处理字符串的函数。
re.sub(replacement, string[, count=0])
subn() 方法跟 sub() 方法干同样的勾当，但区别是返回值为一个包含有两个元素的元组：一个是替换后的字符串，一个是替换的数目。
返回一个字符串，这个字符串从最左边开始，所有 RE 匹配的地方都替换成 replacement。如果没有找到任何匹配，那么返回原字符串。
可选参数 count 指定最多替换的次数，必须是一个非负值。默认值是 0，意思是替换所有找到的匹配。
下边例子中，将匹配被 { 和 } 括起来的单词 section，并将 section 替换成 subsection：
- >>> p = re.compile(‘section{ ( [^}]* ) }’, re.VERBOSE)
- >>> p.sub(r’subsection{\1}',‘section{First} section{second}’)
- ‘subsection{First} subsection{second}’
1. 大家还记得吗？这里开启了 re.VERBOSE，空格将被忽略。因为这里一堆符号，用空格隔开看着才不会乱糟糟的**…
2.*这里 r’subsection{\1}’ 使用 \1 引用匹配模式中的 ([^}]*) 匹配的字符串内容。
还可以使用 Python 的扩展语法 (?P…) 指定命名组，引用命名组的语法是 \g。\g 会将名字为 name 的组匹配的字符串替换进去。另外，\g<数字> 是通过组的序号进行引用。\g<2> 其实就相当于 \2，但我们更提倡使用 \g<2>，因为这样可以避免歧义。
>>> p = re.compile(r'section{ ( [^}]+ ) }', re.VERBOSE)
>>> p.sub(r'subsection{\1}', 'section{First}, section{second}')
'subsection{First}, subsection{second}'
>>> p = re.compile(r'section{(?P[^}]+)}' )
>>> p.sub(r'subsection{\1}', 'section{First}, section{Second}')
'subsection{First}, subsection{Second}'
>>> p.sub(r'subsection{\g}' , 'section{First}, section{Second}')
'subsection{First}, subsection{Second}'
>>> p.sub(r'subsection{\g<1>}', 'section{First}, section{Second}')
'subsection{First}, subsection{Second}'
另外replacement 还可以是一个函数，匹配得到的对象作为参数传给这个函数进行处理然后返回新的东西
>>> def hexrep(match):
value = int(match.group())
return hex(value)
>>> p = re.compile(r'\d+')
>>> p.sub(hexrep, '65536 is from 23456 girls and boys!')
'0x10000 is from 0x5ba0 girls and boys!'