美文网首页
Day-15 正则表达式

Day-15 正则表达式

作者: FansYuercero | 来源:发表于2018-08-03 20:47 被阅读0次

正则表达式：用来查找、匹配、切割字符串的工具

Python对正则表达式的支持：re模块(Python内置模块)
re模块包含字符串匹配、查找、切割等相关方法
fullmatch(正则表达式，需要匹配的功能):用正则表达式来和字符串进行匹配，看是佛能够匹配成功
fullmatch:完全匹配，从字符串开头到结尾

match：从开始往后匹配，如果可以匹配成功，则字符串后面的不再匹配
正则表达式：是一个符合正则规范的字符串

import  re
if __name__ == '__main__':
    #1. .:匹配一个任意字符
    # re_str =r'.' 一个字符
    # re_str = r'a.'第一个是a，第二个任意字符
    # r--->正则表达式的字符串前面一般加'r'来阻止转义,因为正则表达式的符号中有很多带'\'的符号，表示特殊的意义
    re_str = r'..'
    print(re.fullmatch(re_str,'ab'))
    # re_str = 'ab'那只能匹配ab字符串
    # 2.\w --->匹配一个字符是字母、数字、或者下划线
    re_str =r'\w'
    # re_str = r'\w..' 第一个是字母数字下划线，后两个任意字符
    # re_str = r'\w\w'  2个数字、字母、下划线
    print(re.fullmatch(re_str,'_'))
    # 3.\s 匹配1个空白字符(空格、tab(\t)、回车(\n))
    re_str = r'\s'
    # re_str = r'a\sb' 匹配第一个字符是a,第二个是空白,最后是b的字符串
    # print(re.fullmatch(re_str,'a\nb'))
    print(re.fullmatch(re_str,'\t'))
    # 4.\d 匹配1个数字字符
    re_str = r'\d'
    # re_str = r'\d\d\d'匹配三个数字的字符串
    # print(re.fullmatch(re_str,'123'))
    print(re.fullmatch(re_str,'1'))
    # 5.\b 检测单词的边界(字符串结束，字符串开头,单词边界)
    # 三个任意字符的前面和后面都是单词边界的字符串
    # re_str = r'\b...'
    # print(re.match(re_str,'123346'))
    # print(re.match(re_str,'123'))
    re_str = r'\bjsg'
    print(re.match(re_str,'jsg,abc1'))
    # 6. ^匹配字符串以什么开始
    re_str = r'^ss...'
    print(re.fullmatch(re_str,'ssaaa'))
    #匹配无意义，查找时使用，因为fullmatch就是从开始到结束匹配
    print(re.findall(r'^ada','ada123 ada456'))
    # 7. $检测字符串结束
    re_str = r'.abc$'
    print(re.fullmatch(re_str,'1abc'))
    re_str = r'....abc$'
    print(re.fullmatch(re_str,'a122abc'))
    # 8.\W 匹配非字母、数字、下划线
    re_str = r'\W\w'
    print(re.fullmatch(re_str,'*2'))
    # 9.\S 匹配非空白字符
    re_str = r'\S\s'
    print(re.fullmatch(re_str,'*\n'))
    # 10.\D 匹配非数字
    re_str = r'\D\d'
    print(re.fullmatch(re_str,'*1'))
    # 11.\B 检测非边界
    # \B不能放在fullmatch字符串的前后和match的前面，可以放在中间，或match的后面
    re_str = r'ab\Bc'
    # 检测ab的后面不是边界，c的前面不是边界
    print(re.fullmatch(re_str,'abc'))
    print(re.match(re_str,'abc'))


<_sre.SRE_Match object; span=(0, 2), match='ab'>
<_sre.SRE_Match object; span=(0, 1), match='_'>
<_sre.SRE_Match object; span=(0, 1), match='\t'>
<_sre.SRE_Match object; span=(0, 1), match='1'>
<_sre.SRE_Match object; span=(0, 3), match='jsg'>
<_sre.SRE_Match object; span=(0, 5), match='ssaaa'>
['ada']
<_sre.SRE_Match object; span=(0, 4), match='1abc'>
<_sre.SRE_Match object; span=(0, 7), match='a122abc'>
<_sre.SRE_Match object; span=(0, 2), match='*2'>
<_sre.SRE_Match object; span=(0, 2), match='*\n'>
<_sre.SRE_Match object; span=(0, 2), match='*1'>
<_sre.SRE_Match object; span=(0, 3), match='abc'>
<_sre.SRE_Match object; span=(0, 3), match='abc'>

