# 正则表达式

最新推荐文章于 2023-09-27 11:52:08 发布
原创 最新推荐文章于 2023-09-27 11:52:08 发布 · 724 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python

本文详细介绍了Python中的正则表达式，包括匹配符号、检测类符号、匹配次数、分组和分支以及re模块的使用。讲解了fullmatch函数、正则语法、常用特殊符号如d、s、w等，还涵盖了匹配次数的控制和分组的概念。最后，文中给出了正则表达式的实际应用，包括不定项选择题和编程题，如用户名、密码和IP地址的匹配规则。

正则表达式

一、匹配符号

“”"

  1. re模块
    re模块是python提供的专门用支持正则表达式的一个模块
    fullmatch函数：
    fullmatch(正则表达式，字符串) – 让正则表达式和指定字符串进行完全匹配，如果匹配失败返回None；
    “”"

“”"
2. 正则语法
正则表达式 – 正则表达式是一个字符串复杂问题变得简单的工具。
写正则表达式的主要工作：用正则符号描述清楚相关字符串的规则。

python正则表示方式：r’正则表达式’
js的正则：/正则表达式/
“”"

from re import fullmatch

“”"

  1. 普通字符(普通符号)
    在正则除了有特殊功能或者特殊意义以外的符号；
    普通字符在正则中表示这个符号本身。
    “”"
# 匹配一个字符串有三个字符分别是a, b和c
re_str = r'abc'
print(fullmatch(re_str, 'abc'))

“”"
2) . – 匹配任意一个字符
注意：一个.只能匹配一个任意字符
“”"

# 匹配一个字符，长度是三，第一个字符是a，最后一个字符是c，a和c之间是任意一个字符
re_str = r'a.c'
print(fullmatch(re_str, 'abc'))
print(fullmatch(re_str, 'a+c'))
print(fullmatch(re_str, 'a好c'))

re_str = r'abc...'
print(fullmatch(re_str, 'abcm./'))
print(fullmatch(re_str, 'abcm\t/'))
print(fullmatch(re_str, 'abc G/'))

“”"
3) \d – 匹配任意一个数字字符
“”"

re_str = r'a\d\dc'
print(fullmatch(re_str, 'a78c'))
print(fullmatch(re_str, 'a00c'))

“”"
4) \s – 匹配任意一个空白字符
空白字符：空格、回车(\n)、制表符(\t)
“”"

re_str = r'a\sb'
print(fullmatch(re_str, 'a b'))
print(fullmatch(re_str, 'a\nb'))
print(fullmatch(re_str, 'a\tb'))
print(fullmatch(re_str, 'a  b'))    # None(不匹配)

“”"

    1. \w – 匹配任意一个字母、数字或者下划线 （不好用）
      “”"

“”"
6)
\D – 匹配任意一个非数字字符
\S – 匹配任意一个非空白字符
“”"

print(fullmatch(r'a\Sb\D', 'a>b='))
print(fullmatch(r'a\Sb\D', 'a b='))         # None
print(fullmatch(r'a\Sb\D', 'a>b0'))         # None

“”"
7) [字符集] – 匹配字符集中任意一个字符
注意：一个[]只能匹配一个字符
[多个普通字符] – 例如[abc], 可以匹配a或者b或者c
[包含\开头的特殊符号字符集] – 例如：[\dabc], 可以匹配任意数字或者a或者b或者c

[包含减号在两个字符之间的字符集] – 这个时候的减号表示谁到谁(注意：减号前面的字符的编码必须小于减号后面的)
例如：
[a-z] – 匹配任意一个小写字母
[a-d] – 匹配a、b、c、d中的任意一个字符
[A-Z] - 匹配任意一个大写字母
[1-9] – 匹配1到9中任意一个数字字符
[\u4e00-\u9fa5] – 匹配任意一个中文字符
[a-zA-Z]、[A-Za-z] – 匹配任意一个字母
[a-z123] – 匹配任意一个小写字母，或者1或者2或者3
[a-z\d] – 匹配任意一个小写字母或者任意一个数字
“”"

