- import re
- help(re.compile)
- '''
- 输出结果为:
- Help on function compile in module re:
- compile(pattern, flags=0)
- Compile a regular expression pattern, returning a pattern object.
- 通过 help 可知: 编译一个正则表达式模式, 返回一个模式对象.
- ''''''
- 第二个参数 flags 是匹配模式, 可以使用按位或'|'表示同时生效, 也可以在正则表达式字符串中指定.
- Pattern 对象是不能直接实例化的, 只能通过 compile 方法得到. 匹配模式有:
- 1).re.I(re.IGNORECASE): 忽略大小写
- 2).re.M(MULTILINE): 多行模式, 改变'^'和'$'的行为
- 3).re.S(DOTALL): 点任意匹配模式, 改变'.'的行为
- 4).re.L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
- 5).re.U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于 unicode 定义的字符属性
- 6).re.X(VERBOSE): 详细模式. 这个模式下正则表达式可以是多行, 忽略空白字符, 并可以加入注释
- '''text="JGod is a handsome boy ,but he is a ider"print re.findall(r'\w*o\w*',text) #查找有 o 的单词
- # 输出结果为:['JGod', 'handsome', 'boy']
- # 利用 compile 生成一个规则模式吧, 然后利用 findall 将某一个对象内容进行匹配., 合适则输出符合规则的内容
- regex=re.compile(r'\w*o\w*')
- print regex.findall(text)
- #>>> ['JGod', 'handsome', 'boy']
- test1="who you are,what you do,When you get get there? What is time you state there?"
- regex1=re.compile(r'\w*wh\w*',re.IGNORECASE)
- wh=regex1.findall(test1)
- print wh
- #>>> ['who', 'what', 'When', 'What']
- '''
- re 正则表达式模块还包括一些有用的操作正则表达式的函数. 下面主要介绍 match 函数以及 search 函数.
- 定义: re.match 尝试从字符串的开始匹配一个模式.
- 原型:
- re.match(pattern, string, flags)
- 第一个参数是正则表达式, 如果匹配成功, 则返回一个 Match, 否则返回一个 None;
- 第二个参数表示要匹配的字符串;
- 第三个参数是标致位, 用于控制正则表达式的匹配方式, 如: 是否区分大小写, 多行匹配等等.
- 函数的返回值为真或者假.
- 例如: match('p','python')返回值为真; match('p','www.python.org')返回值为假.
- 定义: re.search 会在给定字符串中寻找第一个匹配给定正则表达式的子字符串.
- 函数的返回值: 如果查找到则返回查找到的值, 否则返回为 None.
- 原型:
- re.search(pattern, string, flags)
- 每个参数的含意与 re.match 一样.
- '''
- #re.match 的例子 1
- import re
- your_love=re.match("wh","What are you doing? who is you mate?",re.I)
- if your_love:
- print "you are my angle"
- else:
- print "i lose you"
- # 相当于:
- print "*"*100 #便于区分
- import re
- content="What are you doing? who is your mate?"
- regu_cont=re.compile("\w*wh\w*",re.I)
- yl=regu_cont.match(content)
- if yl:
- print yl.group(0)
- else:
- print "what happen?"
- 解析: 首先创造了需要正则表达式匹配的字符串 content;
- 接着利用 re.compile()来创建了我们所需要的匹配规则, 创建了模式对象 regu_cont;
- yl 用来接收对内容 content 字符串进行 regu_cont 正则表达式实现 match 函数的结果
- 如果有 yl 不为空, 则使用 m.group(index)输出查找到的子字符串
- 否则(返回值为 None) print "what happen?"
- match 例子 2
- '''
- match 如果查找到结果, 将返回一个 MatchObject, 你可以查询 MatchObject 关于匹配字符串的相关信息了. MatchObject 实例也有几个方法和属性; 最重要的那些如下所示:
- group() 返回被 RE 匹配的字符串
- start() 返回匹配开始的位置
- end() 返回匹配结束的位置
- span() 返回一个元组包含匹配 (开始, 结束) 的位置
- '''
- import re
- content="What are you doing? who is your mate?"
- regu_cont=re.compile("\w*wh\w*",re.I)
- yl=regu_cont.match(content)
- if yl:
- print yl.group(0)
- else:
- print "pass the test"
- print yl.group()
- print yl.start()
- print yl.end()
- print yl.span()
执行结果为:
- What
- What
- 0
- 4
- (0, 4)
- #search()方法与 match()方法类似
- import re
- content='Where are you from? You look so hansome.'
- regex=re.compile(r'\w*som\w*')
- m=regex.search(content)
- if m:
- print m.group(0)
- else:
- print "Not found"
- # 相当于:
- import re
- m=re.search(r'\w*som\w*','Where are you from? You look so handsome.',re.I)
- if m:
- print m.group(0)
- else:
- print "not found"
re 模块官方说明文档 https://docs.python.org/3/library/re.html
正则匹配的时候, 第一个字符是 r, 表示 raw string 原生字符, 意在声明字符串中间的特殊字符不用转义.
比如表示 '\n', 可以写 r'\n', 或者不适用原生字符 '\n'.
推荐使用 re.match
re.compile() 函数
编译正则表达式模式, 返回一个对象. 可以把常用的正则表达式编译成正则表达式对象, 方便后续调用及提高效率.
re.compile(pattern, flags=0)
pattern 指定编译时的表达式字符串
flags 编译标志位, 用来修改正则表达式的匹配方式. 支持 re.L|re.M 同时匹配
flags 标志位参数
re.I(re.IGNORECASE)
使匹配对大小写不敏感
re.L(re.LOCAL)
做本地化识别 (locale-aware) 匹配
re.M(re.MULTILINE)
多行匹配, 影响 ^ 和 $
re.S(re.DOTALL)
使 . 匹配包括换行在内的所有字符
re.U(re.UNICODE)
根据 Unicode 字符集解析字符. 这个标志影响 \w, \W, \b, \B.
re.X(re.VERBOSE)
该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解.
示例:
- ? https://www.jb51.net/article/141830.htm#
- import re
- content = 'Citizen wang , always fall in love with neighbour,WANG'
- rr = re.compile(r'wan\w', re.I) # 不区分大小写
- print(type(rr))
- a = rr.findall(content)
- print(type(a))
- print(a)
findall 返回的是一个 list 对象
- <class '_sre.SRE_Pattern'>
- <class 'list'>
- ['wang', 'WANG']
re.match() 函数
总是从字符串'开头曲匹配', 并返回匹配的字符串的 match 对象 <class '_sre.SRE_Match'>.
re.match(pattern, string[, flags=0])
pattern 匹配模式, 由 re.compile 获得
string 需要匹配的字符串
- ? https://www.jb51.net/article/141830.htm#
- import re
- pattern = re.compile(r'hello')
- a = re.match(pattern, 'hello world')
- b = re.match(pattern, 'world hello')
- c = re.match(pattern, 'hell')
- d = re.match(pattern, 'hello')
- if a:
- print(a.group())
- else:
- print('a 失败')
- if b:
- print(b.group())
- else:
- print('b 失败')
- if c:
- print(c.group())
- else:
- print('c 失败')
- if d:
- print(d.group())
- else:
- print('d 失败')
- hello
b 失败
c 失败
hello
match 的方法和属性
参考链接 https://www.jb51.net/article/124588.htm
- ? https://www.jb51.net/article/141830.htm#
- import re
- str = 'hello world! hello python'
- pattern = re.compile(r'(?Phell\w)(?P\s)(?P.*ld!)') # 分组, 0 组是整个 hello world!, 1 组 hello,2 组 ld!
- match = re.match(pattern, str)
- print('group 0:', match.group(0)) # 匹配 0 组, 整个字符串
- print('group 1:', match.group(1)) # 匹配第一组, hello
- print('group 2:', match.group(2)) # 匹配第二组, 空格
- print('group 3:', match.group(3)) # 匹配第三组, ld!
- print('groups:', match.groups()) # groups 方法, 返回一个包含所有分组匹配的元组
- print('start 0:', match.start(0), 'end 0:', match.end(0)) # 整个匹配开始和结束的索引值
- print('start 1:', match.start(1), 'end 1:', match.end(1)) # 第一组开始和结束的索引值
- print('start 2:', match.start(1), 'end 2:', match.end(2)) # 第二组开始和结束的索引值
- print('pos 开始于:', match.pos)
- print('endpos 结束于:', match.endpos) # string 的长度
- print('lastgroup 最后一个被捕获的分组的名字:', match.lastgroup)
- print('lastindex 最后一个分组在文本中的索引:', match.lastindex)
- print('string 匹配时候使用的文本:', match.string)
- print('re 匹配时候使用的 Pattern 对象:', match.re)
- print('span 返回分组匹配的 index (start(group),end(group)):', match.span(2))
返回结果:
group 0: hello world!
- group 1: hello
- group 2:
- group 3: world!
- groups: ('hello', '','world!')
- start 0: 0 end 0: 12
- start 1: 0 end 1: 5
- start 2: 0 end 2: 6
pos 开始于: 0
endpos 结束于: 25
lastgroup 最后一个被捕获的分组的名字: last
lastindex 最后一个分组在文本中的索引: 3
string 匹配时候使用的文本: hello world! hello python
re 匹配时候使用的 Pattern 对象: re.compile('(?P<first>hell\\w)(?P<symbol>\\s)(?P<last>.*ld!)')
span 返回分组匹配的 index (start(group),end(group)): (5, 6)
re.search 函数
对整个字符串进行搜索匹配, 返回第一个匹配的字符串的 match 对象.
re.search(pattern, string[, flags=0])
pattern 匹配模式, 由 re.compile 获得
string 需要匹配的字符串
- ? https://www.jb51.net/article/141830.htm#
- import re
- str = 'say hello world! hello python'
- pattern = re.compile(r'(?Phell\w)(?P\s)(?P.*ld!)') # 分组, 0 组是整个 hello world!, 1 组 hello,2 组 ld!
- search = re.search(pattern, str)
- print('group 0:', search.group(0)) # 匹配 0 组, 整个字符串
- print('group 1:', search.group(1)) # 匹配第一组, hello
- print('group 2:', search.group(2)) # 匹配第二组, 空格
- print('group 3:', search.group(3)) # 匹配第三组, ld!
- print('groups:', search.groups()) # groups 方法, 返回一个包含所有分组匹配的元组
- print('start 0:', search.start(0), 'end 0:', search.end(0)) # 整个匹配开始和结束的索引值
- print('start 1:', search.start(1), 'end 1:', search.end(1)) # 第一组开始和结束的索引值
- print('start 2:', search.start(1), 'end 2:', search.end(2)) # 第二组开始和结束的索引值
- print('pos 开始于:', search.pos)
- print('endpos 结束于:', search.endpos) # string 的长度
- print('lastgroup 最后一个被捕获的分组的名字:', search.lastgroup)
- print('lastindex 最后一个分组在文本中的索引:', search.lastindex)
- print('string 匹配时候使用的文本:', search.string)
- print('re 匹配时候使用的 Pattern 对象:', search.re)
- print('span 返回分组匹配的 index (start(group),end(group)):', search.span(2))
注意 re.search 和 re.match 匹配的 str 的区别
打印结果:
group 0: hello world!
- group 1: hello
- group 2:
- group 3: world!
- groups: ('hello', '','world!')
- start 0: 4 end 0: 16
- start 1: 4 end 1: 9
- start 2: 4 end 2: 10
pos 开始于: 0
endpos 结束于: 29
lastgroup 最后一个被捕获的分组的名字: last
lastindex 最后一个分组在文本中的索引: 3
string 匹配时候使用的文本: say hello world! hello python
re 匹配时候使用的 Pattern 对象: re.compile('(?P<first>hell\\w)(?P<symbol>\\s)(?P<last>.*ld!)')
span 返回分组匹配的 index (start(group),end(group)): (9, 10)
PS: 这里再为大家提供 2 款非常方便的正则表达式工具供大家参考使用:
JavaScript 正则表达式在线测试工具:
http://tools.jb51.net/regex/javascript
正则表达式在线生成工具:
- http://tools.jb51.net/regex/create_reg
- https://www.cnblogs.com/huangdongju/p/7839697.html
来源: http://www.bubuko.com/infodetail-2690695.html