import re
if __name__ == '__main__':
    # 1.[] 匹配[]中出现的任意一个字符。
    # 匹配字符串前三位是abc开始，第4位是1或者q
    re_str = r'abc[1q].'
    print(re.fullmatch(re_str,'abc12'))
    print(re.fullmatch(re_str, 'abcq1'))
    # 2.[^]匹配不再[]中出现的任意一个字符
    # 匹配一个字符串，前三位是acc第4位不是123的字符串
    # re_str = r'acc[^123]'
    re_str = r'acc[^\da]'
    print(re.fullmatch(re_str,'accb'))
    # [0-9]匹配0-9的任意一个数字
    # [a-z]匹配小写字母
    # [A-Z]匹配大写字母
    # [a-zA-z]匹配所有字母
    # re_str = r'[-a-zA-Z]\w*' 标识符
    # 3.*匹配0次或者多次
    re_str = r'\d*abc'
    print(re.fullmatch(re_str,'abc'))
    print(re.fullmatch(re_str,'1abc'))
    print(re.fullmatch(re_str,'123abc'))
    # 4.+:匹配一次或多次
    re_str = r'\d+a*'
    #至少一次数字,+至少0次字母
    print(re.fullmatch(re_str,'111aa'))
    print(re.fullmatch(re_str,'22aa'))
    # 5.?:匹配0次或者1次
    re_str = r'[a-z]?123'
    print(re.fullmatch(re_str,'123'))
    print(re.fullmatch(re_str,'s123'))

    # re_str =r'[1-9]\d*'
    # re_str =r'\+?[1-9]\d*'
    # re_str =r'[+]?[1-9]\d*'
    # 6.{N} 匹配N次
    # re_str =r'\d{5}abc'
    print(re.fullmatch(re_str,'12345abc'))
    # 7.{M,}至少匹配M次 >=M次
    re_str = r'\d{3,}\w*'
    print(re.fullmatch(re_str,'123abc'))
    print(re.fullmatch(re_str, '1223abcd'))
    # 8.{M,N}匹配次数 M<=次数<=N
    re_str =r'\d{8,16}'
    print(re.fullmatch(re_str,'12345678'))
    re_str = r'[\da-zA-z]{8,16}'
    # 9.| 分支
    # 匹配三个数字或者三个小写字母
    re_str = r'\d{3}|[a-z]{3}'
    print(re.fullmatch(re_str,'123'))
    # 10.()匹配的时候是分组，让括号中的正则条件变成一个整体
    # 匹配一个字符串，a1整体重复3次
    re_str = r'(a1){3}'
    print(re.fullmatch(re_str,'a1a1a1'))

    #=====================================
    #11.*？重复1次或多次，尽可能少的重复
    re_str = r'a*?'
    print(re.match(re_str,'aaaaa'))
    #12.??重复0次或者1次，尽可能少的重复
    re_str = r'b??'
    #13.{M,N}? 重复M-N范围，0次或1次，尽可能少的重复
    #14.{N,}?重复至少N次，尽可能少的重复


<_sre.SRE_Match object; span=(0, 5), match='abc12'>
<_sre.SRE_Match object; span=(0, 5), match='abcq1'>
<_sre.SRE_Match object; span=(0, 4), match='accb'>
<_sre.SRE_Match object; span=(0, 3), match='abc'>
<_sre.SRE_Match object; span=(0, 4), match='1abc'>
<_sre.SRE_Match object; span=(0, 6), match='123abc'>
<_sre.SRE_Match object; span=(0, 5), match='111aa'>
<_sre.SRE_Match object; span=(0, 4), match='22aa'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 4), match='s123'>
None
<_sre.SRE_Match object; span=(0, 6), match='123abc'>
<_sre.SRE_Match object; span=(0, 8), match='1223abcd'>
<_sre.SRE_Match object; span=(0, 8), match='12345678'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 6), match='a1a1a1'>
<_sre.SRE_Match object; span=(0, 0), match=''>