re_str = r'a[xym]b'
print(fullmatch(re_str, 'axb'))
print(fullmatch(re_str, 'ayb'))
print(fullmatch(re_str, 'amb'))
print(fullmatch(re_str, 'azb'))     # None

re_str = r'a[16]b'
print(fullmatch(re_str, 'a1b'))
print(fullmatch(re_str, 'a6b'))

re_str = r'a[a\db]b'
print(fullmatch(re_str, 'a1b'))
print(fullmatch(re_str, 'aab'))
print(fullmatch(re_str, 'abb'))

print(fullmatch(r'x[a-z]y', 'xmy'))

print(fullmatch(r'x[a-zA-Z]y', 'xmy'))
print(fullmatch(r'x[a-zA-Z]y', 'xKy'))

print(fullmatch(r'x[a-zA-Z*&]y', 'x*y'))
print(fullmatch(r'x[a-zA-Z*&]y', 'xMy'))

print(fullmatch(r'x[0-9]y', 'x5y'))

print(fullmatch(r'x[-09]y', 'x-y'))
print(fullmatch(r'x[-09]y', 'x0y'))
print(fullmatch(r'x[-09]y', 'x9y'))

“”"
8) [^字符集] – 匹配任意一个不在字符集的任意一个字符
[^abc] – 匹配除了a、b、c以外的任意一个字符
[^a-z] – 匹配除了小写字母以外的任意一个字符

注意：[]中的-和^只有放在指定位置的时候才有特色功能，否则在[]中就是一个普通的字符。
“”"

print(fullmatch(r'a[^\u4e00-\u9fa5]c', 'a是c'))   # None
print(fullmatch(r'a[^a-zA-Z]c', 'aKc'))          # None
print(fullmatch(r'a[^a-zA-Z]c', 'a1c'))
print(fullmatch(r'a[a-z^]c', 'a^c'))

二、检测类符号

from re import fullmatch, findall

“”"
检查类符号的存在不影响被匹配的字符串长度，它的作用是在匹配成功的前提下检测符号所在的位置是否符号要求。
检测类符号的用法：先去掉检测类符号，看是否能匹配成功，如果失败整个正则匹配失败。如果成功再来看检测类符号所在的位置是否符号要求。

  1. \b – 检测是否是单词边界
    单词边界 – 能够区分出两个不同单词的符号都属于单词边界，例如：空白、标点符号、字符串开头、字符串结尾

“”"

re_str = r'abc\b123'
print(fullmatch(re_str, 'abc123'))      # None
print(fullmatch(re_str, 'abc 123'))     # None

re_str = r'abc,\b123'
print(fullmatch(re_str, 'abc,123'))

print(fullmatch(r'abc\s\b123', 'abc 123'))

# findall(正则表达式, 字符串)   -   获取字符串中所有满足正则表达式的子串
str1 = '12ksksj78ss 34抗生素,89 试7试看90 56 江苏省23'
result1 = findall(r'\d\d', str1)
print(result1)           # ['12', '78', '34', '89', '90', '56', '23']

result2 = findall(r'\d\d\b', str1)
print(result2)          # ['89', '90', '56', '23']

result3 = findall(r'\b\d\d\b', str1)
print(result3)          # ['89', '56']

“”"
2. \B – 检测是否是非单词边界
“”"

result3 = findall(r'\d\d\B', str1)
print(result3)

“”"
3. ^ – 检测是否是字符串开头
“”"

re_str = r'^\d\d'
print(fullmatch(re_str, '12'))      # <re.Match object; span=(0, 2), match='12'>
print(findall(r'^\d\d',  str1))     # ['12']

“”"
4. $ – 检测是否是字符串结尾
“”"

re_str = r'\d\d$'
print(fullmatch(re_str, '67'))      # <re.Match object; span=(0, 2), match='67'>

三、匹配次数

from re import fullmatch, match, findall
import requests

“”"

    • – 匹配0次或者多次（任意次数）
      匹配类符号用法：
      a       – 匹配任意多个a
      \d* – 匹配任意多个数字字符
      “”"
