081 re正则表达式模块
目录
- 一、正则表达式
- 二、re模块的基本语法
- ^ 元字符
- $ 元字符
- [] 元字符(字符集)
- [^] 反取
- . 任意字符(换行符除外)
- * 对前一个字符0-无穷次扩展
- + 对前一个字符1-无穷次扩展
- ? 对前一个字符0或1次扩展
- {m} 对前一个字符扩展m次
- {m,n} 对前一个字符扩展m-n次(含n)
- \d 匹配单个数字(0-9)
- \D 匹配单个非数字(包括\n)
- \w 匹配 数字/字母/下划线
- \W 匹配 非数字/非字母/非下划线
- \s 匹配 空格/ \t/ \n
- \S 匹配 非空格/ 非\t/ 非\m
- () 只要括号内的
- | 左右两边的字符都要
- .* 贪婪模式
- **.*? 非贪婪模式**
- 三、re模块中常用功能函数
- 3.1 正则表达式的两种书写方式
- 3.2 re.compile(strPattern[, flag])函数
- 3.2.1 re.S
- 3.2.2 re.I
- 3.2.3 re.M
- 3.2.4 re.sub
- 3.3 分组函数
- 3.4 re.match(pattern, string[, flags])函数(常用)
- 3.5 re.search(pattern, string[, flags])函数
- 3.6 re.findall(pattern, string[, flags])函数(常用)
- 3.7 re.split(pattern, string[, maxsplit])函数
- 3.8 re.sub(pattern, repl, string[, count])函数
- 3.9 re.subn(pattern, repl, string,[, count][, flags])函数
一、正则表达式
正则表达式本身是一种小型的、高度专业化的编程语言,它并不是Python的一部分。
如果已经在其他语言里使用过正则表达式,只需要简单看一看就可以上手了。
而在python中,通过内嵌集成re模块,程序员们可以直接调用来实现正则匹配。
正则表达式的大致匹配过程是:依次拿出表达式和文本中的字符比较,如果每一个字符都能匹配,则匹配成功;一旦有匹配不成功的字符则匹配失败。如果表达式中有量词或边界,这个过程会稍微有一些不同,但也是很好理解的,看下图中的示例以及自己多使用几次就能明白。
下图列出了Python支持的正则表达式元字符和语法:
二、re模块的基本语法
^ 元字符
字符串开始位置与匹配规则符合就匹配,否则不匹配
匹配字符串开头。在多行模式中匹配每一行的开头(Python3+已经失效,配合compile使用)
import re
s = '王大炮打炮被大炮打死了 王大炮打炮被大炮打死了'
# ^: 匹配开头
print(re.findall("^王大炮", s))
['王大炮']
$ 元字符
字符串结束位置与匹配规则符合就匹配,否则不匹配
匹配字符串末尾,在多行模式中匹配每一行的末尾
import re
s = '王大炮打炮被大炮打死了 王大炮打炮被大炮打死了'
# $: 匹配结尾
print(re.findall("打死了$", s))
['打死了']
[] 元字符(字符集)
匹配中间的字符,只要单个字符
也可以使用[a-z]表示a到z 单个字符
import re
s = "adasdasdasdasfasf\n\t"
# []: 匹配中间的字符,只要单个字符
print(re.findall("[acef]",s))
['a', 'a', 'a', 'a', 'a', 'f', 'a', 'f']
[^] 反取
^对[]内的元素取反,除了[]里的字符都要
import re
s = "adasdasdasdasfasf\n\t"
# [^] : 把[]中的字符给排除.
print(re.findall("[^acef]",s))
['d', 's', 'd', 's', 'd', 's', 'd', 's', 's', '\n', '\t']
. 任意字符(换行符除外)
表示任意单个字符
import re
s= 'abc12ab56bc'
# .: 任意字符(换行符除外)
print(re.findall(".",s))
['a', 'd', 'a', 's', 'd', 'a', 's', 'd', 'a', 's', 'd', 'a', 's', 'f', 'a', 's', 'f', '\t']
* 对前一个字符0-无穷次扩展
: 匹配 前面的字符0-无穷个,空也会匹配
import re
s = r"abaacaaaaa"
# *: 匹配 *前面的字符0-无穷个
print(re.findall("a*",s)) # 匹配 0-无限个a,空也会匹配
['a', '', 'aa', '', 'aaaaa', '']
+ 对前一个字符1-无穷次扩展
+: 匹配 +前面的字符1-无穷个
import re
s = r"abaacaaaaa"
# +: 匹配 +前面的字符1-无穷个
print(re.findall("a+",s)) # 匹配 1-无限个a
['a', 'aa', 'aaaaa']
? 对前一个字符0或1次扩展
?: 匹配 ?前面的字符0或1次扩展
import re
s = r"abaacaaaaa"
# ?: 匹配 ?前面的字符0-1个
print(re.findall("a?",s)) # 匹配 0-1个a
['a', '', 'a', 'a', '', 'a', 'a', 'a', 'a', 'a', '']
{m} 对前一个字符扩展m次
{m}: 匹配 {m}前面的字符m次
import re
s = r"abaacaaaaa"
# {m}: 匹配 前面的字符m个
print(re.findall("a{2}",s)) # 匹配 2个a
['aa', 'aa', 'aa']
{m,n} 对前一个字符扩展m-n次(含n)
{m,n}: 匹配 前面的的字符m-n个
import re
s = r"abaacaaaaa"
# {m,n}: 匹配 前面的的字符m-n个
print(re.findall("a{2,3}",s)) # 匹配 2、3个a
['aa', 'aaa', 'aa']
\d 匹配单个数字(0-9)
\d: 匹配单个数字
import re
s = '1#@¥23abc123 \n_def\t456'
# \d: 匹配单个数字
print(re.findall("\d",s)) # 匹配 单个数字
['1', '2', '3', '1', '2', '3', '4', '5', '6']
\D 匹配单个非数字(包括\n)
\D: 匹配单个非数字
import re
s = '1#@¥23abc123 \n_def\t456'
# \D: 匹配单个非数字
print(re.findall("\D",s)) # 匹配 单个 非数字(包括\n)
['#', '@', '¥', 'a', 'b', 'c', ' ', '\n', '_', 'd', 'e', 'f', '\t']
\w 匹配 数字/字母/下划线
\w: 匹配 数字/字母/下划线
import re
s = '1#@¥23abc123 \n_def\t456'
# \w: 匹配 数字/字母/下划线
print(re.findall("\w",s))
['1', '2', '3', 'a', 'b', 'c', '1', '2', '3', '_', 'd', 'e', 'f', '4', '5', '6']
\W 匹配 非数字/非字母/非下划线
\W: 非数字/非字母/非下划线
import re
s = '1#@¥23abc123 \n_def\t456'
# \W: 非数字/非字母/非下划线
print(re.findall("\W",s))
['#', '@', '¥', ' ', '\n', '\t']
\s 匹配 空格/ \t/ \n
\s: 空格/ \t/ \n
import re
s = '1#@¥23abc123 \n_def\t456'
# \s: 空格/ \t/ \n
print(re.findall("\s", s))
[' ', '\n', '\t']
\S 匹配 非空格/ 非\t/ 非\m
\S: 非空格/ 非\t/ 非\m
import re
s = '1#@¥23abc123 \n_def\t456'
# \S: 非空格/ 非\t/ 非\m
print(re.findall("\S", s))
['1', '#', '@', '¥', '2', '3', 'a', 'b', 'c', '1', '2', '3', '_', 'd', 'e', 'f', '4', '5', '6']
() 只要括号内的
(): 只要括号内的
import re
s = 'abacad'
# (): 只要括号内的
print(re.findall('a(.)', s))
['b', 'c', 'd']
| 左右两边的字符都要
A|B: A和B都要
import re
s = 'abacad'
# A|B: A和B都要
print(re.findall('a|b', s))
['a', 'b', 'a', 'a']
.* 贪婪模式
.*: 贪婪模式(最大化),找到继续找,让结果最大化
import re
s = 'abbbcabc'
# .*: 贪婪模式(最大化),找到继续找,让结果最大化
print(re.findall('a.*c', s))
print(re.findall('a.+c', s))
['abbbcabc']
['abbbcabc']
**.*? 非贪婪模式**
.*?: 非贪婪模式(最小化),找到就马上停止
import re
s = 'abbbcabc'
# .*?: 非贪婪模式(最小化),找到就马上停止
print(re.findall('a.*?c', s))
print(re.findall('a.+?c', s))
['abbbc', 'abc']
['abbbc', 'abc']
三、re模块中常用功能函数
3.1 正则表达式的两种书写方式
1.一种是直接在函数里书写规则,推荐使用
import re
a = re.findall("匹配规则", "这个字符串是否有匹配规则的字符")
print(a)
2.另一种是先将正则表达式的字符串形式编译为Pattern实例,然后使用Pattern实例处理文本并获得匹配结果(一个Match实例),最后使用Match实例获得信息,进行其他的操作。
import re# 将正则表达式编译成Pattern对象
pattern = re.compile(r'hello')# 使用Pattern匹配文本,获得匹配结果,无法匹配时将返回None
match = pattern.match('hello world!')if match:# 使用Match获得分组信息print(match.group())
hello
3.2 re.compile(strPattern[, flag])函数
这个方法是Pattern类的工厂方法,用于将字符串形式的正则表达式编译为Pattern对象。 第二个参数flag是匹配模式,取值可以使用按位或运算符'|'表示同时生效,比如re.I | re.M。另外,你也可以在regex字符串中指定模式,比如re.compile('pattern', re.I | re.M)与re.compile('(?im)pattern')是等价的。
下表是所有的正则匹配模式:
修饰符 | 描述 |
---|---|
re.I | 使匹配对大小写不敏感 |
re.L | 做本地化识别(locale-aware)匹配 |
re.M | 多行匹配,影响 ^ 和 $ |
re.S | 使 . 匹配包括换行在内的所有字符 |
re.U | 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B. |
re.X | 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。 |
3.2.1 re.S
- 在Python的正则表达式中,有一个参数为re.S。它表示 “.” 的作用扩展到整个字符串,包括“\n”。看如下代码:
import re
a = '''asdfhellopass:worldaf'''
b = re.findall('hello(.*?)world', a)
c = re.findall('hello(.*?)world', a, re.S)
print('b is ', b)
print('c is ', c)
b is []
c is ['pass:\n ']
正则表达式中,“.”的作用是匹配除“\n”以外的任何字符,也就是说,它是在一行中进行匹配。这里的“行”是以“\n”进行区分的。a字符串有每行的末尾有一个“\n”,不过它不可见。
如果不使用re.S参数,则只在每一行内进行匹配,如果一行没有,就换下一行重新开始,不会跨行。而使用re.S参数以后,正则表达式会将这个字符串作为一个整体,将“\n”当做一个普通的字符加入到这个字符串中,在整体中进行匹配。
3.2.2 re.I
- 不区分大小写
res = re.findall(r"A", "abc", re.I)
print(res)
['a']
3.2.3 re.M
- 将所有行的尾字母输出(python3+已经无效)
s = '12 34/n56 78/n90're.findall(r'^/d+', s, re.M) # 匹配位于行首的数字 # ['12', '56', '90']
re.findall(r'/A/d+', s, re.M) # 匹配位于字符串开头的数字 # ['12']
re.findall(r'/d+$', s, re.M) # 匹配位于行尾的数字 # ['34', '78', '90']
re.findall(r'/d+/Z', s, re.M) # 匹配位于字符串尾的数字 # ['90']
3.2.4 re.sub
# 要求结果:['12', '23', '34']
l = ['1 2 ', '2 3', ' 3 4']
import re
print(eval(re.sub(r'\s*', '', str(l))))
['12', '23', '34']
3.3 分组函数
?P<n1>
# ?P<>定义组里匹配内容的key(键),<>里面写key名称,值就是匹配到的内容(只对正则函数返回对象时有用)
取出匹配对象方法
只对正则函数返回对象的有用
- group() # 获取匹配到的所有结果,不管有没有分组将匹配到的全部拿出来,有参取匹配到的第几个如2
- groups() # 获取模型中匹配到的分组结果,只拿出匹配到的字符串中分组部分的结果
- groupdict() # 获取模型中匹配到的分组结果,只拿出匹配到的字符串中分组部分定义了key的组结果
3.4 re.match(pattern, string[, flags])函数(常用)
match,从头匹配一个符合规则的字符串,从起始位置开始匹配,匹配成功返回一个对象,未匹配成功返回None
match(pattern, string, flags=0)
- pattern: 正则模型
- string : 要匹配的字符串
- falgs : 匹配模式
注意:match()函数 与 search()函数基本是一样的功能,不一样的就是match()匹配字符串开始位置的一个符合规则的字符串,search()是在字符串全局匹配第一个合规则的字符串
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
()
{}
# 有分组
# 为何要有分组?提取匹配成功的指定内容(先匹配成功全部正则,再匹配成功的局部内容提取出来)
r = re.match("h(\w+)", origin) # match,从起始位置开始匹配,匹配成功返回一个对象,未匹配成功返回None
print(r.group()) # 获取匹配到的所有结果,不管有没有分组将匹配到的全部拿出来
print(r.groups()) # 获取模型中匹配到的分组结果,只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果,只拿出匹配到的字符串中分组部分定义了key的组结果
hello
('ello',)
{}
# 有两个分组定义了key
# 为何要有分组?提取匹配成功的指定内容(先匹配成功全部正则,再匹配成功的局部内容提取出来)
# ?P<>定义组里匹配内容的key(键),<>里面写key名称,值就是匹配到的内容
r = re.match("(?P<n1>h)(?P<n2>\w+)", origin)
print(r.group()) # 获取匹配到的所有结果,不管有没有分组将匹配到的全部拿出来
print(r.groups()) # 获取模型中匹配到的分组结果,只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果,只拿出匹配到的字符串中分组部分定义了key的组结果
hello
('h', 'ello')
{'n1': 'h', 'n2': 'ello'}
3.5 re.search(pattern, string[, flags])函数
search,浏览全部字符串,匹配第一符合规则的字符串,浏览整个字符串去匹配第一个,未匹配成功返回None
search(pattern, string, flags=0)
- pattern: 正则模型
- string : 要匹配的字符串
- falgs : 匹配模式
注意:match()函数 与 search()函数基本是一样的功能,不一样的就是match()匹配字符串开始位置的一个符合规则的字符串,search()是在字符串全局匹配第一个合规则的字符串
import re
# 无分组
origin = "hello alex bcd alex lge alex acd 19"
# search浏览全部字符串,匹配第一符合规则的字符串,浏览整个字符串去匹配第一个,未匹配成功返回None
r = re.search("a\w+", origin)
print(r.group()) # 获取匹配到的所有结果,不管有没有分组将匹配到的全部拿出来
print(r.groups()) # 获取模型中匹配到的分组结果,只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果,只拿出匹配到的字符串中分组部分定义了key的组结果
alex
()
{}
# 有分组
# 为何要有分组?提取匹配成功的指定内容(先匹配成功全部正则,再匹配成功的局部内容提取出来)
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
# 为何要有分组?提取匹配成功的指定内容(先匹配成功全部正则,再匹配成功的局部内容提取出来)
# ?P<>定义组里匹配内容的key(键),<>里面写key名称,值就是匹配到的内容
r = re.search("a(?P<n1>\w+).*(?P<n2>\d)", origin)
print(r.group()) # 获取匹配到的所有结果,不管有没有分组将匹配到的全部拿出来
print(r.groups()) # 获取模型中匹配到的分组结果,只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果,只拿出匹配到的字符串中分组部分定义了key的组结果
alex bcd alex lge alex acd 19
('lex', '9')
{'n1': 'lex', 'n2': '9'}
3.6 re.findall(pattern, string[, flags])函数(常用)
findall(pattern, string, flags=0)
- pattern: 正则模型
- string : 要匹配的字符串
- falgs : 匹配模式
浏览全部字符串,匹配所有合规则的字符串,匹配到的字符串放到一个列表中,未匹配成功返回空列表
注意:一旦匹配成,再次匹配,是从前一次匹配成功的,后面一位开始的,也可以理解为匹配成功的字符串,不在参与下次匹配
import re
# 无分组
r = re.findall("\d+\w\d+", "a2b3c4d5") # 浏览全部字符串,匹配所有合规则的字符串,匹配到的字符串放到一个列表中
print(r) # 注意:匹配成功的字符串,不在参与下次匹配,所以3c4也符合规则但是没匹配到
['2b3', '4d5']
注意:如果没写匹配规则,也就是空规则,返回的是一个比原始字符串多一位的,空字符串列表
import re
# 无分组
r = re.findall("", "a2b3c4d5") # 浏览全部字符串,匹配所有合规则的字符串,匹配到的字符串放到一个列表中
print(r) # 注意:如果没写匹配规则,也就是空规则,返回的是一个比原始字符串多一位的,空字符串列表
['', '', '', '', '', '', '', '', '']
注意:正则匹配到空字符的情况,如果规则里只有一个组,而组后面是就表示组里的内容可以是0个或者多过,这样组里就有了两个意思,一个意思是匹配组里的内容,二个意思是匹配组里0内容(即是空白)所以尽量避免用否则会有可能匹配出空字符串
注意:正则只拿组里最后一位,如果规则里只有一个组,匹配到的字符串里在拿组内容是,拿的是匹配到的内容最后一位
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)*", origin)
print(r)
['', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', 'a', '', '', '', '', '', '']
无分组:匹配所有合规则的字符串,匹配到的字符串放到一个列表中
import re
# 无分组
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("a\w+", origin) # 浏览全部字符串,匹配所有合规则的字符串,匹配到的字符串放到一个列表中
print(r)
['alex', 'alex', 'alex', 'acd']
有分组:只将匹配到的字符串里,组的部分放到列表里返回,相当于groups()方法
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("a(\w+)", origin) # 有分组:只将匹配到的字符串里,组的部分放到列表里返回
print(r)
['lex', 'lex', 'lex', 'cd']
多个分组:只将匹配到的字符串里,组的部分放到一个元组中,最后将所有元组放到一个列表里返
相当于在group()结果里再将组的部分,分别,拿出来放入一个元组,最后将所有元组放入一个列表返回
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')]
分组中有分组:只将匹配到的字符串里,组的部分放到一个元组中,先将包含有组的组,看作一个整体也就是一个组,把这个整体组放入一个元组里,然后在把组里的组放入一个元组,最后将所有组放入一个列表返回
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()
import re
origin = "hello alex bcd alex lge alex acd 19"
# ?:在有分组的情况下,不只拿分组里的字符串,拿所有匹配到的字符串,注意?:只用于不是返回正则对象的函数如findall()
b = re.findall("a(?:\w+)", origin)
print(b)
['alex', 'alex', 'alex', 'acd']
3.7 re.split(pattern, string[, maxsplit])函数
根据正则匹配分割字符串,返回分割后的一个列表
split(pattern, string, maxsplit=0, flags=0)
- pattern: 正则模型
- string : 要匹配的字符串
- maxsplit:指定分割个数
- flags : 匹配模式
按照一个字符将全部字符串进行分割
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']
将匹配到的字符串作为分割标准进行分割
import re
origin = "hello alex bcd alex lge alex 2acd 19"
r = re.split("a\w+", origin) # 根据正则匹配分割字符串
print(r)
['hello ', ' bcd ', ' lge ', ' 2', ' 19']
3.8 re.sub(pattern, repl, string[, count])函数
替换匹配成功的指定位置字符串
sub(pattern, repl, string, count=0, flags=0)
- pattern: 正则模型
- repl : 要替换的字符串
- string : 要匹配的字符串
- count : 指定匹配个数
- flags : 匹配模式
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
3.9 re.subn(pattern, repl, string,[, count][, flags])函数
替换匹配成功的指定位置字符串,并且返回替换次数,可以用两个变量分别接受
subn(pattern, repl, string, count=0, flags=0)
- pattern: 正则模型
- repl : 要替换的字符串
- string : 要匹配的字符串
- count : 指定匹配个数
- flags : 匹配模式
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
转载于:https://www.cnblogs.com/XuChengNotes/p/11402832.html
081 re正则表达式模块相关推荐
- python正则表达式需要模块_使用Python正则表达式模块,让操作更加简单
处理文本数据的一个主要任务就是创建许多以文本为基础的特性. 人们可能想要在文本中找出特定格式的内容,比如找出存在于文本中的电子邮件,或者大型文本中的电话号码. 虽然想要实现上述功能听起来很繁琐,但是如 ...
- python正则表达式模块
正则表达式是对字符串的最简约的规则的表述.python也有专门的正则表达式模块re. 正则表达式函数 释义 re.match() 从头开始匹配,匹配失败返回None,匹配成功可通过group(0)返回 ...
- python正则表达式模块_Python正则表达式模块(re模块)
Python是我接触到的第一门编程语言,虽然它足够简单,但是对于当时刚刚接触编程语言的我来说还是有些难度的,于是只是了解了一些Python的基本语法,稍微深入一点的地方都没怎么了解.不过,到现在为止, ...
- python如何打出英文括号_用python的re(正则表达式)模块匹配英文环境下的括号
在用re(正则表达式)模块匹配掉文本中的括号时,总是出现各种各样的问题,经过将近一个小时的摸索,终于找到了问题的所在. 案例: 将 txt = 'Linux系统安装 - 1.1(Av20994127, ...
- vb.net 正则 替换 第n个_Python中正则表达式模块详解
作者:python来源:SegmentFault 思否社区 正则表达式用来处理字符串,对字符串进行检索和替换,另外正则在python爬虫的应用也是相当广泛! 特点 灵活性.逻辑性和功能性非常强 可以迅 ...
- Python中re(正则表达式)模块函数学习
2019独角兽企业重金招聘Python工程师标准>>> Python正则表达式指南 今天学习了Python中有关正则表达式的知识.关于正则表达式的语法,不作过多解释,网上有许多学习的 ...
- python正则表达式模块_Python正则表达式函数模块
今天学习了Python中有关正则表达式的知识.关于正则表达式的语法,不作过多解释,网上有许多学习的资料.这里主要介绍python中常用的正则表达式处理函数. 方法/属性 作用 match() 决定 R ...
- python re正则匹配_python re正则表达式模块
模块的的作用主要是用于字符串和文本处理,查找,搜索,替换等 复习一下基本的正则表达式吧 .:匹配除了换行符以为的任意单个字符 *:匹配任意字符,一个,零个,多个都能匹配得到 俗称贪婪模式 +:匹配位于 ...
- Python中re(正则表达式)模块学习
re.match re.match 尝试从字符串的开始匹配一个模式,如:下面的例子匹配第一个单词. import re text = "JGood is a handsome boy, he ...
- python正则表达式模块_Python正则表达式模块re
正则表达式是一种通用的字符串匹配模式,使用灵活功能强大. Python正则表达式支持的语法可以参见这张表 Python的标准模块re提供了对正则表达式的支持,使用r'' 表示正则字符串可以避免转义字符 ...
最新文章
- CoreAPI_对象三种状态
- php 去掉不可见字符串,php去掉指定字符串的办法
- 案例讲解asp.net中jquery post的用法
- HDU 6581 Vacation
- 13.相机和图像——聚焦于对象实战,不断变化的焦距,景深_3
- Ubuntu linux下的录屏
- Android 系统(167)----OTA升级常见问题
- 头歌c语言答案循环结构,C语言的“汤头歌”
- programming paradigm
- 全文 40000 字,最强(全) Matplotlib 实操指南
- 龙芯9341屏驱动开发过程(GUI、增加tty 裸奔版)
- 编包----rpm和deb和ISO目录制作出ISO
- NSSCTF ez_unserialize
- 现代计算机理论模型与工作方式
- 中诚信报告预计2019年中国GDP增长率约6.3%
- 三维图像高斯金字塔matlab,图像拼接中 高斯金字塔的建立 matlab程序详细解释 现金奖励...
- 安全HCIP之华为USG6000
- 索引左前缀性的三层意思
- 各版本Nexus S大全
- 200G绘声绘影素材以及教学视频送给你
热门文章
- SpringBoot学习(二)SpringBoot自动装配原理
- Leetcode 207. 课程表(值得一刷的宽搜)
- 144hz和60hz测试软件,144hz显示器与60hz采集卡(等同于60hz显示器)复制画面后程序帧率异常...
- BIO、NIO和AIO的区别简述
- 邮箱大师手机版服务器异常,邮箱大师安装步骤 邮箱大师常见问题
- 阶段3 3.SpringMVC·_06.异常处理及拦截器_4 SpringMVC拦截器之介绍和搭建环境
- 阶段3 1.Mybatis_11.Mybatis的缓存_2 延迟加载和立即加载的概念
- HDU2072 tri树/map/set/字符串hash
- webpack打包vue项目IE报错,“对象不支持“use”属性或方法”
- Java语言中的泛型