re正则表达式：数据解析

正则匹配 re 模块
一、扩展表示法
1、(?iLmsux)：
i：忽略大小
L：
m：Multiline - 多行模式
s：Singleline - 单行模式
u：表示和问号的作用差不多，用于设置"贪婪模式"。
x：忽略正则表达式中的空白字符，除非它已经被转义。
示例：
c = re.findall('(?i)to','welcom to china,Tom,t中,国家,t-m,t_m,123,')
print(c)    # ['to', 'To']
c = re.findall('(?ix)t o','welcom to china,Tom,t中,国家,t-m,t_m,123,t o')
print(c)    # ['to', 'To']
c = re.findall('(?ix)t\ o','welcom to china,Tom,t中,国家,t-m,t_m,123,t o')
print(c)    # ['t o']
c = re.findall('(?iu)t','welcom to china,Tom,t中,国tt家,t-m,t_m,123,t o')
print(c)    # ['t', 'T', 't', 't', 't', 't', 't', 't']
2、(?:...)：表示一个匹配不用保存的分组  ？
c = re.findall('(?P<number>\d+)','welcom to china,Tom,t2中,国家,t-m,t_m,123,')
print(c)    # ['2', '123']
3、(?P<name>...)：给正则分组匹配标识为 name，还不是数字 ID 标识
4、(?P=name)：在同一字符串中匹配邮 (?P<name>) 分组的之前文本
5、(?#...)：表示注释，所有内容都被忽略
6、(?=...)：匹配条件条件是如果...出现在之后的位置，而不使用输入字符串；称作正向前视断言
7、(?!...)：匹配条件条件是如果...不出现在之后的位置，而不使用输入字符串；称作负向前视断言
8、(?<=...)：匹配条件条件是如果...出现在之前的位置，而不使用输入字符串；称作正向后视断言
9、(?<!...)：匹配条件条件是如果...不出现在之前的位置，而不使用输入字符串；称作负向后视断言
10、(?(id/name)Y|N)：如果分组所提供的 id 或 name 存在，就返回正则表达式的条件匹配 Y，如果不存在，就返回 N；|N 是可选项
二、match(pattern,str[,flags])
匹配字符串开始位置，没有匹配到则返回 None，匹配成功则返回匹配的对象
# 通过 group() 取出匹配的字符串，通过 span() 来取出匹配的位置，start() 取匹配到的开始位置，end() 取匹配到的结束位置
# 一般用来判断是否是以什么开头的
c = re.match('to','welcom to china')
print(c)    # None
c = re.match('to','tos china s')
print(c)            # <_sre.SRE_Match object; span=(0, 2), match='to'>
print(c.string)     # tos china s
print(c.group())    # to
c = re.match('\d+','123tos china 321s')
print(c.group())    # 123
print(c.span())     # (0,3)
print(c.start())    # 0
print(c.end())      # 3
c = re.match('\d+.*','123tos china 321s')
print(c.group())    # 123tos china 321s
c = re.match('(\d+).*','123tos china 321s')
print(c.group())    # 123tos china 321s
print(c.group(1))   # 123
line = "Cats are smarter than dogs"
matchObj = re.match(r'(.*) are (.*?) .*', line, re.M | re.I)
print(matchObj)             # <_sre.SRE_Match object; span=(0, 26), match='Cats are smarter than dogs'>
print(matchObj.group())     # Cats are smarter than dogs
print(matchObj.group(1))    # Cats
print(matchObj.group(2))    # smarter
三、search(pattern, str[, flags])
匹配字符串，返回第一个匹配成功的对象，不成功则返回 None。
line = "Cats are smarter than dogs";
searchObj = re.search(r'(.*) are (.*?) .*', line, re.M | re.I)
print(searchObj.group())    # Cats are smarter than dogs
print(searchObj.group(1))   # Cats
print(searchObj.group(2))   # smarter
四、sub(pattern, repl, string, count=0, flags=0)：检索并替换
参数：
pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
phone = "2004-959-559 |# 这是一个国外电话号码"
# 删除字符串中的 Python注释
num = re.sub(r'#.*$', "", phone)
print("电话号码是: ", num)       # 电话号码是:  2004-959-559 |
# 删除非数字(-)的字符串
num = re.sub(r'\D', "", phone)
print("电话号码是 : ", num)      # 电话号码是 :  2004959559
五、compile(pattern[, flags])：用于编译正则表达式，生成一个正则表达式（ Pattern ）对象
参数：
pattern : 一个字符串形式的正则表达式
flags : 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：
re.I 忽略大小写
re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
re.M 多行模式
re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X 为了增加可读性，忽略空格和 # 后面的注释
六、findall(string[, pos[, endpos]])
匹配所有符合条件的子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
参数：
string : 待匹配的字符串。
pos : 可选参数，指定字符串的起始位置，默认为 0。
endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。
pattern = re.compile(r'\d+')  # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)
print(result1)  # ['123', '456']
print(result2)  # ['88', '12']
七、finditer(pattern, string, flags=0)
在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
it = re.finditer(r"\d+","12a32bc43jf")
for match in it:
print (match.group() )
# 输出
12
32
43
八、split(pattern, string[, maxsplit=0, flags=0])
split 方法按照能够匹配的子串将字符串分割后返回列表
参数：
pattern  匹配的正则表达式
string  要匹配的字符串。
maxsplit  分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
flags  标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志
c = re.split('\W+', 'runoob, runoob, runoob.')
print(c)    # ['runoob', 'runoob', 'runoob', '']
c = re.split('(\W+)', ' runoob, runoob, runoob.')
print(c)    # ['', ' ', 'runoob', ', ', 'runoob', ', ', 'runoob', '.', '']
c = re.split('\W+', ' runoob, runoob, runoob.', 1)
print(c)    # ['', 'runoob, runoob, runoob.']
c = re.split('a*', 'hello world')   # 对于一个找不到匹配的字符串而言，split 不会对其作出分割
print(c)    # ['hello world']
================================================================================================
一、特殊字符匹配：\b 和 \B
# \b：匹配一个单词的边界；\B：匹配一个单词的中间（即不是边界）
pattern = re.compile(r'er\b')
c = pattern.findall('erc')
print(c)    # []
c = pattern.findall('never')
print(c)    # ['er']
c = pattern.findall('very')
print(c)    # []
pattern = re.compile(r'er\B')
c = pattern.findall('erc')
print(c)    # ['er']
c = pattern.findall('never')
print(c)    # []
c = pattern.findall('very')
print(c)    # ['er']
二、范围匹配
[''-a]：ASCII 码中，所有字符都位于 "" 和 a 之间，即 34~97 之间
三、闭包操作符：*  +
*：Kleene 闭包，匹配 0 次或多次
+：正闭包，匹配 1 次或多次
注意：
?：表示匹配 0 次或 1 次
? 跟在闭包操作符后，表示在匹配成功的前提下，尽可能少的匹配
四、html 标签匹配
</?[^>]+>
五、扩展表示法
(?:\w+\.)*：匹配以句点作为结尾的字符串，如"google."、"baidu."，但这些匹配不会保存下来供后续的使用和数据检索
(?#comment)：此处不做匹配，只是作为注释
(?=.com)：匹配后面带有 .com 的字符串
(?!.net)：匹配后面不带 .net 的字符串
(?<=800-)：匹配前面带有 800- 的字符串
(?<!192\.168\.)：匹配前面不带有 192.168. 的字符串
(?(1)y|x)：如果一个匹配组 1（\1）存在，就与 y 匹配，否则与 x 匹配