笔记

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

python对正则表达式的支持：提供了re模块（python模块），包含字符串匹配、查找、切割等相关方法。

正则表达式的符号

fullmatch(正则表达式，字符串)：用正则表达式来和字符串进行匹配，看是否能够匹配成功。
正则表达式：是一个符合正则规范的字符串。"""
import re

if __name__ == '__main__':
    # 注意正则表达式的字符串，前面一般要加阻止转义字符（r or R）。因为正则表达式中有很多带‘\’的符号，其功能不是转义，而是表示特殊的意义。

    # 1. . : 匹配（点的个数个）任意字符
    """匹配一个任意字符的字符串"""
    re_str = '.'  # 泛华
    """匹配字符是a的字符串"""
    re_str = 'a'  # 具化
    m = re.fullmatch(re_str, 'a')
    print(m)  # <_sre.SRE_Match object; span=(0, 1), match='a'>
    """匹配第一个字符是a，第二个字符是任意字符的字符串"""
    re_str = r'a.'  # 局部具化
    n = re.fullmatch(re_str, 'ah')

    # 2. \w ： 匹配( \w的个数个)字符是字母、数字或者下划线
    """匹配一个字符是字母、数字或者下划线"""
    re_str = r'\w'
    m = re.fullmatch(re_str, 'b')
    print(m)

    # 3. \s ：匹配一个空白字符（空格、换行、制表符）
    """匹配第一个字符是a,第二个字符是空白，最后一个字符是b的字符串"""
    re_str = r'a\sb'
    print(re.fullmatch(re_str, 'a\nb'))

    # 4. \d  : 匹配一个数字字符
    re_str = r'\d\d\d'
    print(re.fullmatch(re_str, '120'))
    # 匹配第一个字符是0，后面两个字符都是数字的字符串
    re_str = r'0\d\d'
    print(re.fullmatch(re_str, '034'))

    # fullmatch 与 match 的区别
    """
    fullmatch: 匹配整个字符串
    match: 匹配整个字符串前面与正则表达式对应的部分字符串    """

    # 5. \b : 检测边界(单词边界--一般的符号都可以作为单词边界)
    print(re.match(re_str, '0190'))
    """匹配任意三个字符的前面和后面都是单词边界的字符串"""
    re_str = r'\b...\b'
    print(re.match(re_str, 'jsh,abc'))

    # 6. ^  : 检测字符串开始（^The --检测以The开头的字符串）
    re_str = r'^The'
    print(re.fullmatch(re_str, 'The'))
    print(re.findall(r'^The', '234657ThedsiufghTbs'))  # 查找

    # 7.  $ : 检测字符串结束
    re_str = r'abc$'
    print(re.findall(re_str, 'sdf fgs dsf abc'))

    # 8. \W ：匹配非字母、数字、下划线
    re_str = r'\W\w'
    print(re.fullmatch(re_str, '&k'))

    # 9. \S : 匹配非空白字符
    re_str = r'\S\d'
    print(re.fullmatch(re_str, 'p8'))

    # 10. \D : 匹配非数字
    """匹配第一个字母是非数字字符，第二个字符是字母、数字、下划线"""
    re_str = r'\D\w'

    # 11. \B : 检测非边界
    """匹配前面两个字符是a和b，第三个字符是c。并且检测b的后面是非边界"""
    re_str = r'ab\Bc'
    print(re.fullmatch(re_str, 'abd'))
    print(re.match(re_str, 'abc2'))

正则表达式符号组合

import reif __name__ == '__main__':    # 1.[] : 匹配[]中出现的任意一个字符
    """匹配一个字符串，前三位是abc,第四位是字符1或者字符a"""
    re_str = r'abc[1a]'
    print(re.fullmatch(re_str, 'abc1'))    """第一位是数字或者下划线，后面是abc"""
    re_str = r'[\d_]abc'
    print(re.fullmatch(re_str, '2abc'))    # 2.[^] : 匹配不在[]中出现的任意一个字符
    """匹配一个字符串，前三位是abc,第四位字符不是数字也不是a"""
    re_str = r'abc[^\da]'
    print(re.fullmatch(re_str, 'abci'))    # 3.* : 匹配0次或者多次
    """匹配一个字符串，前面是0个或者多个数字字符，然后是abc"""
    re_str = r'\d*abc'
    print(re.fullmatch(re_str, '1abc'))    """
    [0-9]:匹配任意一个数字
    [3-6]:匹配3/4/5/6
    [a-z]:匹配任意一个小写字母
    [A-Z]:匹配任意一个大写字母
    [a-zA-Z]:匹配所有的字母
    """
    print(re.fullmatch(r'[1-9]', '7'))    # 写一个正则表达式，判断一个字符串是数字字符串（不能空串）
    re_str = r'\d\d*'

    # 写一个正则表达式，检测一个字符串是否是合格的标识符（字母数字下划线组成，数字不能开头）
    # re_str = r'[\D\w]\w*' # []中类逻辑运算符or，而非and，故此法不通
    re_str = r'[a-zA-Z_]\w*'
    print(re.fullmatch(re_str, '1sdf'))    # 4. + ：匹配一次或者多次
    """匹配一个字符串开头出现一个或多个数字，后面出现零个或多个字母、数字、下划线"""
    re_str = r'\d+\w*'

    # 5. ? : 匹配零次或者一次
    re_str = r'[a-z]?123'
    print(re.fullmatch(re_str, 'z123'))    # 判断一个字符串是否是正整数字符串（除0）
    re_str = r'[+]?[1-9]\d*'
    # re_str = r'[1-9]\d*'
    print(re.fullmatch(re_str, '+123'))    # 5. {N} : 匹配N次
    """前面5个数字，然后是abc"""
    re_str = r'\d{5}abc'

    re_str = r'[12ab]{3}mn'

    # 写一个正则表达式能够匹配一个合格分数（0-100）
    re_str = r''

    # 6. {N,} : 匹配大于等于N次
    """字符串前面至少三位数字，后面随意"""
    re_str = r'\d{3,}.*'
    print(re.fullmatch(re_str, '123s'))    # 7. {M.N} : 匹配最少M次，最多N次
    """密码要求：数字、字母组成，并且8-16"""
    re_str = r'[\da-zA-Z]{8,16}'
    print(re.fullmatch(re_str, 'sdfgdv34'))    # 8. | : 分支
    """匹配一个字符串，是三个数字字符或者是三个小写字符"""
    re_str = r'\d{3}|[a-z]{3}'
    print(re.fullmatch(re_str, '123'))    # 9.（）：匹配的时候是分组，让括号中的正则条件变成一个整体，进行整体操作
    re_str = r'(abc){3}'
    print(re.fullmatch(re_str, 'abcabcabc'))

    re_str = r'(\d\w[0-3]){2}'
    print(re.fullmatch(re_str, '3o37h1'))    """==========以下了解=========="""
    # 10. *？ ：重复任意次，尽可能少的重复
    re_str = r'a*?'
    print(re.match(re_str, 'baaa'))    # 11. +？ ：重复任意次，最少重复一次，尽可能少的重复
    re_str = r'ba+?'
    print(re.match(re_str, 'baaa'))    # 12. ?? ：重复0次或一次，尽可能少的重复
    # 13. {N,}? ：重复至少N次，尽可能少的重复
    # 14. {N,M}? ：重复N-M次，尽可能少的重复
    """
    尽可能少：是在能够匹配到的前提下尽可能少
    正则表达式里面出现？，进入懒惰模式（常用于数据过滤）
    """

正则表达式

正则表达中：. \ [] {} () * + ? ^ $ |
这些字符有特殊意义，所以在正则表达式中，如果想要单纯表达这些字符，需要在前面加'\'

注意：
1.- [] \ ^ 在中括号里可能是特殊符号,需要加\

1. . {} () * + ?  $ | 在中括号里可以不用加\，来表示字符

import reif __name__ == '__main__':
    re_str = r'\d+.\d+'
    print(re.fullmatch(re_str, '12.89'))

    re_str = r'[\\\^]'  # 匹配^或\
    print(re.fullmatch(re_str, '^'))    # 1. \N ---> 匹配前面第N个组中匹配到的内容

    re_str = r'([1-9][a-z]{2})n(\d)\1\2'
    print(re.fullmatch(re_str, '9hjn09hj0'))    """
    练习1：
    用户名必须由字母、数字或下划线构成且长度在6~20个字符之间
    QQ号由5-12位数字组成且首位不能为0
    """
    re_str = r'\w{6,20}'

    re_str = r'[1-9]\d{4,11}'

    """
    判断IP地址是否合法：
    x.x.x.x
    """
    re_str = r'(([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.){3}([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])'
    # re_str = r'[0-255]\.[0-255]\.[0-255]\.[0-255]'#[]中范围最大0-9
    # re_str = r'^ (\\d{1, 2} | 1\\d\\d | 2[0-4]\\d | 25[0-5])\\.(\\d{1, 2} | 1\\d\\d | 2[0-4]\\d | 25[0-5])\\.(\\d{1, 2} | 1\\d\\d | 2[0-4]\\d | 25[0-5])\\.(\\d{1, 2} | 1\\d\\d | 2[0-4]\\d | 25[0-5])$'
    print(re.fullmatch(re_str, '10.7.23.254'))

re模块方法

import reif __name__ == '__main__':    # 1.compile(正则字符串)将正则表达式字符串转换成正则表达式对象
    # 转换成正则表达式对象后，可以通过对象调用相关的方法
    re_obct = re.compile(r'\w{6,12}')
    print(re_obct.fullmatch('esfrsedr'))
    print(re.fullmatch(r'\w{6,12}', 'esfrsedr'))    # 2.fullmatch(正则表达式，字符串)完全匹配，从字符串开头匹配到结尾
    # 返回值是匹配对象,如果匹配失败返回None
    match = re.fullmatch('\w{3}', 'h3s')
    print(match)    # a.获取匹配到的结果
    print(match.group())    # b.获取匹配到的范围
    print(match.span())    # c.获取匹配到的开始的下标和结束下标
    print(match.start(), match.end())    # d.获取匹配到的字符串（原字符串）
    print(match.string)    # 应用:判断一个字符串是否是某种字符串（判断账号、密码是否符合要求等）

    # 3.match(正则表达式，字符串)不完全匹配，从字符串开头匹配，匹配到正则表达式对应的范围为止
    # 返回值是匹配对象，如果匹配失败返回None
    match = re.match('\w{3}', 'h3strvsdc')
    print(match)
    print(match.group())
    print(match.string)    # 应用：判断一个字符串是否以某种字符串开头

    # 4.search(正则表达式，字符串)在指定的字符串找到某种字符串（以正则表达式来描述）
    print(re.search(r'\d{2,}[a-z]', 'fhuefh45t454uhuh435--dff4u'))    # 应用：判断一个字符串中是否包含某种字符串

    # 5.findall(正则表达式，字符串)去获取指定字符串中满足正则条件的所有字符串
    # 返回值是列表，列表中是符合要求的字符串。没有满足要求的字符串就返回[]
    result = re.findall(r'[a-z](\d+)', '123fdgv2324dfg')
    print(result)    # 注意：在通过正则表达式获取子串的时候，可以通过正则表达式中添加括号，来约束获取的内容（只捕获括号中匹配到的内容）
    #       匹配的时候还是按原正则表达式去查找

    # 应用：字符串提取

    # 6.finditer(正则表达式，字符串)用法和findall一样，只是返回值的类型不一样
    # 返回一个迭代器
    # 注意：（）捕获部分无效
    result = re.finditer(r'[a-z](\d+)', '123fdgv2324dfg')    for math in result:
        print(match)    # 7.split(正则表达式，字符串)按正则表达式匹配到的字符串进行切割
    # 返回值是列表，列表元素就是切割后被分段的字符串
    result = re.split(r'\d+', 'ef234guyhg65yug3u4g')
    print(result)    # 8.(正则表达式,repl，字符串)在原字符串中查找符合正则的子串，替换成repl

    """将指定字符串中所有‘sb'替换成'*'"""
    str1 = '你好sb,你全家都是sb'
    result = re.sub(r'sb', '*', str1)
    print(result)

