zoukankan      html  css  js  c++  java

  • python正则表达式findall的使用

    文章来源与：http://www.cnblogs.com/zjltt/p/6955965.html

    正则表达式

    正则表达式本身是一种小型的、高度专业化的编程语言，而在python中，通过内嵌集成re模块，程序员们可以直接调用来实现正则匹配。正则表达式模式被编译成一系列的字节码，然后由用C编写的匹配引擎执行。

    正则表达式是用来匹配处理字符串的 python 中使用正则表达式需要引入re模块

    如：

    import re #第一步，要引入re模块

    a = re.findall("匹配规则", "要匹配的字符串") #第二步，调用模块函数

    以列表形式返回匹配到的字符串

    如：

    复制代码
    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("匹配规则", "这个字符串是否有匹配规则的字符")   #第二步，调用模块函数
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规则']
    复制代码

    ^元字符

    字符串开始位置与匹配规则符合就匹配，否则不匹配

    匹配字符串开头。在多行模式中匹配每一行的开头

    ^元字符如果写到[]字符集里就是反取
    复制代码
    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("^匹配规则", "匹配规则这个字符串是否匹配")   #字符串开始位置与匹配规则符合就匹配，否则不匹配
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规则']
    复制代码
     
    [^a-z]反取，匹配出除字母外的字符，^元字符如果写到字符集里就是反取
    复制代码
    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("[^a-z]", "匹配s规则这s个字符串是否s匹配f规则则re则则则")   #反取，匹配出除字母外的字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']
    复制代码
    

    $元字符
    

    字符串结束位置与匹配规则符合就匹配，否则不匹配
    

    匹配字符串末尾，在多行模式中匹配每一行的末尾
    

    

    

    复制代码
    

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("匹配规则$", "这个字符串是否匹配规则")   #字符串结束位置与匹配规则符合就匹配，否则不匹配
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规则']
    

    复制代码
    

    

    


    *元字符
    

    需要字符串里完全符合，匹配规则，就匹配，（规则里的*元字符）前面的一个字符可以是0个或多个原本字符
    

    匹配前一个字符0或多次，贪婪匹配前导字符有多少个就匹配多少个很贪婪
    

    如果规则里只有一个分组，尽量避免用*否则会有可能匹配出空字符串
    

    

    

    复制代码
    

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("匹配规则*", "这个字符串是否匹配规则则则则则")   #需要字符串里完全符合，匹配规则，就匹配，（规则里的*元字符）前面的一个字符可以是0或多个原本字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规则则则则则']
    

    复制代码
    

    

    

    +元字符
    

    需要字符串里完全符合，匹配规则，就匹配，（规则里的+元字符）前面的一个字符可以是1个或多个原本字符
    

    匹配前一个字符1次或无限次，贪婪匹配前导字符有多少个就匹配多少个很贪婪
    

    

    

    复制代码
    

    #!/usr/bin/env python
