文章来源与：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)  #以列表形式返回匹配到的字符串

#打印出 ['匹配规则则则']






[]元字符,字符集


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


字符集。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，如[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)  #以列表形式返回匹配到的字符串






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








#!/usr/bin/env python

# -*- coding:utf-8 -*-

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

a = re.findall("[^a-z]", "匹配s规则这s个字符串是否s匹配f规则则re则则则")   #反取，匹配出除字母外的字符

print(a)  #以列表形式返回匹配到的字符串

#打印出 ['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']






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


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


\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']






\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']






\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)  #以列表形式返回匹配到的字符串

#打印出 ['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']






\s匹配任何空白字符，它相当于类[\t\n\r\f\v]






#!/usr/bin/env python

# -*- coding:utf-8 -*-

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

a = re.findall("\s", "匹配规则   这2个字符串3是否匹\n配规则5则则则7则")   #\s匹配任何空白字符，它相当于类[\t\n\r\f\v]

print(a)  #以列表形式返回匹配到的字符串

#打印出[' ', ' ', ' ', '\n']






\S匹配任何非空白字符，它相当于类[^\t\n\r\f\v]






#!/usr/bin/env python

# -*- coding:utf-8 -*-

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

a = re.findall("\S", "匹配规则   这2个字符串3是否匹\n配规则5则则则7则")   #\S匹配任何非空白字符，它相当于类[^\t\n\r\f\v]

print(a)  #以列表形式返回匹配到的字符串

#打印出 ['匹', '配', '规', '则', '这', '2', '个', '字', '符', '串', '3', '是', '否', '匹', '配', '规', '则', '5', '则', '则', '则', '7', '则']






\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']






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






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

a = re.findall('\W',"https://www.cnblogs.com/")  #\w匹配包括下划线在内任何字母数字字符，它相当于类[a-zA-Z0-9_]

print(a)  #以列表形式返回匹配到的字符串

#打印出[':', '/', '/', '.', '.', '/']






()元字符，分组


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


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


列1






#!/usr/bin/env python

# -*- coding:utf8 -*-

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

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

a = re.search("(a4)+", "a4a4a4a4a4dg4g654gb")   #匹配一个或多个a4

b = a.group()

print(b)

#打印出 a4a4a4a4a4






列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






|元字符，或


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






#!/usr/bin/env python

# -*- coding:utf8 -*-

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

a = re.findall(r"你|好", "a4a4a你4aabc4a4dgg好dg4g654g")   #|或，或就是前后其中一个符合就匹配

print(a)

#打印出 ['你', '好']






r原生字符


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


re模块中常用功能函数


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






#!/usr/bin/env python

# -*- coding:utf-8 -*-

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

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

print(a)  #以列表形式返回匹配到的字符串