相关资料

使用正则表达式

正则表达式相关知识

在编写处理字符串的程序或网页时，经常会有查找符合某些复杂规则的字符串的需要，正则表达式就是用于描述这些规则的工具，换句话说正则表达式是一种工具，它定义了字符串的匹配模式（如何检查一个字符串是否有跟某种模式匹配的部分或者从一个字符串中将与模式匹配的部分提取出来或者替换掉）。如果你在Windows操作系统中使用过文件查找并且在指定文件名时使用过通配符（*和?），那么正则表达式也是与之类似的用来进行文本匹配的工具，只不过比起通配符正则表达式更强大，它能更精确地描述你的需求（当然你付出的代价是书写一个正则表达式比打出一个通配符要复杂得多，要知道任何给你带来好处的东西都是有代价的，就如同学习一门编程语言一样），比如你可以编写一个正则表达式，用来查找所有以0开头，后面跟着2-3个数字，然后是一个连字号“-”，最后是7或8位数字的字符串（像028-12345678或0813-7654321），这不就是国内的座机号码吗。最初计算机是为了做数学运算而诞生的，处理的信息基本上都是数值，而今天我们在日常工作中处理的信息基本上都是文本数据，我们希望计算机能够识别和处理符合某些模式的文本，正则表达式就显得非常重要了。今天几乎所有的编程语言都提供了对正则表达式操作的支持，Python通过标准库中的re模块来支持正则表达式操作。

