正则表达式（re）的基本操作

1. 测试正则表达式的工具。

• 在线正则表达式测试：

http://tool.oschina.net/regex/

2. 常见的匹配模式

3. 常用的匹配方法

3.1. re.match

• re.match尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就会返回None

• 最常规的匹配

import re
content = "Hello 123 4567 World_This is a Regex Demo"
result = re.match("Hello\s\d\d\d\s\d{4}\s\w{10}.*Demo$",content)
print(f"len = {len(content)}")
print(f"result = {result}")
print(f"result.group() = {result.group()}") # 返回匹配结果
print(f"result.span = {result.span()}")     # 输出匹配结果的范围

# 输出结果
len = 41
result = <_sre.SRE_Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
result.group() = Hello 123 4567 World_This is a Regex Demo
result.span = (0, 41)

• 泛匹配

# 泛匹配
result = re.match("^Hello.*Demo$",content)

# 输出结果
len = 41
result = <_sre.SRE_Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
result.group() = Hello 123 4567 World_This is a Regex Demo
result.span = (0, 41)

• 匹配目标：如果我们想从字符串中获取我们想要的数据的话，我们就可以用一个（）把我们要的目标括起来，然后指定它的左端点和右端点。然后用group(n)将其取出来。

# 匹配目标
content = "Hello 1234567 World_This is a Regex Demo"

result = re.match("^Hello\s(\d+)\sWorld.*Demo$",content)
print(f"len = {len(content)}")
print(f"result = {result}")
print(f"result.group() = {result.group()}") # 返回匹配结果
print(f"result.span = {result.span()}")     # 输出匹配结果的范围
# 如果正则表达式中出现了()，那么第一个()里匹配的内容为group(1),第二个为group(2)，依次类推
print(f"result.group(1) = {result.group(1)}")

# 输出结果
len = 40
result = <_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
result.group() = Hello 1234567 World_This is a Regex Demo
result.span = (0, 40)
result.group(1) = 1234567 

• 贪婪匹配：

# 贪婪匹配：.*来匹配任意的字符串
# 结果只把 7 这个数字匹配出来了，前面的123456被前面的.*匹配掉了。
# 它会匹配尽可能多的字符，而后面(\d+)至少要有一个数字，那就匹配成了7
# .*会尽可能多的匹配，一直到匹配不到了为止
content = "Hello 1234567 World_This is a Regex Demo"

result = re.match("^He.*(\d+).*Demo$",content)
print(f"len = {len(content)}")
print(f"result = {result}")
print(f"result.group() = {result.group()}") # 返回匹配结果
print(f"result.span = {result.span()}")     # 输出匹配结果的范围
# 如果正则表达式中出现了()，那么第一个()里匹配的内容为group(1),第二个为group(2)，依次类推
print(f"result.group(1) = {result.group(1)}")

# 输出结果
len = 40
result = <_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
result.group() = Hello 1234567 World_This is a Regex Demo
result.span = (0, 40)
result.group(1) = 7

• 非贪婪匹配：

# 非贪婪匹配：.*后面加一个?  ———— .*?
# ? 会指定这个模式为非贪婪模式的匹配。它会匹配尽可能少的字符
# ?后面有个\d+，也就是说它要开始匹配一个数字了，那么如果它看到后面出现一个数字，那么他就会把前面的值进行匹配
# .*?会尽可能少的匹配，匹配到了就停止
content = "Hello 1234567 World_This is a Regex Demo"

result = re.match("^He.*?(\d+).*Demo$",content)
print(f"len = {len(content)}")
print(f"result = {result}")
print(f"result.group() = {result.group()}") # 返回匹配结果
print(f"result.span = {result.span()}")     # 输出匹配结果的范围
# 如果正则表达式中出现了()，那么第一个()里匹配的内容为group(1),第二个为group(2)，依次类推
print(f"result.group(1) = {result.group(1)}")

# 输出结果
len = 40
result = <_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
result.group() = Hello 1234567 World_This is a Regex Demo
result.span = (0, 40)
result.group(1) = 1234567

• 匹配模式：

# 在regex字符串中指定匹配模式，取值可以使用按位或运算符'|'表示同时生效，比如re.I | re.M。

# 匹配模式的可选值有：
    # re.I (re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
    # re.M (re.MULTILINE): 多行模式，改变'^'和'$'的行为
    # re.S (re.DOTALL): 点任意匹配模式，改变'.'的行为
    # re.L (re.LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
    # re.U (re.UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
    # re.X (re.VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。

