正则表达式

于 2022-08-09 23:41:25 发布
阅读量175 收藏
点赞数 1
文章标签： 正则表达式 python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53957045/article/details/126257893
版权

正则表达式

认识正则表达：

""""""

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

# 示例：判断指定的字符串是否是一个合法的手机号
# 11位；每一位都是数字；第一位必须是1；第二位是：3~9
tel = input('请输入手机号:')


def is_tel(num: str):
    if len(num) != 11:
        return False

    for x in num:
        if not 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):
    from re import fullmatch
    return bool(fullmatch(r'1[3-9]\d{9}', num))


print(is_tel2(tel))


# 示例2：提取字符串中所有的数字子串
str1 = '月薪: 25360元, 年龄18岁。身高：175，体重120斤。23'
# ['25360', '18', '175', '120']

# 方法一:
result = []
temp = ''
for x in str1:
    if x.isdigit():
        temp += x
    else:
        if temp:
            result.append(temp)
            temp = ''

if temp:  # 当循环到最后的时候temp= 23,但是此时循环结束，因此23就不会添加到列表中，所以对temp进行判断，如果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
"""
from re import fullmatch

# 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', 'a5c')
print(result)

# 4)\s  -   匹配任意一个空白字符
# 空白字符  -   能产生空白效果的字符，例如：空格、换行、水平制表符
result = fullmatch(r'a\sc', 'a\tc')
print(result)

result = fullmatch(r'\d\d\s.ab', '34 吗ab')
print(result)

# 5)\D  -   匹配任意一个非数字字符
result = fullmatch(r'a\Dc', 'a*c')
print(result)

# 6)\S  -   匹配任意一个非空白字符
result = fullmatch(r'a\Sc', 'a c')
print(result)       # None

result = fullmatch(r'a\Sc', 'a1c')
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)

""""""
from re import fullmatch

# 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)

""""""
from re import match

# match(正则表达式, 字符串)  - 判断字符串开头是否符合正则表达式描述的规则
result = match(r'\d{3}', '234宿舍wsww')
print(result)

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

贪婪和非贪婪：在匹配成功的时候有多种匹配结果，贪婪去最多次数对应的匹配结果, 非贪婪取最少次数对应的匹配结果
            (匹配次数不确定的地方，有多种匹配方式都可以匹配成功，贪婪取最多次数, 非贪婪取最少次数)
            
贪婪模式：*、+、?、{M,N}、{M,}、{,N}
非贪婪模式：*?、+?、??、{M,N}?、{M,}?、{,N}?
"""

# amb、amb计算b、amb计算bxxb
# 1)示例1：
# 贪婪模式
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'>

""""""
from re import fullmatch, findall

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

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

# 23m23、98k98、12p12  -  能匹配
# 23m34、98k08   -   不能匹配
result = fullmatch(r'(\d{2})[a-z]\1', '23m23')
print(result)

# 23mkj=mkj23
result = fullmatch(r'(\d{2})([a-z]{3})=\2\1{3}', '23mkl=mkl232323')
print(result)

# \M 只能重复在它出现之前的分组内容，无法重复在它之后出现的内容
# result = fullmatch(r'(\d{2})\1\2=([a-z]{2})', '2323mk=mk')            # 报错！
# print(result)

# 提取message中金额对应的数字子串
message = '我今年18岁，月薪50000元，身高180，体重70公斤，8块腹肌。每年交300元的腾讯会员费。房贷每月3000元，车贷每月2200元。'
result = findall(r'(\d+)元', message)
print(result)           # ['50000', '300', '3000', '2200']


# 2.分支  -  |
# 正则1|正则2|正则3|...       -      匹配可以和多个正则中任意一个正则匹配的字符串

# 匹配一个字符串是三个数字或者两个小写字母
result = fullmatch(r'\d{3}|[a-z]{2}', 'mk')
print(result)

# a234b、amjkb
result = fullmatch(r'a\d{3}b|a[a-z]{3}b', 'a232b')
print(result)

# 注意：如果想要正则表达式中的一部分实现多选一的效果，变化的部分用分组表示
result = fullmatch(r'a(\d{3}|[a-z]{3})b', 'amklb')
print(result)


result8 = findall(r'我([\u4e00-\u9fa5]|[\u4e00-\u9fa5]{2})你', '我爱你，胜过我讨厌你')
print(result8)

result8 = findall(r'我[\u4e00-\u9fa5]你|我[\u4e00-\u9fa5]{2}你', '我爱你，胜过我讨厌你')
print(result8)

"""
Author: 余婷
Time: 2022/8/9 15:28
Good Good Study, Day Day Up!
"""
from re import fullmatch

