文章来源与：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. 深度学习面试题13：AlexNet(1000类图像分类)
			
    目录 网络结构 两大创新点 参考资料 第一个典型的CNN是LeNet5网络结构,但是第一个引起大家注意的网络却是AlexNet,Alex Krizhevsky其实是Hinton的学生,这个团队领导者是 ...
    
			
    2. 
						
  2. 深度学习面试题05：激活函数sigmod、tanh、ReLU、LeakyRelu、Relu6
			
    目录 为什么要用激活函数 sigmod tanh ReLU LeakyReLU ReLU6 参考资料 为什么要用激活函数 在神经网络中,如果不对上一层结点的输出做非线性转换的话,再深的网络也是线性模型 ...
    
			
    3. 
						
  3. 在Kaggle免费使用GPU训练自己的神经网络
			
    Kaggle上有免费供大家使用的GPU计算资源,本文教你如何使用它来训练自己的神经网络. Kaggle是什么 Kaggle是一个数据建模和数据分析竞赛平台.企业和研究者可在其上发布数据,统计学者和数据 ...
    
			
    4. 
						
  4. Column 'status' specified twice
			
    字段写了两次, 检查下sql语句, 删除一个就好了.
    
			
    5. 
						
  5. itop 环境
			
    iTop,即IT运营门户(IT Operation Portal),是一个开源web应用程序,用于IT环境的日常运营.它基于ITIL最佳实践,而又不拘泥于任何具体流程.它很灵活,可以适应不管是非正 式 ...
    
			
    6. 
						
  6. WebMercator和geographic互相转换
			
    方法1:esri的sdk中包含的方法:esri.geometry.geographicToWebMercator() 方法2:自己转换 //经纬度转Web墨卡托 function lonLat2Web ...
    
			
    7. 
						
  7. MD5Encrypt加密
			
    package utils; import java.security.MessageDigest; public class MD5Encrypt { public MD5Encrypt() { } ...
    
			
    8. 
						
  8. windows10 环境下的amqp安装步骤（图文）
			
    安装PHP扩展ampq 查看phpinfo()信息 下载ampq扩展 下载地址:http://pecl.php.net/package/amqp 选择一个dll版本下载,本文选择的是1.9.3 自己根 ...
    
			
    9. 
						
  9. django中同通过getlist() 接收页面form的post数组
			
    前端中的一些东西: <form action="people?action=edit" method="post"> <input type= ...
    
			
    10. 
						
  10. AWS 数据分析服务（十）
			
    Amazon Kinesis 概念 处理AWS上大量流数据的数据平台 Kinesis Streams 用于搜集数据,Client Library 用于分析后的展示 构建用于处理或分析流数据的自定义应用 ...
    
			
    11.