print(fullmatch(r'a*b', 'b'))
print(fullmatch(r'a*b', 'aab'))
print(fullmatch(r'a*b', 'aaaaaaab'))
print(fullmatch(r'\d*b', '245899b'))
print(fullmatch(r'[abc]*x', 'aabccax'))

“”"
2. + – 匹配1次或多次（至少一次）
“”"

print(fullmatch(r'a+b', 'b'))           # None
print(fullmatch(r'a+b', 'ab'))
print(fullmatch(r'a+b', 'aaaaab'))

“”"
3. ? – 匹配0次或1次
“”"

re_str = r'[-+]?[1-9]\d'
print(fullmatch(re_str, '-12'))
print(fullmatch(r'a?b', 'b'))
print(fullmatch(r'a?b', 'ab'))
print(fullmatch(r'a?b', 'aab'))     # None

“”"
4. {}
{N} – 匹配N次
{M,N} – 匹配M到N次
{,N} – 匹配最多N次
{M,} – 匹配至少M次
“”"

print(fullmatch(r'\d{3}', '786'))

print(fullmatch(r'\d{3,5}', '899'))
print(fullmatch(r'\d{3,5}', '8092'))
print(fullmatch(r'\d{3,5}', '89129'))
print(fullmatch(r'\d{3,5}', '8578990'))     # None

print(fullmatch(r'\d{,5}', '802'))
print(fullmatch(r'\d{,5}', '0921'))
print(fullmatch(r'\d{,5}', '081898'))       # None

print(fullmatch(r'\d{3,}', '0976'))
print(fullmatch(r'\d{3,}', '31221'))
print(fullmatch(r'\d{3,}', '82'))           # None

# 注意：匹配次数对应的符号的前面必须是匹配类符号

“”"
5. 贪婪和非贪婪
在匹配次数不确定的时候，匹配模式分为贪婪和非贪婪两种，默认是贪婪模式
在匹配成功的前提下，贪婪是匹配次数选最多的那个次数；非贪婪是匹配次数最少的那个次数。

*、+、?、{M,N}、{M,}、{,N} – 贪婪的
*?、+?、??、{M,N}?、{M,}?、{,N}? – 非贪婪的
“”"

print(match(r'\d{3}', '234hj监管机构'))
print(match(r'a.*b', 'asmmdb监管机构'))     # asmmdb
print(match(r'a.*?b', 'asmmdb监管机构'))    # asmmdb

# 'asb'、'asbmmb'、'asbmmbdb' 有三种情况可以成功，因为贪婪所以最后匹配次数最多的情况
print(match(r'a.*b', 'asbmmbdb监管机构'))       # asbmmbdb
print(match(r'a.*?b', 'asbmmbdb监管机构'))      # asb

四、分组和分支

from re import fullmatch

“”"

  1. () – 分组
    作用1：将()中的内容作为一个整体，进行整体相关操作，例如：整体控制次数
    作用2：通过’\M’ 重复前面第M个分组匹配到的结果，M从1开始
    作用3：捕获(在findall中讲)
    “”"
str1 = '79gt34er23sd'
print(fullmatch(r'\d\d[a-z]{2}\d\d[a-z]{2}\d\d[a-z]{2}', str1))
print(fullmatch(r'(\d\d[a-z]{2}){3}', str1))

str1 = r'abababab'
print(fullmatch(r'(ab)+', str1))


print(fullmatch(r'(\d{2})abc\1', '89abc89'))
print(fullmatch(r'(\d{2})abc\1', '89abc34'))        # None

"""print(fullmatch(r'\d{2}abc\1', '89abc89'))"""   # re.error(错误)

print(fullmatch(r'(\d{3})([a-z]{3})-\2', '234ams-ams'))
print(fullmatch(r'(\d{3})([a-z]{3})-\1', '234ams-234'))
print(fullmatch(r'(\d{3})([a-z]{3})-\2\1', '234ams-ams234'))
print(fullmatch(r'(\d{3})([a-z]{3})-\1{2}', '234ams-234234'))

"""print(fullmatch(r'(\d{3})-\2([a-z]{3})', '234ams-ams'))"""     #  re.error(错误)

“”"
2. | – 分支
正则1|正则2 – 先用正则1进行匹配，如果成功就匹配成功，如果匹配失败再使用正则2进行匹配
“”"