content = '''Hello 1234567 World_This 
is a Regex Demo
'''
result = re.match("^He.*?(\d+).*Demo$",content)
print(f"result = {result}")
# 输出结果
result = None  # 因为 .*不能匹配This后面的换行符。

# ----------- 加上匹配模式 re.S : 多行匹配 ----------
result2 = re.match("^He.*?(\d+).*Demo$", content, re.S)
print(f"result2.group(1) = {result2.group(1)}")
# 输出结果
result2.group(1) = 1234567  # re.S可以多行匹配

• 转义符：

# 转义符
import re   
content = 'price is $5.00'
result = re.match('price is $5.00', content)
print(f"result = {result}")
# 输出结果
result = None  # 因为$和.是通配符，失去了原字符的意义

result = re.match('price is \$5\.00', content)
print(f"result = {result}")
# 输出结果
result = <_sre.SRE_Match object; span=(0, 14), match='price is $5.00'>

3.2. 正则匹配的原则

• 尽量使用泛匹配
• 使用括号得到匹配目标
• 尽量使用非贪婪模式
• 有换行符就用re.S
• 为匹配方便，能用search就不用match

3.3. re.search

• 由于re.match是从字符串开头进行匹配的，适用性不算强。
• re.search 是会对整个字符串进行扫描，返回第一个成功的匹配。

content = 'Extra strings Hello 1234567 World_This is a Regex Demo Extra strings'
result = re.search("Hello.*?(\d+).*?Demo", content)
print(f"result = {result}")
print(f"result.group(1) = {result.group(1)}")
# 输出结果
result = <_sre.SRE_Match object; span=(13, 53), match='Hello 1234567 World_This is a Regex Demo'>
result.group(1) = 1234567

3.4. re.findall

• 搜索字符串，以列表形式返回全部能匹配的子串
• 如果有多个括号()，那么返回的列表，元素是元组 [( ), ( ), ( ), ( )]

3.5. re.sub

• 替换字符串中每一个匹配的子串后，返回替换后的字符串

# re.findall 案例一
content = 'Extra strings Hello 1234567 World_This is a Regex Demo Extra strings'
content = re.sub('\d+', '', content)
print(f"content = {content}")
# 输出结果
content = Extra strings Hello  World_This is a Regex Demo Extra strings

# re.findall 案例二
content = 'Extra strings Hello 1234567 World_This is a Regex Demo Extra strings'
content = re.sub('\d+', 'Replacement', content)
print(f"content = {content}")
# 输出结果
content = Extra strings Hello Replacement World_This is a Regex Demo Extra strings

# 如果需求是替换字符串本身，或者说需要替换的字符串是有包含原字符串的话，则需要把匹配的字符串加上一个括号，然后用\1拿到匹配的内容。又因为\是转义字符，所以需要在前面加上一个r
# \1就是把匹配结果，换成括号1中的匹配结果
# re.findall 案例三
content = 'Extra strings Hello 1234567 World_This is a Regex Demo Extra strings'
content = re.sub('(\d+)', r'\1 8910', content)
print(f"content = {content}")
# 输出结果
content = Extra strings Hello 1234567 8910 World_This is a Regex Demo Extra strings

3.5.1. 一般操作模式

• 第一步：先用re.sub进行替换，修正原始字符串到一个比较有规律的模式。
• 第二步：再使用re.findall进行字符串匹配。

html = re.sub('<a.*?>|</a>', '', html)
print(html)
results = re.findall('<li.*?>(.*?)</li>', html, re.S)
print(results)
for result in results:
    print(result.strip())

3.6. re.compile

• 将正则字符串编译成正则表达式对象
• 为了方便重复使用固定的正则匹配模式，使用re.compile将一个正则表达式串编译成正则对象，以便于复用该匹配模式
• 第二个参数flag是匹配模式，取值可以使用按位或运算符’|’表示同时生效，比如re.I | re.M。另外，你也可以在regex字符串中指定模式，比如re.compile(‘pattern’, re.I | re.M)与re.compile(‘(?im)pattern’)是等价的。

# re.compile 案例一
content = 'Hello 1234567 World_This 
is a Regex Demo'
pattern = re.compile('Hello.*Demo', re.S)
result1 = re.match(pattern, content)
result2 = re.match('Hello.*Demo', content, re.S)