Python学习---day35

正则表达式

正则表达式是一种可以让复杂的字符串问题变得简单的工具

应用

  • 实例1:判断指定的字符串是否是一个合法的手机号
    11位:每一位都是数字,第一位必须是1:
from re import fullmatch
tel = input('请输入手机号:')
def is_tel(num:str):
    if len(num) != 11:
        return False

    for x in num:
        if x.isdigit():
            return False
    if num[0] != '1':
        return False
    if '3' <= num[1] <= '9':
        return True

    return False
# print(is_tel(tel))

def is_tel2(num:str):
    return bool(fullmatch(r'1[3-9]\d{9}', num))
# print(is_tel2(tel))
  • 实例2:提取字符串中所有的数字字串
str1 = '月薪:23654元,年龄18岁,身高175,'
result = []
temp = ''
for x in str1:
    if x.isdigit():
        temp += x
    else:
        if temp:
            result.append(temp)
            temp = ''
if temp:
    result.append(temp)
print(result)

# 方法二
from re import findall
result = findall(r'\d+', str1)
print(result)

匹配类符号

1.什么是正则表达式

正则表达式是一种可以让复杂的字符串问题变得简单的工具
正则并不是python特有的语法(不属于python),所有的高级编程语言都支持正在,正在的语法通用
不管通过正则表达式解决的时候什么问题,写正则的时候都是在使用正则表达式描述字符串规则

2.python的re模块

re模块是python用来支持正则表达式的一个模块,模块中包含了所有和正则相关的函数
fullmatch(正则表达式,字符串):

  • 判断正则表达式和指定的字符串是否完全匹配(判断整个字符串是否符号正则表达式所描述的规则)
  • 如果匹配成功,返回匹配对象;如果失败返回None

3.正则语法

匹配类符号

1.普通符号

—在正则表达式中表示符号的本身

result = fullmatch(r'abc', 'abc')
print(result)
2.匹配任意一个字符
result = fullmatch(r'a.c', 'a.c')
print(result)

result = fullmatch(r'...abc', '*9abc')
print(result)
3.\d — 匹配任意一个数字字符
result = fullmatch(r'a\dc', 'a0c')
print(result)
4.\s — 匹配任意一个空白字符

空白字符 — 能产生空白效果的字符,例如:空格、换行、水平制表符

result = fullmatch(r'a\sc', 'a c')
print(result)

result = fullmatch(r'\d\d\s.ab', '12 kab')
print(result)
5. \D — 匹配任意一个非数字字符
result = fullmatch(r'a\Dc', 'a*c')
print(result)
6. \S — 匹配非空白字符
result = fullmatch(r'a\Sc', 'a8c')
print(result)
7.[字符集] — 匹配字符集中任意一个字符
  • [abc] - 匹配a或者b或者c
  • [abc\d] - 匹配a或者b或者c或者任意数字
  • [1-9] - 匹配1到9中的任意一个数字
  • [a-z] - 匹配任意一个小写字母
  • [A-Z] - 匹配任意一个大写字母
  • [a-zA-Z] - 匹配任意一个字母
  • [a-zA-Z\d_] - 匹配字母数字或者下划线
  • [\u4e00-\u9fa5] - 匹配任意一个中文字符
    注意:[]中减号放在两个字符之间表示谁到谁(确定的方式是根据字符编码值大小确定的); 如果减号不在两个字符之间,就表示一个普通的减号
result = fullmatch(r'a[MN12]b', 'aNb')
print(result)

result = fullmatch(r'a[MN\d]b', 'a4b')
print(result)
8.[^字符集] - 匹配不在字符集中的任意一个字符
result = fullmatch(r'a[^MN]b', 'a是b')
print(result)

result = fullmatch(r'a[^\u4e00-\u9fa5]b', 'a-b')
print(result)

匹配次数

1. * - 0次或多次(任意次数)

*注意:在谁的后面控制的就是谁的次数

  • a* - 0个或多个a
  • \d* - 0个或者多个\d
result = fullmatch(r'a*123', 'aaaaaaaa123')
print(result)

result = fullmatch(r'\d*abc', '123411232abc')
print(result)

result = fullmatch(r'[MN]*abc', 'MNMabc')
print(result)

2. + - 1次或者多次(至少一次)

result = fullmatch(r'a+123', 'aaaaa123')
print(result)

3. ? - 0次或1次

result = fullmatch(r'A?123', 'A123')
print(result)

4. {}

  • {M,N} - M到N次
  • {M,} - 至少M次
  • {,N} - 最多N次
  • {N} - N次
result = fullmatch(r'[a-z]{3,5}123', 'bambk123')
print(result)

练习:写一个正则,判断输入的内容是否是一个合法的QQ号(长度是5~12位的数字,第一位不能是0)

qq = '3452'
result = fullmatch(r'[1-9]\d{4,11}', qq)
if result:
    print(f'{qq} 合法')
else:
    print(f'{qq} 不合法')

练习:判断输入的内容是否是一个合法的标识符(由字母、数字下划线组成,数字不能开头)