# -*- coding:gbk -*-
import re   #第一步，要引入re模块
a = re.findall("匹配+", "匹配配配配配规则这个字符串是否匹配规则则则则则")   #需要字符串里完全符合，匹配规则，就匹配，（规则里的+元字符）前面的一个字符可以是1个或多个原本字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配配配配配', '匹配']
    

    复制代码
    

    

    

    ?元字符，和防止贪婪匹配
    

    需要字符串里完全符合，匹配规则，就匹配，（规则里的?元字符）前面的一个字符可以是0个或1个原本字符
    

    匹配一个字符0次或1次
    

    还有一个功能是可以防止贪婪匹配，详情见防贪婪匹配
    

    

    

    复制代码
    

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("匹配规则?", "匹配规这个字符串是否匹配规则则则则则")   #需要字符串里完全符合，匹配规则，就匹配，（规则里的?元字符）前面的一个字符可以是0个或1个原本字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规', '匹配规则']
    

    复制代码
    

    

    

    {}元字符,范围
    

    需要字符串里完全符合，匹配规则，就匹配，（规则里的 {} 元字符）前面的一个字符，是自定义字符数，位数的原本字符
    

    {m}匹配前一个字符m次，{m,n}匹配前一个字符m至n次，若省略n，则匹配m至无限次
    

    {0,}匹配前一个字符0或多次,等同于*元字符
    {+,}匹配前一个字符1次或无限次,等同于+元字符
    {0,1}匹配前一个字符0次或1次,等同于?元字符
    

    

    

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("匹配规则{3}", "匹配规这个字符串是否匹配规则则则则则")   #{m}匹配前一个字符m次，{m,n}匹配前一个字符m至n次，若省略n，则匹配m至无限次
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规则则则']
    

    
View Code
    

    []元字符,字符集
    

    需要字符串里完全符合，匹配规则，就匹配，（规则里的 [] 元字符）对应位置是[]里的任意一个字符就匹配
    

    字符集。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，如[abc]或[a-c]。[^abc]表示取反，即非abc。
    所有特殊字符在字符集中都失去其原有的特殊含义。用反斜杠转义恢复特殊字符的特殊含义。
    

    

    

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("匹配[a,b,c]规则", "匹配a规则这个字符串是否匹配b规则则则则则")   #需要字符串里完全符合，匹配规则，就匹配，（规则里的 [] 元字符）对应位置是[]里的任意一个字符就匹配
print(a)  #以列表形式返回匹配到的字符串
    

    
View Code
    

    [^]非，反取，匹配出除[^]里面的字符，^元字符如果写到字符集里就是反取

    

    

    

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("[^a-z]", "匹配s规则这s个字符串是否s匹配f规则则re则则则")   #反取，匹配出除字母外的字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']
    

    
View Code
    


    反斜杠后边跟普通字符实现特殊功能；（即预定义字符）
    

    预定义字符是在字符集和组里都是有用的
    

    d匹配任何十进制数，它相当于类[0-9]
    

    

    

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("d", "匹配规则这2个字符串3是否匹配规则5则则则7则")   #d匹配任何十进制数，它相当于类[0-9]
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['2', '3', '5', '7']
    

    
View Code
    

    d+如果需要匹配一位或者多位数的数字时用
    

    

    

    #!/usr/bin/env python
# -*- coding:gbk -*-
import re   #第一步，要引入re模块
a = re.findall("d+", "匹配规则这2个字符串134444是否匹配规则5则则则7则")   #d+如果需要匹配一位或者多位数的数字时用
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['2', '134444', '5', '7']
    

    
View Code
    

    D匹配任何非数字字符，它相当于类[^0-9]
    

    

    

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("D", "匹配规则这2个字符串3是否匹配规则5则则则7则")   #D匹配任何非数字字符，它相当于类[^0-9]
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']
    

    
View Code
    

    s匹配任何空白字符，它相当于类[	

fv]
    

    

    

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("s", "匹配规则   这2个字符串3是否匹
配规则5则则则7则")   #s匹配任何空白字符，它相当于类[	

fv]
print(a)  #以列表形式返回匹配到的字符串
#打印出[' ', ' ', ' ', '
']
    

    
View Code
    

    S匹配任何非空白字符，它相当于类[^	

fv]
    

    

    

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("S", "匹配规则   这2个字符串3是否匹
配规则5则则则7则")   #S匹配任何非空白字符，它相当于类[^	

fv]
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '规', '则', '这', '2', '个', '字', '符', '串', '3', '是', '否', '匹', '配', '规', '则', '5', '则', '则', '则', '7', '则']
    

    
View Code
    

    w匹配包括下划线在内任何字母数字字符，它相当于类[a-zA-Z0-9_]
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re   #第一步，要引入re模块
a = re.findall('w',"https://www.cnblogs.com/")  #w匹配包括下划线在内任何字母数字字符，它相当于类[a-zA-Z0-9_]
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['h', 't', 't', 'p', 's', 'w', 'w', 'w', 'c', 'n', 'b', 'l', 'o', 'g', 's', 'c', 'o', 'm']
    

    
View Code
    

    W匹配非任何字母数字字符包括下划线在内，它相当于类[^a-zA-Z0-9_]
    

    

    

    import re   #第一步，要引入re模块