import re
if __name__ == '__main__':
    # 1.[] 匹配[]中出现的任意一个字符。
    # 匹配字符串前三位是abc开始，第4位是1或者q
    re_str = r'abc[1q].'
    print(re.fullmatch(re_str,'abc12'))
    print(re.fullmatch(re_str, 'abcq1'))
    # 2.[^]匹配不再[]中出现的任意一个字符
    # 匹配一个字符串，前三位是acc第4位不是123的字符串
    # re_str = r'acc[^123]'
    re_str = r'acc[^\da]'
    print(re.fullmatch(re_str,'accb'))
    # [0-9]匹配0-9的任意一个数字
    # [a-z]匹配小写字母
    # [A-Z]匹配大写字母
    # [a-zA-z]匹配所有字母
    # re_str = r'[-a-zA-Z]\w*' 标识符
    # 3.*匹配0次或者多次
    re_str = r'\d*abc'
    print(re.fullmatch(re_str,'abc'))
    print(re.fullmatch(re_str,'1abc'))
    print(re.fullmatch(re_str,'123abc'))
    # 4.+:匹配一次或多次
    re_str = r'\d+a*'
    #至少一次数字,+至少0次字母
    print(re.fullmatch(re_str,'111aa'))
    print(re.fullmatch(re_str,'22aa'))
    # 5.?:匹配0次或者1次
    re_str = r'[a-z]?123'
    print(re.fullmatch(re_str,'123'))
    print(re.fullmatch(re_str,'s123'))

    # re_str =r'[1-9]\d*'
    # re_str =r'\+?[1-9]\d*'
    # re_str =r'[+]?[1-9]\d*'
    # 6.{N} 匹配N次
    # re_str =r'\d{5}abc'
    print(re.fullmatch(re_str,'12345abc'))
    # 7.{M,}至少匹配M次 >=M次
    re_str = r'\d{3,}\w*'
    print(re.fullmatch(re_str,'123abc'))
    print(re.fullmatch(re_str, '1223abcd'))
    # 8.{M,N}匹配次数 M<=次数<=N
    re_str =r'\d{8,16}'
    print(re.fullmatch(re_str,'12345678'))
    re_str = r'[\da-zA-z]{8,16}'
    # 9.| 分支
    # 匹配三个数字或者三个小写字母
    re_str = r'\d{3}|[a-z]{3}'
    print(re.fullmatch(re_str,'123'))
    # 10.()匹配的时候是分组，让括号中的正则条件变成一个整体
    # 匹配一个字符串，a1整体重复3次
    re_str = r'(a1){3}'
    print(re.fullmatch(re_str,'a1a1a1'))

    #=====================================
    #11.*？重复1次或多次，尽可能少的重复
    re_str = r'a*?'
    print(re.match(re_str,'aaaaa'))
    #12.??重复0次或者1次，尽可能少的重复
    re_str = r'b??'
    #13.{M,N}? 重复M-N范围，0次或1次，尽可能少的重复
    #14.{N,}?重复至少N次，尽可能少的重复

<_sre.SRE_Match object; span=(0, 5), match='abc12'>
<_sre.SRE_Match object; span=(0, 5), match='abcq1'>
<_sre.SRE_Match object; span=(0, 4), match='accb'>
<_sre.SRE_Match object; span=(0, 3), match='abc'>
<_sre.SRE_Match object; span=(0, 4), match='1abc'>
<_sre.SRE_Match object; span=(0, 6), match='123abc'>
<_sre.SRE_Match object; span=(0, 5), match='111aa'>
<_sre.SRE_Match object; span=(0, 4), match='22aa'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 4), match='s123'>
None
<_sre.SRE_Match object; span=(0, 6), match='123abc'>
<_sre.SRE_Match object; span=(0, 8), match='1223abcd'>
<_sre.SRE_Match object; span=(0, 8), match='12345678'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 6), match='a1a1a1'>
<_sre.SRE_Match object; span=(0, 0), match=''>

import re
if __name__ == '__main__':
    re_srt = r'\d+\.\d+'
    print(re.fullmatch(re_srt,'123.68'))

    # \加数字：匹配前面第N个组中匹配到的内容
    re_srt = r'([1-9][a-z]{2})\1'
    print(re.fullmatch(re_srt,'1acac'))

    re_srt = r'[1-9]\d{4,11}'
    re_srt = r'\w{6,20}'
    re_srt =r'((25[0-5]|2[0-4]\d|((1\d{2})|([1-9]?\d)))\.){3}(25[0-5]|2[0-4]\d|((1\d{2})|([1-9]?\d)))'
    print(re.fullmatch(re_srt,'192.168.1.1'))
    re_str = r'((25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)'
    print(re.fullmatch(re_str, '0.168.234.255'))
    re_srt = r'((\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.){3}(\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])'
    print(re.fullmatch(re_str, '192.168.1.1'))

<_sre.SRE_Match object; span=(0, 11), match='192.168.1.1'>
<_sre.SRE_Match object; span=(0, 13), match='0.168.234.255'>
<_sre.SRE_Match object; span=(0, 11), match='192.168.1.1'>

python对正则表达式的支持

# 1.compile(正则字符串):将正则表达式字符串转换为正则表达式对象
    # 转换为正则表达式对象后，可以通过对象调用相关方法
    re_obct = re.compile(r'\w{6,12}')
    print(re_obct.fullmatch('asd_daw'))

<_sre.SRE_Match object; span=(0, 7), match='asd_daw'>