str1 = 'abc'
result = fullmatch(r'[a-zA-Z_][\da-zA-Z_]*', str1)
print(result)

贪婪和非贪婪

match(正则表达式,字符串) — 判断字符串开头是否符合正则表达式描述的规则
result = match(r’\d{3}', ‘244as’)
print(result)

1.贪婪和非贪婪

当匹配次数不确定的时候(*,+,?,{M,N},{M, },{ ,N}),匹配模式分为贪婪和非贪婪两种,默认是贪婪的
贪婪和非贪婪

  • 在匹配成功的时候有多种匹配结果,贪婪取最多次数对应的匹配结果;非贪婪取次数最少对应的结果
  • 匹配次数不确定的地方有多种匹配方式都可以匹配成功,贪婪取最多次数
    贪婪模式,+,?,{M,N},{M, },{ ,N}
    非贪婪模式
    ?,+?,??,{M,N}?,{M, }?,{ ,N}?
result = match(r'a.+b', 'asfsdfsfb')
print(result)

2. amb、amb计算b、amb计算bxxb

示例
  • 贪婪模式
result = match(r'a.+b', 'amb计算bxxbmn')
print(result)           # <re.Match object; span=(0, 9), match='amb计算bxxb'>
  • 非贪婪模式
result = match(r'a.+?b', 'amb计算bxxbmn')
print(result)           # <re.Match object; span=(0, 3), match='amb'>

**注意:**如果匹配结果只有一种可能,那么贪婪和非贪婪的结果一样

result = match(r'a.+b', 'ambxx')
print(result)           #  <re.Match object; span=(0, 3), match='amb'>

result = match(r'a.+?b', 'ambxx')
print(result)           # <re.Match object; span=(0, 3), match='amb'>

分组和分类

findall(正则表达式, 字符串) - 获取字符串中所有满足正则表达式的子串

1.分组 — ()

  • 1)将正则表达式中的一部分作为一个整体进行相关操作
  • 2)重复 — 在正则表达式中通过\M来重复它前面的第M个分组的匹配结果
  • 3)捕获 — 只获取正则表达式中的一部分匹配到的结果(分为手动捕获和自动捕获)
result = fullmatch(r'(\d\d[A-Z]{2})+', '12MN13KO')
print(result)

result = fullmatch(r'(\d{2})[a-z]\1', '23m23')
print(result)

result = fullmatch(r'(\d{2})([a-z]{3})=\2\1', '23mkl=mkl23')
print(result)
  • \M只能重复在它之前出现的分组内容,不能重复在它之后出现的内容
  • result = fullmatch(r’(\d{2})\1\2=([a-z]{2})', ‘2323mk=mk’) —> 报错
message = '我今年18岁,月薪500000元,身高180,体重70公斤'
result = findall(r'(\d+)元', message)
print(result)

2.分支 — |

正则1|正则2|正则3|… — 匹配可以和多个正则匹配的字符串

result = fullmatch(r'\d{3}|[a-z]{2}', 'ml')
print(result)

result = fullmatch(r'a\d{3}b|a[a-z]{3}b', 'a467b')
print(result)

:如果想要正则表达式中的一部分实现多选一的效果,变化的部分用分组表示

result = fullmatch(r'a(\d{3}|[a-z]{3})b', 'asfsb')
print(result)

转义符号

1.转义符号

正则中的转移符号是在本身具有特殊功能或者特殊意义的符号前加’',让这个符号变成一个普通符号

result = fullmatch(r'\d+\.\d+', '23.879')
print(result)

2.[]里面的转义符号

单独存在有特殊意义的符号(+、*、?、.等),在[]中特殊意义会消失

result = fullmatch(r'\d+[*]\d+', '23*879')
print(result)
# 本身在中括号中有特殊功能的符号,如果要表示普通符号
result = fullmatch(r'a[m\-n]b', 'a-b')
print(result)

检测类符号

检测类符号实在匹配成功的情况下,检测检测类符号所在的位置是否符合相关要求

1.\b — 检测是否是单词边界

单词边界:可以将两个单词区分开的符号都是单词边界,比如:空白、标点符号、字符串开头和字符串结尾

result = fullmatch(r'abc\b 123', 'abc 123')
print(result)

message = '23mn45,89 司机34kn;231;89mll==90,232 901='
result = findall(r'\d+', message)
print(result)

result = findall(r'\d+\b', message)
print(result)

result = findall(r'\b\d+', message)
print(result)

result = findall(r'\b\d+\b', message)
print(result)

2.\B — 检测是否不是单词边界

message = '23mn45,89 司机34kn;231;89mll==90,232 901='
result = findall(r'\B\d+\B', message)
print(result)

3.^ — 检测是否是字符串开头

message = '23mn45,89 司机34kn;231;89mll==90,232 901='
result = findall(r'^d+', message)
print(result)
  • 提取字符串前5个字符
message = '23mn45,89 司机34kn;231;89mll==90,232 901='
result = findall(r'^.{5}', message)
print(result)

4.$ — 检测是否是字符串结尾

  • 提取字符串最后五个字符
message = '23mn45,89 司机34kn;231;89mll==90,232 901='
result = findall(r'.{5}$', message)
print(result)

re模块常用函数

1. 常用函数

1) fullmatch(正则表达式, 字符串)