a = re.findall('W',"https://www.cnblogs.com/")  #w匹配包括下划线在内任何字母数字字符，它相当于类[a-zA-Z0-9_]
print(a)  #以列表形式返回匹配到的字符串
#打印出[':', '/', '/', '.', '.', '/']
    

    
View Code
    

    ()元字符，分组
    

    也就是分组匹配，()里面的为一个组也可以理解成一个整体
    

    如果()后面跟的是特殊元字符如   (adc)*   那么*控制的前导字符就是()里的整体内容，不再是前导一个字符
    

    列1
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re   #第一步，要引入re模块
#也就是分组匹配，()里面的为一个组也可以理解成一个整体
a = re.search("(a4)+", "a4a4a4a4a4dg4g654gb")   #匹配一个或多个a4
b = a.group()
print(b)
#打印出 a4a4a4a4a4
    

    
View Code
    

     列2
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re   #第一步，要引入re模块
#也就是分组匹配，()里面的为一个组也可以理解成一个整体
a = re.search("a(d+)", "a466666664a4a4a4dg4g654gb")    #匹配 (a) (d0-9的数字) (+可以是1个到多个0-9的数字)
b = a.group()
print(b)
#打印出 a466666664
    

    
View Code
    


    |元字符，或
    

    |或，或就是前后其中一个符合就匹配
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re   #第一步，要引入re模块
a = re.findall(r"你|好", "a4a4a你4aabc4a4dgg好dg4g654g")   #|或，或就是前后其中一个符合就匹配
print(a)
#打印出 ['你', '好']
    

    
View Code
    


    r原生字符
    

    将在python里有特殊意义的字符如，转换成原生字符（就是去除它在python的特殊意义），不然会给正则表达式有冲突，为了避免这种冲突可以在规则前加原始字符r
    


    re模块中常用功能函数
    

    正则表达式有两种书写方式，一种是直接在函数里书写规则，
    

    

    

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入re模块
a = re.findall("匹配规则", "这个字符串是否有匹配规则的字符")   #第二步，调用模块函数
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规则']
    

    
View Code
    

    match()函数（以后常用）
    

    match，从头匹配一个符合规则的字符串，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
    match(pattern, string, flags=0)
    # pattern： 正则模型
    # string ： 要匹配的字符串
    # falgs ： 匹配模式
    

    注意：match()函数 与 search()函数基本是一样的功能，不一样的就是match()匹配字符串开始位置的一个符合规则的字符串，search()是在字符串全局匹配第一个合规则的字符串
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
origin = "hello egon bcd egon lge egon acd 19"
r = re.match("hw+", origin)    #match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
print(r.group())     # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups())    # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
#输出结果
# hello     匹配到的全部拿出来
# ()        没有分组所以为空
# {}        没分组部分定义了key的组所以为空


# 有分组
# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
r = re.match("h(w+)", origin)   #match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
print(r.group())     # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups())    # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
#输出结果
# hello         匹配到的全部拿出来
# ('ello',)     有分组，在匹配到的字符串中拿出分组的部分
# {}            没分组部分定义了key的组所以为空


# 有两个分组定义了key
# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
r = re.match("(?P<n1>h)(?P<n2>w+)", origin)   #?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容
print(r.group())     # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups())    # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
#输出结果
# hello                         匹配到的全部拿出来
# ('h', 'ello')                 有分组，在匹配到的字符串中拿出分组的部分
# {'n1': 'h', 'n2': 'ello'}     有定义了key的组所以，将定义了key的组里的内容以字典形式拿出来
    

    
View Code
    

    ?P<n1>  #?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容（只对正则函数返回对象的有用）
    

    取出匹配对象方法
    

    只对正则函数返回对象的有用
    

    group() # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来，有参取匹配到的第几个如2
    groups() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
    groupdict() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
    



    search()函数
    search,浏览全部字符串，匹配第一符合规则的字符串，浏览整个字符串去匹配第一个，未匹配成功返回None
    search(pattern, string, flags=0)
    # pattern： 正则模型
    # string ： 要匹配的字符串
    # falgs ： 匹配模式
    

    注意：match()函数 与 search()函数基本是一样的功能，不一样的就是match()匹配字符串开始位置的一个符合规则的字符串，search()是在字符串全局匹配第一个合规则的字符串
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
origin = "hello alex bcd alex lge alex acd 19"
r = re.search("aw+", origin)    #search浏览全部字符串，匹配第一符合规则的字符串，浏览整个字符串去匹配第一个，未匹配成功返回None
print(r.group())     # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups())    # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
#输出结果
# alex     匹配到的全部拿出来
# ()        没有分组所以为空
# {}        没分组部分定义了key的组所以为空


