python正则表达式 - 30 正则表达式的基本用法

正则表达式的基础知识

什么是正则表达式 : 它是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

处理正则表达式相关的模块: import re

1.正则表达式相关符号的用法

(1) . : 任意字符

用法: 匹配一个第一个字符是a,第二个字符是任意字符，第三个字符是b的这样一个字符串

restr = r'a.b'
strstr = 'a-bab----===='
result = match(restr, strstr)
print(result)
>>> <_sre.SRE_Match object; span=(0, 3), match='a-b'>

(2) \w :字母、数字、下划线、中文

用法: 匹配第一个字符是l,第二个字符是字母、数字或者下划线，第三个字符是t的一个字符串

restr = r'l\wt'
strstr = 'l你tllll'
result = match(restr, strstr)
print(result)
>>> <_sre.SRE_Match object; span=(0, 3), match='l你t'>

(3) \s :空格、回车、制表符等(产生空白的字符)

用法: 匹配第一个字符是l,第二个字符是空白，第三个字符是t的一个字符串

restr = r'l\st'
#strstr = 'l_tllll'   >>> None
strstr = 'l tllll' 
result = match(restr, strstr)
print(result)
>>> <_sre.SRE_Match object; span=(0, 3), match='l t'>

(4) \d :匹配数字字符

用法: 匹配第一个字符是l,第二个字符是数字，第三个字符是t的一个字符串

restr = r'l\dt'
strstr = 'l0tssddd'
result = match(restr, strstr)
print(result)
>>> <_sre.SRE_Match object; span=(0, 3), match='l0t'>

(5) \b :匹配单词的边界（空格、逗号，句号，问号,冒号等…）

用法: 匹配一个第一个字符是数字，第二个字符是a,并且a后边是单词的边界的一个字符串

restr = r'\b\da\b'
strstr = '8a:pjuukk'
result = match(restr, strstr)
print(result)
>>> <_sre.SRE_Match object; span=(0, 2), match='8a'>

restr = r'aaa\s\b\da\b,p'
strstr = 'aaa 8a,pooooo'
result = match(restr, strstr)
print(result)
>>> <_sre.SRE_Match object; span=(0, 8), match='aaa 8a,p'>

(6) ^ :匹配字符串的开始

用法: 匹配一个以the开头的字符串

restr = r'^the'
strstr = 'thekoojppp'
result = match(restr, strstr)
print(result)
>>> <_sre.SRE_Match object; span=(0, 3), match='the'>

(7) $ :匹配字符串的结束

用法: 可以匹配or结尾的字符串

restr = r'^the\d\wor$'
strstr = 'the8_or'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 7), match='the8_or'>

(8) \W :匹配非字母、数字、下划线、中文字符

restr = r'a\Wp'
strstr = 'a~p0ppiuuuuu'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 3), match='a~p'>

(9) \S :匹配非空白字符

restr = r'a\Sb'
strstr = 'a7b000pppp'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 3), match='a7b'>

(10) \D :匹配非数字字符

restr = r'\d\D'
strstr = '8Lppppp'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 2), match='8L'>

(11) \B :非边界匹配

restr = r'a\Babc\B'
strstr = 'aabcppp'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 4), match='aabc'>

(12) [ ] :匹配字符集中的任意一个字符

用法: 匹配一个第一个字符a,第二个字符是b,c,d,t中的任意一个，第三个字符是数字

restr = r'a[bcdt]\d'
strstr = 'ac9llllll'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 3), match='ac9'>

(13) [^] :匹配不在字符集中的任意一个字符

restr = r'a[^bcdt]\w'
strstr = 'a,问llll'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 3), match='a,问'>

(14) * : X* 匹配X重复0次或者多次

用法: 匹配字符串开始是0个或者多个a字符，紧跟着bc这样的字符串

restr = r'a*bc'
strstr = 'aaabc'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 5), match='aaabc'>