#打印出 ['匹配规则']






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("h\w+", 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的组里的内容以字典形式拿出来






?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("a\w+", 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的组里的内容以字典形式拿出来






findall()函数（以后常用）


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


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


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






#!/usr/bin/env python

# -*- coding:utf8 -*-

import re

#无分组

r = re.findall("\d+\w\d+", "a2b3c4d5")    #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中

print(r)

#输出结果

#['2b3', '4d5']

#注意：匹配成功的字符串，不在参与下次匹配,所以3c4也符合规则但是没匹配到






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






#!/usr/bin/env python

# -*- coding:utf8 -*-

import re

#无分组

r = re.findall("", "a2b3c4d5")    #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中

print(r)

#输出结果

#['', '', '', '', '', '', '', '', '']

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








注意：正则匹配到空字符的情况，如果规则里只有一个组，而组后面是*就表示组里的内容可以是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', '', '', '', '', '', '']







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






#!/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)

#输出结果

#['alex', 'alex', 'alex', 'acd']

#匹配所有合规则的字符串，匹配到的字符串放到一个列表中






 


有分组：只将匹配到的字符串里，组的部分放到列表里返回，相当于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']






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


相当于在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')]






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






#!/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')]






?:在有分组的情况下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']








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进行分组










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






#!/usr/bin/env python

# -*- coding:utf8 -*-

import re

origin = "hello alex bcd alex lge alex 2acd 19"

r = re.split("a\w+", origin) #根据正则匹配分割字符串

print(r)

#输出结果 ['hello ', ' bcd ', ' lge ', ' 2', ' 19']

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






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










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

#










元字符表








.




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




a.c




abc








\




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




a\.c;a\\c




a.c;a\c








*




需要字符串里完全符合，匹配规则，就匹配，（规则里的*元字符）前面的一个字符可以是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+如果需要匹配一位或者多位数的数字时用




a\bc




a1c








\D




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




a\Dc




abc








\s




\s匹配任何空白字符，它相当于类[\t\n\r\f\v]




a\sc




a c








\S




\S匹配任何非空白字符，它相当于类[^\t\n\r\f\v]




a\Sc




abc








\w




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




a\wc




abc








\W




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




a\Wc




a c








\A




仅匹配字符串开头,同^




\Aabc




abc








\Z




仅匹配字符串结尾，同$




abc\Z




abc








\b




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




\babc\b
a\b!bc




空格abc空格
a!bc








\B




[^\b]




a\Bbc




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)abc\1




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,\B








正则表达式重点


一、


r原生字符


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


二、


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


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


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


方法有


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


三、


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


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




四、


()分组


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


五、


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


												


											
python正则表达式findall的使用的更多相关文章
	

    
						
  1. 关于Python正则表达式findall函数问题详解
		
    关于Python正则表达式 findall函数问题详解 在写正则表达式的时候总会遇到不少的问题, 特别是在表达式有多个元组的时候.下面看下re模块下的findall()函数和多个表达式元组相遇的时候会 ...
    
		
    2. 
								
  2. python正则表达式--findall、finditer方法
		
    findall方法 相比其他方法,findall方法有些特殊.它的作用是查找字符串中所有能匹配的字符串,并以结果存于列表中,然后返回该列表 注意: match 和 search 是匹配一次 finda ...
    
		
    3. 
						
  3. python 正则表达式findall
		
    re.findall("匹配规则", "要匹配的字符串") 以列表形式返回匹配到的字符串 https://www.cnblogs.com/gufengchen/ ...
    
		
    4. 
						
  4. Python正则表达式re.findall("[A-Za-z]([A-Za-z0-9])*[.]txt",'Abc2019.txt')的结果为什么是['9']
		
    在<Python妙用re.sub分析正则表达式匹配过程>中老猿分析了findall函数的返回情况,老猿前一阵子在执行这个语句时: >>> re.findall(" ...
    
		
    5. 
						
  5. Python正则表达式中的re.S
		
    title: Python正则表达式中的re.S date: 2014-12-21 09:55:54 categories: [Python] tags: [正则表达式,python] --- 在Py ...
    
		
    6. 
						
  6. Python 正则表达式入门（初级篇）
		
    Python 正则表达式入门(初级篇) 本文主要为没有使用正则表达式经验的新手入门所写. 转载请写明出处 引子 首先说 正则表达式是什么? 正则表达式,又称正规表示式.正规表示法.正规表达式.规则表达 ...
    
		
    7. 
						
  7. python正则表达式re
		
    Python正则表达式: re 正则表达式的元字符有. ^ $ * ? { [ ] | ( )．表示任意字符［］用来匹配一个指定的字符类别,所谓的字符类别就是你想匹配的一个字符集,对于字符集中的字符可 ...
    
		
    8. 
						
  8. Python正则表达式详解
		
    我用双手成就你的梦想 python正则表达式 ^ 匹配开始 $ 匹配行尾 . 匹配出换行符以外的任何单个字符,使用-m选项允许其匹配换行符也是如此 [...] 匹配括号内任何当个字符(也有或的意思)  ...
    
		
    9. 
						
  9. 比较详细Python正则表达式操作指南(re使用)
		
    比较详细Python正则表达式操作指南(re使用) Python 自1.5版本起增加了re 模块,它提供 Perl 风格的正则表达式模式.Python 1.5之前版本则是通过 regex 模块提供 E ...
    
		
    10. 
		

	


随机推荐
	

    
									
  1. C传递参数给main函数
			
    一个很简单的给main函数传递参数的例子: #include <stdio.h> //int main(int argc, char *argv[]){ int main(int argc ...
    
			
    2. 
						
  2. Rancher2.3.2部署Kubenetes Dashboard
			
    首先进入到集群中的System命令空间,因为kubenetes dashboard是给整个集群使用的,并不是默认的Default命名空间使用的 Default命名空间,是默认的命名空间,也是在部署其他 ...
    
			
    3. 
						
  3. oralce 超过1亿条数据的数据库表清理实践
			
    2018-08-18 16:58 无腿鸟 阅读(331) 评论(0) 编辑 收藏 问题:当一个表的数据量超过一亿条,要删除其中的5000w条,如何处理. 如果直接使用delete语句,会涉及到到大量的 ...
    
			
    4. 
						
  4. Python: 在CSV文件中写入中文字符
			
    0.2 2016.09.26 11:28* 字数 216 阅读 8053评论 2喜欢 5 最近一段时间的学习中发现,Python基本和中文字符杠上了.如果能把各种编码问题解决了,基本上也算对Pytho ...
    
			
    5. 
						
  5. 【Java文件】按UTF-8编码读取文本文件（逐行方式），排序，打印到控制台
			
    代码: package findJavaMemberFunction; import java.io.BufferedReader; import java.io.FileInputStream; i ...
    
			
    6. 
						
  6. 关于如何重写Controller和Service技术攻关文档
			
    版权声明:本文为博主原创文章,遵循CC 4.0 by-sa版权协议,转载请附上原文出处链接和本声明. 本文链接:https://blog.csdn.net/weixin_39784756/articl ...
    
			
    7. 
						
  7. shell按月循环取数
			
    这里有个需求,按月查询,并且要输出每月的开始日期,结束日期. shell脚本如下: #!/bin/sh echo "0个参数时, 按月执行,默认当前月份 " echo " ...
    
			
    8. 
						
  8. evo:评测slam参数设置
			
    zn@buaa:~$ evo_ape euroc m1/state_groundtruth_estimate0/data.csv pl-svo-master2/trajout.txt -angle_d ...
    
			
    9. 
						
  9. DataWorks2.0——DataStudio简单对比使用上手
			
    1.原先的数据管理去哪里了? 悬停在此图标上即可:  2.项目模式有何不同?
    
			
    10. 
						
  10. LeetCode_374. Guess Number Higher or Lower
			
    374. Guess Number Higher or Lower Easy We are playing the Guess Game. The game is as follows: I pick ...
    
			
    11.