# 1. 转义符号
# 正则中的转义符号，就是在本身具备特殊功能或者特殊意义的符号前加'\'，让这个符号变成一个普通符号。

# 匹配任意一个小数对应的字符串
result = fullmatch(r'\d+\.\d+', '23.879')
print(result)

# +234、+889111
result = fullmatch(r'\+\d+', '+23')
print(result)

# (mv)、(ksma)
result = fullmatch(r'\([a-z]+\)', '(msnd)')
print(result)


# 2. []里面的转义符号
# 单独存在有特殊意义的符号(+、*、?、.等)，在[]中特殊意义会自动消失
result = fullmatch(r'\d+[.+*?]\d+', '23?879')
print(result)


# 本身在中括号中有特殊功能的符号，如果要表示普通符合必须加'\'
result = fullmatch(r'a[MN-]b', 'a-b')
print(result)

result = fullmatch(r'a[M\-N]b', 'a-b')
print(result)

result = fullmatch(r'a[MN^]b', 'a^b')
print(result)

result = fullmatch(r'a[\^MN]b', 'a^b')
print(result)

"""
Author: 余婷
Time: 2022/8/9 16:24
Good Good Study, Day Day Up!
"""
from re import *

# 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 = '123aMKnb嗑生嗑死aKKssa923b==='
# 将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'>

什么是正则表达式：是一种可以让一些复杂字符串问题变的简单的工具。正则不是python特有的（不属于python），几乎所有的高级语言都支持。

python的re模块：re模块是python用来支持正则表达的模块，模块中包含了所有和正则相关的函数

fullmatch(正则表达式，字符串) —— 判断正则表达式和指定的字符串是否完全匹配（判断字符串是否符合正则表达式所描述的规则）如果匹配成功返回匹配对象，匹配失败返回None

正则语法：匹配类符号

  • 普通符号 —— 在正则表达中表示符号本身的符号

    from re import fullmatch
result = fullmatch(r'abc','abd')
print(result)

  • ​ . —— 匹配任意一个字符

    from re import fullmatch
result = fullmatch(r'..asd','hhasd') # asd 前面任意匹配两个字符,一个 . 
print(result)						#代表匹配一个字符

  • \d —— 匹配任意一个数字字符

    from re import fullmatch
result = fullmatch(r'hh\dd','hh8d') 
print(result)

#<re.Match object; span=(0, 4), match='hh8d'>

  • \s 匹配任意一个空白字符 。如：空格，换行，水平制表符

from re import fullmatch
result = fullmatch(r'hh\sd','hh\td') # 匹配任意一个产生空白的字符
print(result)
  • \D —— 匹配任意一个非数字字符
from re import fullmatch
result = fullmatch(r'hh\Dd','hhkd') # 匹配任意一个产生空白的字符
print(result)
  • \S —— 匹配任意一个非空白字符（所有大写和小写对应的功能相反）
from re import fullmatch
result = fullmatch(r'hh\Sd','hh\td') # 匹配任意一个不产生空白的字符
print(result)

  • [字符集] —— 匹配字符集中任意一个字符集;[字符集\d] —— 匹配字符集中任意一个字符集或者数字；[1-9] —— 匹配1-9之间数字（前面一个数必须比后面一个数小）；[a-z] —— 匹配任意一个a-z 的字母；[a-zA-z] —— 匹配任意一个字母；[\u4e00 - \u 9fa5 ] —— 匹配任意一个中文字符

    注意：[] 中减号放在两个字符之间表示谁到谁，如果两个字符不在两个减号之间，就是普通减号

    from re import fullmatch
result = fullmatch(r'a[wangting]b','awb') # 匹配[wangting] 中的一个字符
print(result)


from re import fullmatch
result = fullmatch(r'a[1-9]b','a5b') # 匹配[1-9] 中的一个字符
print(result)

  • [^字符集] —— 匹配不在字符集中的任意一个字符

匹配次数

from re import fullmatch]

 * 0 次或者 多个（任意次数）。* 在谁的后面就是控制谁的次数

from re import fullmatch
result = fullmatch(r'a*123','aaa123') # 0 个a 或者多个a
print(result)



from re import fullmatch
result = fullmatch(r'\d*abc','2145413abc') # 0 个数字 或者多个数字
print(result)

# + 1 次或者 多次（至少一次）。+ 在谁的后面就是控制谁的次数
from re import fullmatch
result = fullmatch(r'\d+abc','2145413abc') # 1个数字 或者多个数字
print(result)

# ? 0 次或者 1次。？在谁的后面就是控制谁的次数
from re import fullmatch
result = fullmatch(r'\d?abc','3abc') #  0 次或者 1次数字
print(result)