restr = r'a\d*'
strstr = 'a900pppp'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 4), match='a900'>

(15) + : X+ 匹配X重复1次或者多次

restr = r'a+bc'
strstr = 'aaabc,,,,'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 5), match='aaabc'>

(16) ? : X? 匹配X重复0次或者1次

restr = r'a?bc'
strstr = 'abc'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 3), match='abc'>

(17) X{N} : 匹配X重复N次 X{N,}：匹配X重复至少N次 X{M,N} : 匹配X重复M到N次

restr = r'\d{5,6}'
strstr = '8928990ppp'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 6), match='892899'>

(18) | :分支, 或者

用法: 可以匹配abc或者bpp

restr = r'abc|bpp'
strstr = 'bppkkkkk'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 3), match='bpp'>

restr = r'\d{5}\w|\w{5}[ymn]|R*\d.'
strstr = '98764woooooo'
strstr = 'ah67_yppppppp'
strstr = 'RRRR9mppppp'
print(match(restr, strstr))
>>> <_sre.SRE_Match object; span=(0, 6), match='RRRR9m'>

2. 正则表达式相关函数的用法

(1) compile()

编译正则表达式，返回一个正则表达式对象(没有检测正则表达式是否正确的功能)

restr = r'b[1-9]{6}\w'
reobject = re.compile(restr)
print(reobject)
>>> re.compile('b[1-9]{6}\\w')

print(re.match(reobject, 'b889765wppppp'))
>>> <_sre.SRE_Match object; span=(0, 8), match='b889765w'>

(2) match()

通过指定的正则表达式去匹配指定的字符串，失败会返回None.成功返回匹配对象

restr1 = r'aa\d*'
print(re.match(restr1, 'aa67pppp'))
>>> <_sre.SRE_Match object; span=(0, 4), match='aa67'>

(3) search()

搜索字符串中第一次出现正则表达式的模式。找到就返回匹配对象，没找到返回None

restr2 = r'a\db{2}'
print(re.search(restr2, "bndha1bbdhjsjsa9bbppp"))
>>> <_sre.SRE_Match object; span=(4, 8), match='a1bb'>

(4) split()

maxsplit：控制拆分次数，如果是0，就是全部拆分
在字符串中以正则表达式匹配到的字符串为拆分点，对字符串进行拆分

restr3 = r'\d'
str_list = re.split(restr3, 'uuu h7hh jj k9k ll ii')
print(str_list)
>>> ['uuu h', 'hh jj k', 'k ll ii']

(5) sub()

用指定的字符串替换原字符串中与正则表达式匹配的模式可以用count指定替换的次数

restr4 = r'[操肏艹草曹]|fuck|shit|煞笔|sb|SB|傻叉|Fuck|FUCK'
strstr = '你丫是傻叉吗? 我操你大爷的. Fuck you.'
new_str = re.sub(restr4, '*', strstr)
print(new_str)
>>> 你丫是*吗? 我*你大爷的. * you.

(6) findall()

查找字符串所有与正则表达式匹配的模式返回字符串的列表

from re import findall

def sum_num_seq(string):
    total = 0
    for val in map(int, findall(r'\d+', string)):
        total += val
    return total

print(sum_num_seq('1h3ad4as5h6n'))
print(sum_num_seq('8123917289'))

>>>19
>>>8123917289

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

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

from re import match

def main():

    username = input('用户名:')
    qq = input('QQ:')

    restr = r'[a-zA-Z_][a-zA-Z0-9_]{5,19}$'
    result = match(restr, username)
    if result == None:
        print('用户名输入有误')
    else:
        print(result)


    restr2 = r'[1-9][0-9]{4,11}$'
    result2 = match(restr2, qq)
    if result2 == None:
        print('QQ号输入有误')
    else:
        print(qq)

if __name__ == '__main__':
    main()

练习2 : 替换字符串中的不良内容

import re

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

if __name__ == '__main__':
    main()