# 要求能同时匹配'abc98'和'abcMKP'
print(fullmatch(r'abc\d{2}|abc[A-Z]{3}', 'abcKMP'))
print(fullmatch(r'abc(\d{2}|[A-Z]{3})', 'abcMKP'))

“”"
3. 转义符号
在特殊符号前加\，让符号的功能消失，变成一个普通符号
“”"

print(fullmatch(r'\+\d{3}', '+234'))
print(fullmatch(r'\[\d{3}\]', '[234]'))
print(fullmatch(r'\\dabc', '\dabc'))

# 如果是独立存在有特殊功能的符号，将符号放入[]中其功能也会自动消失
print(fullmatch(r'[+*?|()^$.]abc', '$abc'))
print(fullmatch(r'[\^abc\-z\]]123', ']123'))

五、re模块

import re

“”"

  1. compile(正则表达式) – 编译正则表达式，返回一个正则表达式对象

fullmatch(正则表达式, 字符串)
正则表达式对象.fullmatch(字符串)
“”"

re_obj = re.compile(r'\d{3}')
print(re_obj.fullmatch('234'))

print(re.fullmatch(r'\d{3}', '234'))

“”"
2.
fullmatch(正则表达式, 字符串) – 让正则表达式或整个字符串进行匹配（完全匹配），匹配失败返回None，匹配成功返回匹配对象。
match(正则表达式, 字符串) – 匹配字符串开头（判断字符串的开头是否符号正则的规则），匹配失败返回None，匹配成功返回匹配对象。
“”"

result = re.fullmatch(r'\d{3}', '345')
print(result)       # <re.Match object; span=(0, 3), match='345'>   --   匹配对象

“”"

  1. 获取匹配到的字符串
    匹配对象.group() / 匹配对象.group(0) – 获取整个正则匹配到的结果
    匹配对象.group(N) - 获取第N个分组匹配到的结果
    “”"

“”"
2) 获取匹配结果在原字符串中的位置信息
匹配对象.span() - 返回的是一个元组，元组中的元素是开始下标和结束下标，结束下标对应的位置取不到
匹配对象.span(N)
“”"

print(result.span())

“”"
3. search(正则表达式，字符串) – 获取第一个满足正则表达式的字串。返回结果是None或者匹配对象
“”"

result = re.search(r'\d{3}', 'djrbj324ok,378')
print(result)       # <re.Match object; span=(5, 8), match='324'>
print(result.group())       # 324

“”"
2) 获取匹配结果在原字符串中的位置信息
匹配对象.span() – 返回的是一个元组，元组中的元素是开始下标和结束下标，结束下标对应的位置取不到
匹配对象.span(N)
“”"

“”"
4. findall(正则表达式，字符串) – 获取字符串中所有满足正则的子串，返回的是列表，列表中的元素是子串（没有分组的时候）
如果正则中只有一个分组：返回的列表中的元素是每个分组匹配到的结果
如果正则中有两个或者两个以上的分组:返回的列表中的元素是元组，元组中的元素是每个分组匹配到的结果
“”"

result = re.findall(r'\d{2}', '34ssd908计算机上23，udh89,试试89123')
print(result)   # ['34', '90', '23', '89', '89', '12']

result = re.findall(r'(\d{2})\D', '34ssd908计算机上23，udh89,试试89123')
print(result)   # ['34', '08', '23', '89']

result = re.findall(r'((\d[a-z]){2})', '2m4m司机师傅9k0o试试3k5l--')
print(result)       # [('2m4m', '4m'), ('9k0o', '0o'), ('3k5l', '5l')]

result = re.findall(r'(\d{2})-([a-z]{3})', '23-msn数据是98-kop圣诞节发货')
print(result)       # [('23', 'msn'), ('98', 'kop')]

“”"
5. finditer(正则表达式，字符串) – 获取字符串中所有满足正则的子串，返回的是一个迭代器，迭代器是匹配对象
“”"

result = re.finditer(r'(\d{2})-([a-z]{3})', '23-msn数据是98-kop圣诞节发货')
print(result)
r1 = next(result)
print(r1, r1.group(), r1.group(1), r1.group(2))