我们可以考虑下面一个问题：我们从某个地方（可能是一个文本文件，也可能是网络上的一则新闻）获得了一个字符串，希望在字符串中找出手机号和座机号。当然我们可以设定手机号是11位的数字（注意并不是随机的11位数字，因为你没有见过“25012345678”这样的手机号吧）而座机号跟上一段中描述的模式相同，如果不使用正则表达式要完成这个任务就会很麻烦。

关于正则表达式的相关知识，大家可以阅读一篇非常有名的博客叫《正则表达式30分钟入门教程》，读完这篇文章后你就可以看懂下面的表格，这是我们对正则表达式中的一些基本符号进行的扼要总结。

说明：如果需要匹配的字符是正则表达式中的特殊字符，那么可以使用\进行转义处理，例如想匹配小数点可以写成\.就可以了，因为直接写.会匹配任意字符；同理，想匹配圆括号必须写成\(和\)，否则圆括号被视为正则表达式中的分组。

Python对正则表达式的支持

Python提供了re模块来支持正则表达式相关操作，下面是re模块中的核心函数。

说明：上面提到的re模块中的这些函数，实际开发中也可以用正则表达式对象的方法替代对这些函数的使用，如果一个正则表达式需要重复的使用，那么先通过compile函数编译正则表达式并创建出正则表达式对象无疑是更为明智的选择。