# 有分组
# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
r = re.search("a(w+).*(d)", origin)
print(r.group())     # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups())    # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
#输出结果
# alex bcd alex lge alex acd 19       匹配到的全部拿出来
# ('lex', '9')     有分组，在匹配到的字符串中拿出分组的部分
# {}            没分组部分定义了key的组所以为空


# 有两个分组定义了key
# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
r = re.search("a(?P<n1>w+).*(?P<n2>d)", origin)   #?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容
print(r.group())     # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups())    # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
#输出结果
# alex bcd alex lge alex acd 19                         匹配到的全部拿出来
# ('lex', '9')                 有分组，在匹配到的字符串中拿出分组的部分
# {'n1': 'lex', 'n2': '9'}     有定义了key的组所以，将定义了key的组里的内容以字典形式拿出来
    

    
View Code
    

    findall()函数（以后常用）
    

    findall(pattern, string, flags=0)
    # pattern： 正则模型
    # string ： 要匹配的字符串
    # falgs ： 匹配模式
    

    浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中，未匹配成功返回空列表
    

    注意：一旦匹配成，再次匹配，是从前一次匹配成功的，后面一位开始的，也可以理解为匹配成功的字符串，不在参与下次匹配
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
r = re.findall("d+wd+", "a2b3c4d5")    #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中
print(r)
#输出结果
#['2b3', '4d5']
#注意：匹配成功的字符串，不在参与下次匹配,所以3c4也符合规则但是没匹配到
    

    
View Code
    

     注意：如果没写匹配规则，也就是空规则，返回的是一个比原始字符串多一位的，空字符串列表
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
r = re.findall("", "a2b3c4d5")    #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中
print(r)
#输出结果
#['', '', '', '', '', '', '', '', '']
#注意：如果没写匹配规则，也就是空规则，返回的是一个比原始字符串多一位的，空字符串列表 
    

    
View Code
    

    

    注意：正则匹配到空字符的情况，如果规则里只有一个组，而组后面是*就表示组里的内容可以是0个或者多过，这样组里就有了两个意思，一个意思是匹配组里的内容，二个意思是匹配组里0内容（即是空白）所以尽量避免用*否则会有可能匹配出空字符串
    

    注意：正则只拿组里最后一位，如果规则里只有一个组，匹配到的字符串里在拿组内容是，拿的是匹配到的内容最后一位
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)*", origin)   
print(r)
#输出结果 ['', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', 'a', '', '', '', '', '', '']
    

    
View Code
    


    无分组：匹配所有合规则的字符串，匹配到的字符串放到一个列表中
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("aw+", origin)    #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中
print(r)
#输出结果
#['alex', 'alex', 'alex', 'acd']
#匹配所有合规则的字符串，匹配到的字符串放到一个列表中
    

    
View Code
    

     
    

    有分组：只将匹配到的字符串里，组的部分放到列表里返回，相当于groups()方法
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("a(w+)", origin)    #有分组：只将匹配到的字符串里，组的部分放到列表里返回
print(r)
#输出结果
#['lex', 'lex', 'lex', 'cd']
    

    
View Code
    

     多个分组：只将匹配到的字符串里，组的部分放到一个元组中，最后将所有元组放到一个列表里返
    

    相当于在group()结果里再将组的部分，分别，拿出来放入一个元组，最后将所有元组放入一个列表返回
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)(w+)", origin)    #多个分组：只将匹配到的字符串里，组的部分放到一个元组中，最后将所有元组放到一个列表里返回
print(r)
#输出结果
#[('a', 'lex'), ('a', 'lex'), ('a', 'lex'), ('a', 'cd')]
    

    
View Code
    

     分组中有分组：只将匹配到的字符串里，组的部分放到一个元组中，先将包含有组的组，看作一个整体也就是一个组，把这个整体组放入一个元组里，然后在把组里的组放入一个元组，最后将所有组放入一个列表返回
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)(w+(e))", origin)    #分组中有分组：只将匹配到的字符串里，组的部分放到一个元组中，先将包含有组的组，看作一个整体也就是一个组，把这个整体组放入一个元组里，然后在把组里的组放入一个元组，最后将所有组放入一个列表返回
print(r)
#输出结果
#[('a', 'le', 'e'), ('a', 'le', 'e'), ('a', 'le', 'e')]
    

    
View Code
    

    ?:在有分组的情况下findall()函数，不只拿分组里的字符串，拿所有匹配到的字符串，注意?:只用于不是返回正则对象的函数如findall()
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
b = re.findall("a(?:w+)",origin) #?:在有分组的情况下，不只拿分组里的字符串，拿所有匹配到的字符串，注意?:只用于不是返回正则对象的函数如findall()
print(b)
#输出
# ['alex', 'alex', 'alex', 'acd']
    

    
View Code
    

    


    split()函数
    

    根据正则匹配分割字符串，返回分割后的一个列表
    

    split(pattern, string, maxsplit=0, flags=0)
    

    # pattern： 正则模型
    

    # string ： 要匹配的字符串
    

    # maxsplit：指定分割个数
    

    # flags  ： 匹配模式
    

     
    

    按照一个字符将全部字符串进行分割
    

    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.split("a", origin) #根据正则匹配分割字符串