“”"
6. split(正则表达式，字符串) – 将字符串所有满足正则表达式的子串作为切割点，对字符串进行切割
re.split(正则表达式，字符串，N) – 将字符串中前N个满足正则表达式的子串作为切割点，对字符串进行切割
“”"

result = re.split(r'\d+', '是是9564s双生视界09世纪东方和3d失敬失敬2试试')
print(result)

“”"
7. sub(正则表达式，字符串1，字符串2) – 将字符串2中所有满足正则表达式的子串替换成字符串1
sub(正则表达式，字符串1，字符串2，N) – 将字符串2中前N个满足正则表达式的子串替换成字符串1
“”"

result = re.sub(r'\d+', '*', '是是9564s双生视界09世纪东方和3d失敬失敬2试试')
print(result)

message = 'f u c    k you! 打团了，你TM的没看见吗？SB'
re_str = open('badLanguage.txt', encoding='utf-8').read()
re_str = r'(?i)%s' % re_str
result = re.sub(re_str, '*', message)
print(result)

“”"
8. flags参数
上面的每一个函数都有一个参数flags，用来设置正则参数
1) 单行匹配和多行匹配参数：re.S、re.M(默认的)
单行匹配：.可以匹配\n
多行匹配：.不能和\n匹配

flags=re.S <==> r’(?s)正则表达式’

2) 忽略大小写：re.I
flags = re.I  <==>  r'(?i)正则表达式'

flags=re.S|re.I  <==>  r'(?si)正则表达式'

“”"

print(re.fullmatch(r'a.b', 'a\nb', flags=re.M))     # None
print(re.fullmatch(r'a.b', 'a\nb'))                 # None
print(re.fullmatch(r'a.b', 'a\nb', flags=re.S))
print(re.fullmatch(r'(?s)a.b', 'a\nb'))

print('---------------------------------------------------')
print(re.fullmatch(r'abc', 'abc'))
print(re.fullmatch(r'abc', 'Abc'))      # None
print(re.fullmatch(r'abc', 'ABc', flags=re.I))
print(re.fullmatch(r'(?i)abc', 'ABc'))

print(re.fullmatch(r'a.b', 'A\nb', flags=re.S|re.I))
print(re.fullmatch(r'(?is)a.b', 'A\nb'))

作业

利用正则表达式完成下面的操作:

一、不定项选择题
  1. 能够完全匹配字符串"(010)-62661617"和字符串"01062661617"的正则表达式包括（A 、B、D）

A.r"\(?\d{3}\)?-?\d{8}"
B. r"[0-9()-]+"
C.r"[0-9(-)]*\d*"
D.r"[(]?\d*[)-]*\d*"

  1. 能够完全匹配字符串“back”和“back-end”的正则表达式包括（ A、B、C 、D）
    A. r“\w{4}-\w{3}|\w{4}”
    B. r“\w{4}|\w{4}-\w{3}”
    C.r “\S±\S+|\S+”
    D. r“\w*\b-\b\w*|\w*”

  2. 能够完全匹配字符串“go go”和“kitty kitty”，但不能完全匹配“go kitty”的正则表达式包括（A,D）
    A.r “\b(\w+)\b\s+\1\b”
    B. r“\w{2,5}\s*\1”
    C. r“(\S+) \s+\1”
    D. r“(\S{2,5})\s{1,}\1”

  3. 能够在字符串中匹配“aab”，而不能匹配“aaab”和“aaaab”的正则表达式包括（B,C ）
    A. r“a*?b”
    B. r“a{,2}b”
    C. r“aa??b”
    D. r“aaa??b”

二、编程题

1.用户名匹配

​ 要求: 1.用户名只能包含数字 字母 下划线

​ 2.不能以数字开头

​ 3.⻓度在 6 到 16 位范围内

from re import fullmatch

username = 'ss3568ahh'
result = re.fullmatch(r'[a-zA-Z_][A-Za-z\d]{5,15}', username)
if result:
    print(f'用户名:{username} 合法')
else:
    print(f'用户名:{username} 不合法')
  1. 密码匹配