下面我们通过一系列的例子来告诉大家在Python中如何使用正则表达式。

例子1：验证输入用户名和QQ号是否有效并给出对应的提示信息。

"""

验证输入用户名和QQ号是否有效并给出对应的提示信息

要求：
用户名必须由字母、数字或下划线构成且长度在6~20个字符之间
QQ号是5~12的数字且首位不能为0

"""import redef main():
    username = input('请输入用户名: ')
    qq = input('请输入QQ号: ')    # match函数的第一个参数是正则表达式字符串或正则表达式对象
    # 第二个参数是要跟正则表达式做匹配的字符串对象
    m1 = re.match(r'^[0-9a-zA-Z_]{6,20}$', username)    if not m1:
        print('请输入有效的用户名.')
    m2 = re.match(r'^[1-9]\d{4,11}$', qq)    if not m2:
        print('请输入有效的QQ号.')    if m1 and m2:
        print('你输入的信息是有效的!')if __name__ == '__main__':
    main()

提示：上面在书写正则表达式时使用了“原始字符串”的写法（在字符串前面加上了r），所谓“原始字符串”就是字符串中的每个字符都是它原始的意义，说得更直接一点就是字符串中没有所谓的转义字符啦。因为正则表达式中有很多元字符和需要进行转义的地方，如果不使用原始字符串就需要将反斜杠写作\\，例如表示数字的\d得书写成\\d，这样不仅写起来不方便，阅读的时候也会很吃力。