完全匹配,判断整个字符串是否符合正则表达式描述的规则,匹配成功返回匹配对象,匹配失败返回空

result = fullmatch(r'\d{3}', '234')
print(result)
2) match(正则表达式, 字符串)

匹配字符串开头,判断字符串开头是否符合正则表达式描述的规则,匹配成功返回匹配对象,匹配失败返回空

result = match(r'\d{3}', '823介绍数据库')
print(result)
3) search(正则表达式, 字符串)

获取字符串中第一个能够和正则匹配的子串,能找到返回匹配对象,找不到返回空

result = search(r'\d{3}', 'ba203还是678说')
print(result)
4) findall(正则表达式, 字符串)

获取字符串中所有满足正则的子串,返回一个列表,列表中的元素是字符串。
注意:如果正则表达式中有分组,会针对分组做自动捕获(只获取分组匹配到的结果)

result = findall(r'\d{3}', 'ba203还是678说kk0222jksn就是23311')
print(result)
5) finditer(正则表达式, 字符串)

获取字符串中所有满足正则的子串,返回一个迭代器,迭代器中的元素是每个子串对应的匹配对象

result = finditer(r'\d{3}', 'ba203还是678说kk0222jksn就是23311')
print(result)
# print(next(result))
print(list(result))
6) split(正则表达式, 字符串)

将字符串中所有满足正则的子串作为切割点对字符串进行切割

# 将str1中的a和b作为切割点对字符串进行切割
result = split(r'a|b', str1)
print(result)       # ['123', 'MKn', '嗑生嗑死', 'KKss', '923', '===']
7)sub(正则表达式, 字符串1, 字符串2)

将字符串2中所有满足正则的子串都替换成字符串1

result = sub(r'\d+', '+', 'ba203还是678说kk0222jksn就是23311')
print(result)

message = '我草!你TM看不见吗?f u c k!'
result = sub(r'(?i)草|TM|f\s*u\s*c\s*k|sb|妈', '*', message)
print(result)

2.匹配对象

result = search(r'(\d{3})([A-Z]{2})', '-=2设计师234KM222哈哈宿舍239KH')
print(result)       # <re.Match object; span=(6, 11), match='234KM'>
1)直接获取整个正则表达式对应的匹配结果: 匹配对象.group()
print(result.group())       # '234KM'
2)手动捕获某个分组对应的匹配结果: 匹配对象.group(分组数)
print(result.group(1))      # '234'
print(result.group(2))      # 'KM'
3)获取匹配结果在原字符串中的位置: 匹配对象.span()
print(result.span())            # (6, 11)
print(result.span(2))           # (9, 11)

3.参数

1)匹配忽略大小写: (?i)
result = fullmatch(r'(?i)abc', 'AbC')
print(result)
2)单行匹配: (?s) (了解!)

多行匹配(默认):匹配的时候.不能和换行(\n)进行匹配
单行匹配:匹配的时候.可以和换行(\n)进行匹配

result = fullmatch(r'abc.123', 'abc\n123')
print(result)       # None

result = fullmatch(r'(?s)abc.123', 'abc\n123')
print(result)       # <re.Match object; span=(0, 7), match='abc\n123'>
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python中,异常处理是非常重要的一部分。当程序运行时如果出现错误,如果没有异常处理,程序就会崩溃。为了避免这种情况,Python提供了异常处理机制。 在Python中,异常处理语句使用 `try` 和 `except` 关键字来实现。`try` 语句块中包含可能会发生异常的代码,如果这段代码出现了异常,则会跳转到 `except` 语句块中执行异常处理代码。 下面是一个简单的例子: ```python try: num = int(input("请输入一个整数:")) print(10/num) except ZeroDivisionError: print("除数不能为0") except ValueError: print("输入的不是整数") ``` 在上面的代码中,我们尝试将用户输入的字符串转换为整数,并将其用作除数计算 10/num。如果用户输入的是 0,则会触发 ZeroDivisionError 异常。如果用户输入的不是整数,则会触发 ValueError 异常。如果发生异常,则会跳转到对应的 except 语句块中执行处理代码。 除了可以指定具体的异常类型,也可以使用 `except Exception` 来捕获所有异常。例如: ```python try: num = int(input("请输入一个整数:")) print(10/num) except Exception as e: print("发生异常:", e) ``` 在上面的代码中,如果发生任何异常,都会跳转到 `except` 语句块中执行处理代码,并将异常信息打印出来。 除了 `try` 和 `except`,还有 `finally` 关键字,它指定的代码块无论是否发生异常都会执行。例如: ```python try: num = int(input("请输入一个整数:")) print(10/num) except Exception as e: print("发生异常:", e) finally: print("程序执行完毕") ``` 在上面的代码中,无论是否发生异常,都会执行 `finally` 中的代码,即输出“程序执行完毕”。 总之,在Python中,异常处理是非常重要的一部分,它可以有效避免程序崩溃,提高程序的健壮性和可靠性。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值