贪婪和非贪婪

当匹配次数不确定的时候（* + ? {M,N}，{，M}，{M，}）匹配分为贪婪和非贪婪，默认是贪婪。

贪婪：在匹配成功的时候有多种情况，贪婪情况取最多次数对应的匹配结果（匹配次数不确定的地方，有多种匹配结果贪婪取次数最多）

非贪婪取最少次数

from re import match
#match(正则表达式，字符串） —— 判断字符串是否符合正则表达式描述的规则
# amb   ,  ambhhb   ,  ambhhbxxb(次数最多)
result = match(r'a.+b','ambhhbxxbmn')#贪婪模式，取最多次
print(result)

#<re.Match object; span=(0, 9), match='ambhhbxxb'>


from re import match
#非贪婪模式
#match(正则表达式，字符串） —— 判断字符串是否符合正则表达式描述的规则
# amb (次数最少)  ,  ambhhb   ,  ambhhbxxb(次数最多)
result = match(r'a.+?b','ambhhbxxbmn')#贪婪模式，取最多次
print(result)

#<re.Match object; span=(0, 3), match='amb'>

分组和分支

分组：—— （）。

1）：将正则表达式中的一部分作为一个整体进行相关操作

#12JH45LI69GD17WE
from re import  fullmatch
result = fullmatch(r'(\d\d[A-Z]{2})+','23HK89MB')
print(result)

2）重复 —— 可以在正则表达式中通过 \M 来重复他前面的第M个分组的匹配结果

from re import fullmatch
result = fullmatch(r'(\d{2})([a-z]{3})=\2\1{3}','23mkl=mkl232323')
print(result)

3）捕获：只获取正则表达式一部分匹配结果（手动捕获和自动捕获）

from  re import findall
message = "我今年18岁，月薪500000元，身高180，体重70kg，8快腹肌，每年交200元腾讯会员费，房贷每月5000元，车贷每月3000元"
result = findall(r'(\d+)元',message)
print(result)  #['500000', '200', '5000', '3000']

分支：

正则1|正则2|正则3…

from re import fullmatch

result1 = fullmatch(r'\d{3}|[a-z]{2}','mk')
print(result1)#<re.Match object; span=(0, 2), match='mk'>

# 如果正则表达式中的一部分实现多选一的效果，变化的部分用分组表示
result2 = fullmatch(r'a(\d{3}|[a-z]{3})b','amklb')
print(result2)#<re.Match object; span=(0, 5), match='amklb'>

转义字符：

正则中的转义字符，在本身具有特殊意义的符号前加" \ " ,让这个字符变成普通字符

#匹配任意一个小数
result3 = fullmatch(r'\d+\.\d+','23.5')
print(result3)


result = fullmatch(r'\d\+','5+')  # + 前面加了\  + 失去表示一次或者多次的功能，只是便是单独的+符号
print(result)

[] 里面的转义字符

1）单独存在有特殊意义的符号（+ * ? . ） 在[]括号中特殊意义会自动消失

result4 = fullmatch(r'a[M\-N]b','a-b')
print(result4)

检测类符号（了解）：检测类符号在检测成功的情况下，

\b ： 检测是否是单词边界 ：可以将两个单词分开的符号都是单词边界，比如：空格，标点符号，字符串开头或者字符串结尾

\B : 检测是否不是单词边界

^ ：检测是否是字符串开头

$ : 检测是否字符串结尾

re 模块的常用函数：

from re import *

# 1 :fullmatch(正则表达式，字符串) —— 完全匹配，判断整个字符串是否符合正则表达式的规则
#匹配失败返回空
result1 = fullmatch(r'\d{3}','123')
print(result1)

匹配对象：