​ 要求: 1.不能包含!@#¥%^&*这些特殊符号

​ 2.必须以字母开头

​ 3.⻓度在 6 到 12 位范围内

from re import fullmatch

pw = 'dka4i53'
result = fullmatch(r'[a-zA-Z][^!@#¥%^&*]{5,11}', pw)
if result:
    print(f'密码 {pw} 合法')
else:
    print(f'密码 {pw} 不合法')
  1. ipv4 格式的 ip 地址匹配
    提示: IP地址的范围是 0.0.0.0 - 255.255.255.255
"""
0 - 255 (0-9; 10-99; 100-199; 200-249; 250-255)
0-9: \d
10-99:[1-9]\d
100-199: 1\d[2]
200-249: 2[0-4]\d
250-255: 25[0-5]

0-255的正则：(\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])
ip: ((\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])
"""

ip = '255.5.255.255'
result = fullmatch(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])', ip)
if result:
    print(f'{ip} 合法')
else:
    print(f'{ip} 不合法')
  1. 提取用户输入数据中的数值 (数值包括正负数 还包括整数和小数在内) 并求和
例如:“-3.14good87nice19bye” =====> -3.14 + 87 + 19 = 102.86

import re

str1 = '-3.14good87nice19bye'
result = re.findall(r'-?\d+\.?\d*', str1)

print(sum([float(x) for x in result]))  # 102.86

  1. 验证输入内容只能是汉字

    str1 = '温柔他的回归'
result = fullmatch(r'[\u4e00-\u9fa5]+', str1)
print(result)

  2. 匹配整数或者小数（包括正数和负数）

    """
整数：[-+]?([1-9]\d*|0)
-0、2、9、+19、342、34523、-0、+0（合法）
00、09、00087、--9、++23、-+23、 （不合法）

小数：[-+]?(0|[1-9]\d*)\.\d+
0.23、23.98、2.00、0.00 （合法）
003.9、0.、34.   （不合法）

整数或者小数：[-+]?([1-9]\d*|0)(\.\d+)?
"""
str1 = input('请输入整数或者小数：')
 result = fullmatch(r'[-+]?([1-9]\d*|0)(\.\d+)?', str1)
 print(result)

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

    要求：
    用户名必须由字母、数字或下划线构成且长度在6~20个字符之间

     user_name = input('请输入用户名：')
 user_QQ = input('请输入用户的QQ号：')
 if not re.fullmatch(r'(?i)[a-z_]{6,20}', user_name):
     print('输入的用户名不合法')
 else:
     print('用户名合法')
 if not re.fullmatch(r'[1-9][\d]{4,11}', user_QQ):
     print('输入的QQ号不合法')
 else:
     print('QQ号合法')

  4. 拆分长字符串：将一首诗的中的每一句话分别取出来

    ​ poem = ‘窗前明月光，疑是地上霜。举头望明月，低头思故乡。’

    poem = '窗前明月光，疑是地上霜。举头望明月，低头思故乡。'
 result = re.split(r'[，。]\b', poem)
 print(result)
