2/re.match()

从头开始匹配:
    如果匹配不上，则直接返回None
    如果匹配成功，则返回目标字符串的位置(开始位置，结束位置)
re.match()函数的基本语法是：
     re.match(pattern,string,flags=0)
re.match()函数的参数解释：
    <1> pattern： 匹配的正则表达式（某种模式，就是你希望从string中匹配出来的模式）
    <2> string：要匹配的字符串
    <3> flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
        说白了就是一些参数，这些参数可以对match()函数起到一定的影响。
        re.I是是否区分大小写，
        re.M是否匹配多行
import re 
print(re.match('www', 'www.runoob.com').span()) 
print(re.match('com', 'www.runoob.com')) 
#以下实例运行输出结果为：
#(0,3)  返回的是位置index下标
#None   string中虽然也有com，但是由于com不是在字符串的起始位置，所以也匹配不上，返回None.
3/re.search()
re.search()函数扫描`整个字符串`，并返回`第一个`成功的匹配。
切记：该函数是扫描整个字符串，而不是像match()函数那样只匹配字符串的起始位置。
     并且该函数只返回第一个匹配成功的。
函数语法：
    re.search(pattern,string,flags=0)
函数参数说明：
   <1>pattern : 匹配的正则表达式（某种模式，就是你希望从string中匹配出来的模式）
   <2>string  : 要匹配的字符串。
   <3>flags   : 标志位，用于控制正则表达式的匹配方式，
                如：是否区分大小写flags=re.I，
                   多行匹flags=re.M等。
                说白了就是一些参数，这些参数可以对match()函数起到一定的影响。
import re
print(re.search('www', 'www.runoob.com').span())   
print(re.search('com', 'www.runoob.com').span()) 
#以上实例运行输出结果为：
#(0, 3)  # 返回的是位置index下标
#(11, 14)
4/re.match()与re.search()的区别
re.match()是只匹配string的开始位置，如果开始位置没有（即使string的后面有），就返回None
re.search()是扫描整个string，返回第一个，即使有多个匹配，也只返回第一个。
5/补充一点函数中的标志位flags
6/re.sub()
先检索，再替换，最后返回替换后的结果
# 如果检索出来多个，至于替换一部分还是全部替换，可以由count参数决定。
Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。
   re.sub(pattern,repl,string,count=0,flags=0)
参数解释：
    - pattern : 正则中的模式字符串。
    - repl : 替换的字符串，也可为一个函数。 这一点很重要
    - string : 要被查找替换的原始字符串。(也就是输入的字符串)
    - count : 模式匹配后替换的最大次数，默认为0，表示全部替换
import re 
phone = "2004-959-559  # 这是一个国外电话号码" 
# 删除字符串中的 Python注释 
# .表示任何一位字符，*表示前面的字符匹配0次或多次，$是匹配结尾
num = re.sub(r'#.*$', "", phone) 
print( "电话号码是: ", num  )
# 删除非数字(-)的字符串 
# \d是任意数字，及[0-9]
# \D是任意非数字
num =  re.sub(r'\D', "", phone)  # 把所有不是数字的字符都替换为""，及都干掉
print( "电话号码是 : ", num )
# 以上实例执行结果如下：
# 因为-不是字符，所以都干掉了
# 电话号码是:  2004-959-559 
# 电话号码是 :  2004959559
# 实例2  repl参数是一个函数
# 以下实例中将字符串中的匹配的数字乘以 2：
import re 
# 将匹配的数字乘以 2 
def func_double(matched): 
  value = int(matched.group('value')) 
  return str(value * 2) 
string = 'A23G4HFD567' 
re.sub('(?P<value>\d+)', func_double, string) 
#执行输出结果为：
#A46G8HFD1134
#?P<value>是组名
6/re.compile()
re.compile()函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，
供 match() 和 search() 这两个函数使用。
语法格式为：
   re.compile(pattern[, flags])
参数解释：
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 为了增加可读性，忽略空格和 # 后面的注释
   import re 
   pattern = re.compile(r'\d+') # 用于匹配至少一个数字
   m = pattern.match('one12twothree34four') # 查找头部，没有匹配  
   print(m)
   m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配，没有匹配
   print(m)
   m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配 
   print m 
   # 返回一个 Match 对象 <_sre.SRE_Match object at 0x10a42aac0> >>> m.group(0) # 可省略 0 '12' >>> m.start(0) # 可省略 0 3 >>> m.end(0) # 可省略 0 5 >>> m.span(0) # 可省略 0 (3, 5)
在上面，当匹配成功时返回一个 Match 对象，其中：
-   `group([group1, …])` 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 `group()` 或 `group(0)`；
-   `start([group])` 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
-   `end([group])` 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
-   `span([group])` 方法返回 `(start(group), end(group))`。
再看看一个例子：
   import re 
   pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I) # re.I 表示忽略大小写
   m = pattern.match('Hello World Wide Web') 
   print m # 匹配成功，返回一个 Match 对象 <_sre.SRE_Match object at 0x10bea83e8> 
   m.group(0) # 返回匹配成功的整个子串 'Hello World' 
   m.span(0) # 返回匹配成功的整个子串的索引 (0, 11) 
   m.group(1) # 返回第一个分组匹配成功的子串 'Hello' 
   m.span(1) # 返回第一个分组匹配成功的子串的索引 (0, 5) 
   m.group(2) # 返回第二个分组匹配成功的子串 'World' 
   m.span(2) # 返回第二个分组匹配成功的子串 (6, 11) 
   m.groups() # 等价于 (m.group(1), m.group(2), ...) ('Hello', 'World') 
   m.group(3) # 不存在第三个分组 Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: no such group