print(r)
#输出结果 ['hello ', 'lex bcd ', 'lex lge ', 'lex ', 'cd 19']
#根据a进行分组
    

    
View Code
    

    

    

    将匹配到的字符串作为分割标准进行分割
    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex 2acd 19"
r = re.split("aw+", origin) #根据正则匹配分割字符串
print(r)
#输出结果 ['hello ', ' bcd ', ' lge ', ' 2', ' 19']
#将匹配到的字符串作为分割标准进行分割
    

    
View Code
    

     sub()函数
    

    替换匹配成功的指定位置字符串
    

    sub(pattern, repl, string, count=0, flags=0)
    

    # pattern： 正则模型
    

    # repl   ： 要替换的字符串
    

    # string ： 要匹配的字符串
    

    # count  ： 指定匹配个数
    

    # flags  ： 匹配模式
    

    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.sub("a","替换",origin) #替换匹配成功的指定位置字符串
print(r)
#输出
# hello 替换lex bcd 替换lex lge 替换lex 替换cd 19
    

    
View Code
    

    

    


    subn()函数
    

    替换匹配成功的指定位置字符串,并且返回替换次数，可以用两个变量分别接受
    

    subn(pattern, repl, string, count=0, flags=0)
    

    # pattern： 正则模型
    

    # repl   ： 要替换的字符串
    

    # string ： 要匹配的字符串
    

    # count  ： 指定匹配个数
    

    # flags  ： 匹配模式
    

    

    

    

    #!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
a,b = re.subn("a","替换",origin) #替换匹配成功的指定位置字符串,并且返回替换次数，可以用两个变量分别接受
print(a)
print(b)
#输出
# hello 替换lex bcd 替换lex lge 替换lex 替换cd 19
# 4
    

    
View Code
    

    

    


    元字符表
    

    


    


    .
    
    		


    需要字符串里完全符合，匹配规则，就匹配，（规则里的.元字符）可以是任何一个字符，匹配任意除换行符"