顶峰相见_li
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
day-17正则表达式
qq_45658696的博客
08-09 248
day-17正则表达式
精通正则表达式：5 6 ...
Just for fun的专栏
12-10 390
第五章 正则表达式使用技巧 正则表达式的平衡法则： （1）只匹配期望的文本，排除不期望的文本。 （2）必须易于控制和理解 （3）如果使用NFA引擎，必须保证效率（如果能够匹配，必须很快地返回匹配结果，如果不能匹配，应该在尽可能短的时间内报告匹配失败）。 第六章 打造高效正则表达式 第七章 Perl 第八章 Java 第九章 .NET 第十章 PHP
正则表达式（身高、体重、视力、地址等）
chungoujiang1690的博客
07-13 2577
体重：var weightReg = /^(0(\.\d{1}){0,1}|[1-8]\d{1,3}(\.\d{1}){0,1}|9\d{1,2}(\.\d{1}){0,1}|999(\.0){0,1}|.{0})$/; 身高：var heightReg = /^(0{1}|[1-...
IP 正则表达式验证
12-12
您可能感兴趣的文章:javascript 手机号码正则表达式验证函数JS正则表达式验证数字代码JavaScript正则表达式验证身份证号码是否合法(两种方法)jquery正则表达式验证（手机号、身份证号、中文名称）邮箱地址正则...
正则表达式必知必会v_1.0.pdf
01-02
"正则表达式必知必会" 正则表达式是一种强大的文本处理工具，广泛应用于各个领域。下面是对正则表达式的详细解释： 正则表达式的用途 正则表达式主要用于处理文本，提供了两大主要功能：查找和替换。查找功能允许...
JavaScript正则表达式
01-08
1、正则表达式是描述字符模式的对象，正则表达式用于对字符串模式匹配及检索替换，是对字符串执行模式匹配的强大工具。 2、String和RegExp都定义了使用正则表达式进行强大的模式匹配和文本检索与替换的函数。 3、...
正则表达式匹配用户密码
12-13
正则表达式 ^[a-zA-Z]\w{5,17}$ 匹配 以字母开头，长度在6~18之间，只能包含字符、数字和下划线 不匹配 正则表达式 ^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?!.*\s).{4,8}$ 匹配 1agdA*$# | 1agdA*$# | 1agdA*$# 不...
正则表达式汇总-Labview
03-25
正则表达式汇总
excel 中如何取字符串中的倒数第二个数字并替换
07-05
excel 中如何取字符串中的倒数第二个数字并替换
iOS 正则表达式判断纯数字及匹配11位手机号码的方法
10-20
主要介绍了iOS 正则表达式判断纯数字及匹配11位手机号码的方法，判断手机号码是否正确的方法很多,我是用正则表达式来完成匹配的，具体方法，大家参考下本
使用正则表达式判断是否为手机号码(简单且实用)
10-21
主要介绍了使用正则表达式判断是否为手机号码(简单且实用)的相关知识，非常不错，具有参考借鉴价值，感兴趣的朋友一起看下吧
正则表达式验证11位数的手机号
weixin_56408993的博客
05-25 7291
getShortMessageCode() { let regs = /^(13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])\d{8}$/;// 11位手机 if (!regs.test(this.MessageloginForm.username)) { this.msgError("手机号码格式不正确，请重新输入"); } else { thi...
python 正则表达式
罗小辉的专栏
10-10 6664
先上图～ .*?结合是什么意思 分开来说： 1、. 匹配任意除换行符“\n”外的字符； 2、*表示匹配前一个字符0次或无限次； 3、+或后跟？表示非贪婪匹配，即尽可能少的匹配，如？重复任意次，但尽可能少重复； 4、 .*? 表示匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。 如：a.*?b匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab的话
SQL正则表达式
weixin_41730591的博客
02-27 151
LIKE：区分大小写的模糊匹配，如果没有%那就是准确匹配 REGEXP：不区分大小写的模糊匹配，用.来模糊匹配，如果没有那还是模糊匹配 BINARY：区分大小的，其他同REGEXP REGEXP用法 REGEXP ‘100|200’: |=OR REGEXP ‘[123] ton’： 多个OR，也可以简写为[1-3] REGEXP ‘\.’:特殊字符匹配 REGEXP ‘ins?’：最后一个字符可选 REGEXP ‘0{3}’：前面字符出现三次 REGEXP ‘^厨房’：：开头匹配 去空格.
Python正则匹配判断手机号是否合法
Beyond_F4的博客
11-09 1万+
import re # 需求 # 定义一个函数，用于判断输入的手机号是否合法 # 并判断它的运营商 # 思路步骤： # 1.首先了解三大运营商的号段分布 # 2.获取用户输入内容 # 3.判断输入是否是一个手机号 # 4.如果手机号合法，判断该手机号段的运营商 # 5.输出 def phone(): n = input("请输
signature=1a4f4cc2a4cb36682d90c0d4c84ca5da,dweb-mirror/yarn.lock at master · internetarchive/dweb-mi...
热门推荐
weixin_34615710的博客
05-29 10万+
# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.# yarn lockfile v1"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.8.3":version "7.8.3"resolved "https://registry.yarnpkg.com/@babel/co...
身高体重Java
weixin_66125815的博客
06-10 734
Java
正则表达式深入浅出：精通正则表达式的艺术
精通正则表达式第三版 正则表达式是计算机科学中的一种模式匹配语言，广泛应用于文本处理、数据提取、字符串匹配等领域。作为一名经验丰富的IT大师，我将从给定的文件中提炼出相关知识点，帮助读者更好地理解和掌握...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值