# 2.匹配相关的方法
    # fullmatch(正则表达式，字符串)
    # 完全匹配，从字符串开头匹配到结束，返回一个匹配对象
    # 匹配失败返回None
    match = re.fullmatch(r'\w{3}','a_a')
    print(match)
    # a.获取匹配结果
    print(match.group())
    # b.获取匹配到的范围
    print(match.span())
    # c.获取匹配的开始下标与结束下标
    print(match.start(),match.end())
    # d.获取被匹配的字符串(元字符串)
    print(match.string)
    # 判断一个字符串是否是某种字符


<_sre.SRE_Match object; span=(0, 3), match='a_a'>
a_a
(0, 3)
0 3
a_a

    # 3.match(正则表达式，字符串)不完全匹配，从字符串开头开始匹配，匹配到正则表达式对应的范围为止
    # 类似于判断是否以正则表达式开头
    match  = re.match(r'\w{3}','abc**')
    print(match)
    # 判断一个字符串是否以某种字符串开头


<_sre.SRE_Match object; span=(0, 3), match='abc'>
[Finished in 0.3s]

# 4.search(正则表达式，字符串)在指定的字符串中
    # 查找以正则表达式描述的字符串，如果有多个只返回第一个,没有返回None
    print(re.search(r'\d{2,}[a-z]','a23na123n--123b'))
    search = re.search(r'\d{2,}[a-z]','a23na123n--123b')
    print(search)

<_sre.SRE_Match object; span=(0, 3), match='abc'>
<_sre.SRE_Match object; span=(1, 4), match='23n'>


# 5.re.findall(正则表达式，字符串)去获取指定字符串中满足正则条件的所有的子串
    # 如果有多个返回一个子串列表，没有返回空列表[]
    print(re.findall(r'\d{2,}[a-z]','--12a*ad(123aa*'))
    print(re.findall(r'[a-zA-z](\d)', '--a12a*ad923aa*'))
    #在通过正则表达式获取子串的时候，可以通过在正则表达式中添加括号，
    #来约束()中的内容，只获取括号中的内容，匹配的时候还是按正则表达式查找
    #字符串提取

['12a', '123a']
['1', '9']

# 6.re.finditer(正则表达式，字符串)
    # 返回的是一个迭代器，迭代器的内容是匹配对象
    # 表达式中()捕获无效
    result = re.finditer(r'\d{2,}[a-z]','--12a*ad(123qq*')
    for x in result:
        print(x)
<_sre.SRE_Match object; span=(2, 5), match='12a'>
<_sre.SRE_Match object; span=(9, 13), match='123q'>
[Finished in 0.2s]

# 7.re.split正则表达式，字符串)
    #按正则表达式匹配到的字符串进行切割,返回值是列表，列表元素就是切割后、
    # 被分段的字符串
    print(re.split(r'\d*','sa1ada12dad123ds1234d3(&'))
['sa', 'ada', 'dad', 'ds', 'd', '(&']

# 8.re.sub(正则表达式,替换字符串,原字符串)
    #在原字符串中查找符合正则的子串，替换成新的字符串
    print(re.sub(r'a|b|c|d','*','happy birstay today hava fun'))

h*ppy *irst*y to**y h*v* fun
[Finished in 0.2s]

相关文章

  • Day-15 正则表达式

    正则表达式：用来查找、匹配、切割字符串的工具 python对正则表达式的支持

  • day-15正则表达式awk

    cut 切割按列切割 -d 指定分隔符 -f 指定列 三剑客 grep过滤查找内容。 sed取行，增删改查 awk...

  • DAY-15

  • 快书速读：《学习之道》

    【大螺丝】打卡 | 快书速读 Day-15 首先，起心动念是根基，要知道你想学是为什么，以及愿意付出多大的成本。比...

  • #25天打卡学宁向东的管理学课

    Day-15 冲突识别丨研判情势最重要 学习重点： 1、中国人讲求中庸之道，我们总的来说不太善于处理冲突。 2、冲...

  • day-15 作业

  • day-15作业

    1.声明⼀个电脑类: 属性:品牌、颜⾊、内存⼤小 方法:打游戏、写代码、看视频 a.创建电脑类的对象，然后通过对象...

  • day-15 类

    类和对象 1.什么是类，什么是对象 类就是拥有相同功能和相同属性的对象的集合：类是抽象的对象就是累的实例：对象是具...

  • Day-15 练习

    1.声明一个电脑类: 属性:品牌、颜色、内存大小 方法:打游戏、写代码、看视频a.创建电脑类的对象，然后通过对象点...

  • Day-15(5.12)

    临摹。 狐狸一系列 早上起来玩到现在才开始画画∪･ω･∪ 狐狸脚一不小心画粗掉了。 画偏了一点。 春日。 脸和狗画...

网友评论

      本文标题：Day-15 正则表达式

      本文链接：https://www.haomeiwen.com/subject/rvsyvftx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|Day-15 正则表达式|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！