"外的字符(在DOTALL模式中也能匹配换行符)
    
    		


    a.c
    
    		


    abc
    
    		

    

    


    
    		


    1.反斜杠后边跟元字符去除特殊功能；（即将特殊字符转义成普通字符），2.反斜杠后边跟普通字符实现特殊功能；（即预定义字符），3.2引用序号对应的字组
    
    		


    a.c;a\c
    
    		


    a.c;ac
    
    		

    

    


    *
    
    		


    需要字符串里完全符合，匹配规则，就匹配，（规则里的*元字符）前面的一个字符可以是0个或多个原本字符，匹配前一个字符0或多次，贪婪匹配前导字符有多少个就匹配多少个很贪婪，如果规则里只有一个分组，尽量避免用*否则会有可能匹配出空字符串
    
    		


    abc*
    
    		


    ab;abccc
    
    		

    

    


    +
    
    		


    需要字符串里完全符合，匹配规则，就匹配，（规则里的+元字符）前面的一个字符可以是1个或多个原本字符，匹配前一个字符1次或无限次，贪婪匹配前导字符有多少个就匹配多少个很贪婪
    
    		


    abc+
    
    		


    abc;abccc
    
    		

    

    


    ?
    
    		


    需要字符串里完全符合，匹配规则，就匹配，（规则里的?元字符）前面的一个字符可以是0个或1个原本字符，匹配一个字符0次或1次，还有一个功能是可以防止贪婪匹配，详情见防贪婪匹配
    
    		


    abc?
    
    		


    ab;abc
    
    		

    

    


    ^
    
    		


    字符串开始位置与匹配规则符合就匹配，否则不匹配，匹配字符串开头。在多行模式中匹配每一行的开头，^元字符如果写到[]字符集里就是反取
    
    		


    ^abc
    
    		


    abc
    
    		

    

    


    $
    
    		


    字符串结束位置与匹配规则符合就匹配，否则不匹配，匹配字符串末尾，在多行模式中匹配每一行的末尾
    
    		


    abc$
    
    		


    abc
    
    		

    

    


    |
    
    		


    |或，或就是前后其中一个符合就匹配
    
    		


    abc|def
    
    		


    abc
    

    def
    
    		

    

    


    {}
    
    		


    需要字符串里完全符合，匹配规则，就匹配，（规则里的 {} 元字符）前面的一个字符，是自定义字符数，位数的原本字符，{m}匹配前一个字符m次，{m,n}匹配前一个字符m至n次，若省略n，则匹配m至无限次，{0,}匹配前一个字符0或多次,等同于*元字符，{+,}匹配前一个字符1次或无限次,等同于+元字符，{0,1}匹配前一个字符0次或1次,等同于?元字符
    
    		


    ab{1,2}c
    
    		


    abc
    

    abbc
    
    		

    

    


    []
    
    		


    需要字符串里完全符合，匹配规则，就匹配，（规则里的 [] 元字符）对应位置是[]里的任意一个字符就匹配，字符集。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，如[abc]或[a-c]。[^abc]表示取反，即非abc。所有特殊字符在字符集中都失去其原有的特殊含义。用反斜杠转义恢复特殊字符的特殊含义。
    
    		


    a[bcd]e
    
    		


    abe
    

    ace
    

    ade
    

     
    
    		

    

    


    ()
    
    		


    也就是分组匹配，()里面的为一个组也可以理解成一个整体，如果()后面跟的是特殊元字符如   (adc)*   那么*控制的前导字符就是()里的整体内容，不再是前导一个字符
    
    		


    (abc){2}
    a(123|456)c
    






    		


    abcabc
    

    a456c
    






    		







    






    







    

    预定义字符集表，可以写在字符集[...]中 
    

    


    


    d
    






    		


    d匹配任何十进制数，它相当于类[0-9]，d+如果需要匹配一位或者多位数的数字时用
    






    		


    ac
    






    		


    a1c
    






    		







    

    


    D
    






    		


    D匹配任何非数字字符，它相当于类[^0-9]
    






    		


    aDc
    






    		


    abc
    






    		







    

    


    s
    






    		


    s匹配任何空白字符，它相当于类[	

fv]
    






    		


    asc
    






    		


    a c
    






    		







    

    


    S
    






    		


    S匹配任何非空白字符，它相当于类[^	

fv]
    






    		


    aSc
    






    		


    abc
    






    		







    

    


    w
    






    		


    w匹配包括下划线在内任何字母数字字符，它相当于类[a-zA-Z0-9_]
    






    		


    awc
    






    		


    abc
    






    		







    

    


    W
    






    		


    W匹配非任何字母数字字符包括下划线在内，它相当于类[^a-zA-Z0-9_]
    






    		


    aWc
    






    		


    a c
    






    		







    

    


    A
    






    		


    仅匹配字符串开头,同^
    






    		


    Aabc
    






    		


    abc
    






    		







    

    


    
    






    		


    仅匹配字符串结尾，同$
    






    		


    abc
    






    		


    abc
    






    		







    

    


    
    






    		


    b匹配一个单词边界，也就是指单词和空格间的位置
    






    		


    abc
    a!bc
    






    		


    空格abc空格
    a!bc
    






    		







    

    


    B
    






    		


    [^]
    






    		


    aBbc
    






    		


    abc
    






    		







    






    







    


    特殊分组用法表：只对正则函数返回对象的有用
    

    


    


    (?P<name>)
    






    		


    ?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容，在用groupdict()方法打印字符串
    






    		


    (?P<id>abc){2}
    






    		


    abcabc
    






    		







    

    


    (?P=name)
    






    		


    引用别名为<name>的分组匹配到字符串
    






    		


    (?P<id>d)abc(?P=id)
    






    		


    1abc1
    

    5abc5
    






    		







    

    


    <number>
    






    		


    引用编号为<number>的分组匹配到字符串
    






    		


    (d)abc1
    






    		


    1abc1
    

    5abc5
    






    		







    






    







    







    







    


    正则匹配模式表
    

    


    


    标志
    






    		


    含义
    






    		







    

    


    re.S(DOTALL)
    






    		


    使.匹配包括换行在内的所有字符
    






    		







    

    


    re.I（IGNORECASE）
    






    		


    使匹配对大小写不敏感
    






    		







    

    


    re.L（LOCALE）
    






    		


    做本地化识别（locale-aware)匹配，法语等
    






    		







    

    


    re.M(MULTILINE)
    






    		


    多行匹配，影响^和$
    






    		







    

    


    re.X(VERBOSE)
    






    		


    该标志通过给予更灵活的格式以便将正则表达式写得更易于理解
    






    		







    

    


    re.U
    






    		


    根据Unicode字符集解析字符，这个标志影响w,W,,B
    






    		







    






    







    

     
    

    正则表达式重点
    

    一、
    

    r原生字符
    

    将在python里有特殊意义的字符如，转换成原生字符（就是去除它在python的特殊意义），不然会给正则表达式有冲突，为了避免这种冲突可以在规则前加原始字符r
    


    二、
    

    正则表达式，返回类型为表达式对象的
    

    如：<_sre.SRE_Match object; span=(6, 7), match='a'>  
    

    返回对象的，需要用正则方法取字符串，
    

    方法有
    

    group() # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来，有参取匹配到的第几个如2
    groups() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
    groupdict() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
    


    三、
    

    匹配到的字符串里出现空字符
    

    注意：正则匹配到空字符的情况，如果规则里只有一个组，而组后面是*就表示组里的内容可以是0个或者多过，这样组里就有了两个意思，一个意思是匹配组里的内容，二个意思是匹配组里0内容（即是空白）所以尽量避免用*否则会有可能匹配出空字符串
    







    


    四、
    

    ()分组
    

    注意：分组的意义，就是在匹配成功的字符串中，在提取()里，组里面的字符串
    


    五、
    


    ?:在有分组的情况下findall()函数，不只拿分组里的字符串，拿所有匹配到的字符串，注意?:只用于不是返回正则对象的函数如findall()
    

    

    
    
                
    
                
              
    • 
              
    
              
  • 

                相关阅读:
    
                
                  手把手教你利用create-nuxt-app脚手架创建NuxtJS应用
                    
    初识NuxtJS
                    
    webpack打包Vue应用程序流程
                    
    用选择器代替表格列的筛选功能
                    
    Element-UI
                    
    Spectral Bounds for Sparse PCA: Exact and Greedy Algorithms[贪婪算法选特征]
                    
    Sparse Principal Component Analysis via Rotation and Truncation
                    
    Generalized Power Method for Sparse Principal Component Analysis
                    
    Sparse Principal Component Analysis via Regularized Low Rank Matrix Approximation(Adjusted Variance)
                    
    Truncated Power Method for Sparse Eigenvalue Problems
                    
                        
              
    • 
              
    
              
  • 
                原文地址：https://www.cnblogs.com/gufengchen/p/10913186.html
              
    • 

            

          



          
          

            

            

          

        

      

      



      

      

        

          Copyright © 2011-2022 走看看