例子2：从一段文字中提取出国内手机号码。

下面这张图是截止到2017年底，国内三家运营商推出的手机号段。

[图片上传失败...(image-eeff94-1533288203864)]

import redef main():
    # 创建正则表达式对象 使用了前瞻和回顾来保证手机号前后不应该出现数字
    pattern = re.compile(r'(?<=\D)1[34578]\d{9}(?=\D)')
    sentence = '''
    重要的事情说8130123456789遍，我的手机号是13512346789这个靓号，
    不是15600998765，也是110或119，王大锤的手机号才是15600998765。
    '''
    # 查找所有匹配并保存到一个列表中
    mylist = re.findall(pattern, sentence)
    print(mylist)
    print('--------华丽的分隔线--------')    # 通过迭代器取出匹配对象并获得匹配的内容
    for temp in pattern.finditer(sentence):
        print(temp.group())
    print('--------华丽的分隔线--------')    # 通过search函数指定搜索位置找出所有匹配
    m = pattern.search(sentence)    while m:
        print(m.group())
        m = pattern.search(sentence, m.end())if __name__ == '__main__':
    main()

说明：上面匹配国内手机号的正则表达式并不够好，因为像14开头的号码只有145或147，而上面的正则表达式并没有考虑这种情况，要匹配国内手机号，更好的正则表达式的写法是：(?<=\D)(1[38]\d{9}|14[57]\d{8}|15[0-35-9]\d{8}|17[678]\d{8})(?=\D)，国内最近好像有19和16开头的手机号了，但是这个暂时不在我们考虑之列。

例子3：替换字符串中的不良内容

import redef main():
    sentence = '你丫是傻叉吗? 我操你大爷的. Fuck you.'
    purified = re.sub('[操肏艹草曹]|fuck|shit|傻[比屄逼叉缺吊屌]|煞笔',                      '*', sentence, flags=re.IGNORECASE)
    print(purified)  # 你丫是*吗? 我*你大爷的. * you.if __name__ == '__main__':
    main()

说明：re模块的正则表达式相关函数中都有一个flags参数，它代表了正则表达式的匹配标记，可以通过该标记来指定匹配时是否忽略大小写、是否进行多行匹配、是否显示调试信息等。如果需要为flags参数指定多个值，可以使用按位或运算符进行叠加，如flags=re.I | re.M。

例子4：拆分长字符串

import redef main():
    poem = '窗前明月光，疑是地上霜。举头望明月，低头思故乡。'
    sentence_list = re.split(r'[，。, .]', poem)    while '' in sentence_list:
        sentence_list.remove('')
    print(sentence_list)  # ['窗前明月光', '疑是地上霜', '举头望明月', '低头思故乡']if __name__ == '__main__':
    main()

后话

如果要从事爬虫类应用的开发，那么正则表达式一定是一个非常好的助手，因为它可以帮助我们迅速的从网页代码中发现某种我们指定的模式并提取出我们需要的信息，当然对于初学者来收，要编写一个正确的适当的正则表达式可能并不是一件容易的事情（当然有些常用的正则表达式可以直接在网上找找），所以实际开发爬虫应用的时候，有很多人会选择Beautiful Soup或Lxml来进行匹配和信息的提取，前者简单方便但是性能较差，后者既好用性能也好，但是安装稍嫌麻烦，这些内容我们会在后期的爬虫专题中为大家介绍。

作者：GHope
链接：https://www.jianshu.com/p/d44e2b0537e0