正则表达式-正则表达式
10-10
正则表达式是一种特殊的字符序列，用于匹配一组字符串，根据特定的规则来设定字符组合的模式。正则表达式广泛应用于编程语言和文本处理工具中，用于查找、替换、删除或提取特定的字符或字符串组合。在文本编辑器、...
精选资源
强大的离线正则表达式生成工具
最新发布
03-10
正则表达式（Regular Expression，简称regex）是用于匹配字符串的一种模式，广泛应用于文本处理、数据验证、搜索和替换等场景。它通过一系列特定的字符和语法构建出一个规则，来匹配符合该规则的字符串。在IT行业中...
C# 正则表达式
weixin_34221276的博客
05-20 133
　　最近写爬虫时需要用到正则表达式，有段时间没有使用正则表达式现在渐渐感觉有些淡忘，现在使用还需要去查询一些资料。为了避免以后这样的情况，在此记录下正则表达式的一些基本使用方法附带小的实例。让以后在使用时能一目了然知道他的使用，为开发节约时间，同时也分享给大家。 正则元字符 　　在说正则表达式之前我们先来看看通配符，我想通配符大家都用过。通配符主要有星号(*)和问号(?)，用来模糊搜索文件。w...
正则表达式 表示 非指定字符串开头的正则
10-28
非指定字符串开头的正则，很多情况下需要用的到，需要的朋友可以参考下。
正则表达式
阿燃i
03-24 1039
findall:返回所有满足匹配条件的结果，放在列表中 search:找整个字符串，返回匹配上的第一个值，遇不到就None 如果有返回值调用group()就可以取到值，没有就报错 match:从头开始匹配，匹配上了返回，否则返回None，调用group取值 ret = re.split('[ab]', 'abcd') # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割 ...
# 正则表达式详解
超级无敌棒棒糖
09-27 468
真的很详细，还可以练习，我觉得你需要
精选资源
《正则表达式详解》.pdf
10-11
正则表达式是用于匹配和替换文本的一组具有特定含义的字符串，也叫做匹配模式或Pattern。正则表达式的概念起源于对人类神经系统工作原理的研究，后由Warren McCulloch和Walter Pitts两位科学家发展出数学描述神经...
精选资源
qt使用正则表达式限制lineEdit的输入，对正则表达式进行了封装，可以直接引入，工程编译正常
08-08
在Qt框架中，正则表达式（Regular Expression）是一种强大的文本处理工具，它允许程序员以结构化的方式匹配、查找、替换或验证字符串。本项目针对Qt的lineEdit组件，通过正则表达式实现了输入限制功能，使得lineEdit...
SQL 正则表达式及mybatis中使用正则表达式
12-13
mysql 提供的模式匹配的其他类型是使用扩展正则表达式。 当你对这类模式进行匹配测试时，使用REGEXP和NOT REGEXP操作符(或RLIKE和NOT RLIKE，它们是同义词)。 扩展正则表达式的一些字符是： “.”匹配任何单个的...
#正则#
weixin_45037444的博客
03-22 393
以什么结尾 $ 以什么开头^ 出现一次或者多次+ 出现0次或者多次* 出现0次或者1次？ 匹配出现x个nn{x} 匹配至少x个nn{x,} 匹配至少出现x个n，最多y个nn{x,y} 在数字或者字母范围内[a-z] 数字范围\d,等价于[0-9] 匹配所有字符. 匹配任意单词/w ...
正则表达式大全
DatsJou的专栏
04-09 951
匹配中文字符的正则表达式： [/u4e00-/u9fa5] 匹配双字节字符(包括汉字在内)：[^/x00-/xff] 应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1） String.prototype.len=function(){return this.replace([^/x00-/xff]/g,"aa").length;} 匹配空行的正则表达式：/n[/s| ]*/r 匹配HTML标记的正则表达式：/.*|/ 匹配首尾空格的正则表达式：(^/s*)|(/s*$) 应
python之正则表达式
boo程序员的博客
08-17 481
#正则表达式是记录文本规则的代码 #是一个特殊的字符序列 #普通字符和元字符组成的。其实就是对元字符的学习 import re #python中特殊的库,包含正则表达式,元字符串等 reg_string = "hello6232pyeh@qwhg.@！hellohh" reg = "hello" result = re.findall(reg,reg_string) print(result) ''' 元字符 常用的元字符 .匹配换行符以外的任意字符 \w 匹配字母或数字或下划线或汉字 \s 匹配任意
正则
木木
08-13 887
 举几个例子 // 匹配16进制颜色值 // 要求匹配：#ffbbad #Fc01DF #FFF #ffE // 表示一个16进制字符，可以用字符组[0-9a-fA-F]。其中字符可以出现3或6次，需要是用量词和分支结构。使用分支结构时，需要注意顺序。 var regex = /#[0-9a-fA-F]{6}|[0-9a-f...
正则表达式测试工具：简化正则表达式编写与调试
正则表达式测试工具是程序员和文本处理专业人士在日常工作中不可或缺的一部分。正则表达式（Regular Expression，简称RegEx）是一种强大的文本处理工具，它允许用户通过特定的模式来搜索、匹配和操作字符串。这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值