7/re.findall()
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表[]。
注意：match()函数 和 search()函数都只是匹配一次，而findall()函数是匹配所有。
语法格式为：
    findall(string[, pos[, endpos]])
    string : 待匹配的字符串。
    pos : 可选参数，指定字符串的起始位置，默认为 0。
    endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。
import re 
# 先构建一个正则表达式对象
pattern = re.compile(r'\d+') # 查找数字 ，一位或者多位
result1 = pattern.findall('runoob 123 google 456') 
result2 = pattern.findall('run88oob123google456', 0, 10) 
print(result1) 
print(result2)
#输出结果：
#['123', '456']
#['88', '12']
# 可以看出来，findall()不能返回index
input  = '我在清华读书，我在清华食堂吃饭'
pattern = re.compile(r'清华')
a = pattern.findall(input)
print(a)
['清华','清华']
第二种写法：
import re
s = "Long live the people's Republic of China"
ret = re.findall('h', s)  # 在s中找'h'
print(ret)
#结果是['h','h']
s = "Long live the people's Republic of China"
ret = re.findall('USA', s)  # 在s中找'USA'
print(ret)
#结果是 []
s = "https://blog.csdn.net/weixin_44799217"
ret = re.findall(r"^http", s)
print(ret)
ret2 = re.findall(r"[t,b,s]", s)  # 匹配括号中的其中一个字符
print(ret2)
ret3 = re.findall(r"\d\d\d", s)
print(ret3)
ret4 = re.findall(r"\d", s)
print(ret4)
ret5 = re.findall(r"[^\d]", s)  # 取非
print(ret5)
ret6 = re.findall(r"[^https://]", s)  # 取非
print(ret6)
9/re.split()
re.split()函数方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
   re.split(pattern, string[, maxsplit=0, flags=0])
   <1>pattern  ：匹配的正则表达式
   <2>string   ：要匹配的字符串。
   <3>maxsplit ：分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
   <4>flags    ：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等
import re 
re.split('\W+', 'runoob, runoob, runoob.')
['runoob', 'runoob', 'runoob', ''] 
re.split('(\W+)', ' runoob, runoob, runoob.')
['', ' ', 'runoob', ', ', 'runoob', ', ', 'runoob', '.', ''] 
re.split('\W+', ' runoob, runoob, runoob.', 1)
['', 'runoob, runoob, runoob.'] 
re.split('a*', 'hello world') 
# 对于一个找不到匹配（分割符）的字符串而言，split 不会对其作出分割 ['hello world']
10/正则表达式修饰符 - 可选标志
正则表达式可以包含一些可选标志修饰符来控制匹配的模式。
修饰符被指定为一个可选的标志。
多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志:
11/正则表达式模式
模式字符串使用特殊的语法来表示一个正则表达式：
字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
多数字母和数字前加一个反斜杠时会拥有不同的含义。
标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
反斜杠本身需要使用反斜杠转义。
由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'\t'，等价于 '\\t')匹配相应的特殊字符。
下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。
^       | 匹配字符串的开头
$       | 匹配字符串的末尾。
.       | 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]   | 用来表示一组字符,单独列出：[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       | 匹配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          | 匹配字母数字及下划线                                                         \W          | 匹配非字母数字及下划线                                                       \s          | 匹配任意空白字符，等价于 [ \t\n\r\f]。                                       \S          | 匹配任意非空字符                                                             \d          | 匹配任意数字，等价于 [0-9].                                                 \D          | 匹配任意非数字                                                             \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个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。
12/正则表达式实例
#### 字符匹配
| 实例     | 描述           |
| ------ | ------------ |
| python | 匹配 "python". |
#### 字符类
| 实例          | 描述                      |
| ----------- | ----------------------- |
| [Pp]ython   | 匹配 "Python" 或 "python"  |
| rub[ye]     | 匹配 "ruby" 或 "rube"      |
| [aeiou]     | 匹配中括号内的任意一个字母           |
| [0-9]       | 匹配任何数字。类似于 [0123456789] |
| [a-z]       | 匹配任何小写字母                |
| [A-Z]       | 匹配任何大写字母                |
| [a-zA-Z0-9] | 匹配任何字母及数字               |
| [^aeiou]    | 除了aeiou字母以外的所有字符        |
| [^0-9]      | 匹配除了数字外的字符              |
#### 特殊字符类
| 实例 | 描述                                                      |
| -- | ------------------------------------------------------- |
| .  | 匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。 |
| \d | 匹配一个数字字符。等价于 [0-9]。                                     |
| \D | 匹配一个非数字字符。等价于 [^0-9]。                                   |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。              |
| \S | 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。                           |
| \w | 匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。                       |
| \W | 匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。
复制代码
  分类：
 代码人生
 标签：
 正则表达式Python
 
   
      安装掘金浏览器插件
     多内容聚合浏览、多引擎快捷搜索、多工具便捷提效、多模式随心畅享，你想要的，这里都有！
 前往安装
      
    HZ在掘金
        数据挖掘工程师 @ aa