正则表达式08-python贪婪和非贪婪

最新推荐文章于 2024-03-26 18:48:29 发布
原创 最新推荐文章于 2024-03-26 18:48:29 发布 · 231 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细解析了Python正则表达式中贪婪与非贪婪匹配的区别，通过实例展示了如何利用非贪婪操作符“？”来精确控制匹配长度，避免过度匹配的问题。

python贪婪和非贪婪

Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；

非贪婪则相反，总是尝试匹配尽可能少的字符。

在"*","?","+","{m,n}"后面加上？，使贪婪变成非贪婪。

>>> s="This is a number 234-235-22-423"
>>> r=re.match(".+(\d+-\d+-\d+-\d+)",s)
>>> r.group(1)
'4-235-22-423'
>>> r=re.match(".+?(\d+-\d+-\d+-\d+)",s)
>>> r.group(1)
'234-235-22-423'
>>>

正则表达式模式中使用到通配字，那它在从左到右的顺序求值时，会尽量“抓取”满足匹配最长字符串，在我们上面的例子里面，“.+”会从字符串的启始处抓取满足模式的最长字符，其中包括我们想得到的第一个整型字段的中的大部分，“\d+”只需一位字符就可以匹配，所以它匹配了数字“4”，而“.+”则匹配了从字符串起始到这个第一位数字4之前的所有字符。

解决方式：非贪婪操作符“？”，这个操作符可以用在"*","+","?"的后面，要求正则匹配的越少越好。

>>> re.match(r"aa(\d+)","aa2343ddd").group(1)
'2343'
>>> re.match(r"aa(\d+?)","aa2343ddd").group(1)
'2'
>>> re.match(r"aa(\d+)ddd","aa2343ddd").group(1) 
'2343'
>>> re.match(r"aa(\d+?)ddd","aa2343ddd").group(1)
'2343'
>>>

字符串为:

<img data-original="https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973_201611131917_small.jpg" src="https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973_201611131917_small.jpg" style="display: inline;">

请提取url地址

参考答案

re.search(r"https://.*?\.jpg", test_str)
解析网页--正则表达式--python爬虫知识点4
weixin_43761516的博客
04-28 1204
正则表达式 爬虫要求不高，如果你写的表达式很复杂就说明该网站并不适合用正则来处理 掌握基础 一、正则表达式的简介 概念 正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑 特殊符号组合在一起的一个字符串，对你预知的一个字符串做一个验证，验证字符串的“机器、锁” 逻辑就是对事物观察分析后的结果 应用场景 爬虫 表达验证(例如 : 手机号、邮箱、身份证… ) 登入网站app的时候填入
python正则表达式01--贪心算法和非贪心算法findall()
m0_72345017的博客
12-01 208
print("无re.S：%s\n有re.S：%s"%(d,e))#有re.S：['i', 'love\n', 'you']#非贪心算法（点星问号）少食多餐 -- .*?#非贪心算法（点星问号）少食多餐 -- .*?#贪心算法（点星）尽可能多的匹配 -- .*#无re.S：['i', 'sadawe']#问号匹配前面的一个字符0次或者1次。#星匹配前面的一个字符一次或多次。#点匹配除换行符外的任意字符。# re.S 匹配换行符。#尽可能长的匹配字符串。
python正则表达式：贪婪与非贪婪
05-10 3938
python里的数量词默认是贪婪的，总是尝试尽可能的匹配更多的字符。python中使用?号关闭贪婪模式 如 import re print(re.match(r"aa\d+","aa2323")) #会尽可能多的去匹配\d # <re.Match object; span=(0, 6), match='aa2323'> print(re.match(r"aa\d+?","aa2323")) #尽可能少的去匹配\d # <re.Match object; sp
正则表达式和re模块
。
09-19 968
目录 正则表达式 字符组 ​​​​​​ 元字符 量词 . ^ $ * + ? { } 字符集［］［^］ 分组 ()与 或 ｜［^］ 转义符 \ 贪婪匹配 re模块  re模块下的常用方法 注意 1、findall的优先级查询 2、split的优先级查询 扩展 1、匹配标签 2、匹配整数 3、数字匹配 正则表达式 字符组 ​​​​​​ 在同一个位置可能出现...
Python-正则表达式-贪婪模式和非贪婪模式
qq522044637的博客
01-29 2028
Python中的数量词默认是贪婪模式，会尽可能地去匹配更多的字符。 非贪婪模式则相反，尽可能少地匹配字符。
【正则表达式学习09】python贪婪和非贪婪
飞上云端看彩虹
12-12 421
Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪则相反，总是尝试匹配尽可能少的字符。在"*","?","+","{m,n}"后面加上？，使贪婪变成非贪婪。 &gt;&gt;&gt; s="This is a number 234-235-22-423" &gt;&gt;&gt; r=re.match(&q
Python：正则表达式---贪婪匹配
豫州刺史
12-21 1346
John 使用了非贪婪匹配，它只匹配到第一个满足条件的 “John” 前面的最小字符串 “my name is John”。通过使用非贪婪匹配，我们可以控制正则表达式尽可能少地匹配字符，从而得到更精确的结果。.* 表示匹配任意数量的任意字符（除换行符外）。贪婪匹配会将尽可能多的字符都作为匹配结果返回。表示非贪婪的匹配任意数量的任意字符。非贪婪匹配会尽可能少地匹配字符以满足匹配规则。如果我们想要匹配 “my” 后面的最小字符串，即。的，它会尽可能多地匹配满足条件的字符。，我们可以使用非贪婪匹配的符号。
正则表达式---Python程序设计1
08-04
正则表达式还支持两种匹配模式：贪婪匹配和懒惰（非贪婪）匹配。默认情况下，正则表达式采用贪婪模式，即尽可能多地匹配文本。例如，若要匹配 `<a>` 和 `<b>` 之间的所有文本，可以使用以下正则表达式： ```python ...
精选资源
详解Python正则表达式库-Re
02-16
Python的正则表达式库`re`是处理字符串的强大工具，它允许我们通过特定的模式来搜索、替换或提取文本。正则表达式（Regular Expression）是一种特殊的字符串序列，用于匹配或处理具有特定模式的文本。 一、正则...
Python正则表达式---re模块
qq_52758588的博客
03-26 1522
该篇文章详细讲述了Python正则表达式的应用，从基础到进阶
python正则表达式中的贪婪与非贪婪模式
qq_40741808的博客
08-04 1167
概述 贪婪与非贪婪模式影响的是被量词修饰的子表达式的匹配行为，贪婪模式在整个表达式匹配成功的前提下，尽可能多的匹配，而非贪婪模式在整个表达式匹配成功的前提下，尽可能少的匹配。非贪婪模式只被部分NFA引擎所支持。 属于贪婪模式的量词，也叫做匹配优先量词，包括： “{m,n}”、“{m,}”、“?”、“*”和“+”。 在一些使用NFA引擎的语言中，在匹配优先量词后加上“?”，即变成属于非贪婪模式的量词，也叫做忽略优先量词，包括： “{m,n}?”、“{m,}?”、“??”、“*?”和“+?”。 从正则语法的角度
正则表达式-基础(python)-7python贪婪和非贪婪
pleboyzha的博客
10-25 178
python贪婪和非贪婪 Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符； 非贪婪则相反，总是尝试匹配尽可能少的字符。 在"*","?","+","{m,n}"后面加上？，使贪婪变成非贪婪。 >>> s="This is a number 234-235-22-423" >>> r=re.match(".+(\d+-\d+-\d+-\d+)",s) >>> r.group(1) '4-235-22-423'
python 的正则表达式 贪婪模式与懒惰模式
weixin_30411819的博客
03-17 253
正则表达式中用于表示匹配数量的元字符如下： ? 　　重复0次或1次，等同于{0,1} *　　重复0次或更多次，等同于{0,} +　　重复1次或更多次，等同于{1,} {n,} 重复n次及以上 上面的表示匹配次数的元字符分为贪婪型和懒惰型2种类型。其表达式分别如下。 贪婪型 懒惰型 *　　　　　*? +　　　　　+? {n,}　　 　{n,}? ...
Python：贪婪与非贪婪
weixin_44396481的博客
10-13 170
#在 * ? + {m,n} 后面加上?,使贪婪变成非贪婪 import re li=re.match('.*\d','a22222').group() #贪婪模式：在满足条件下，尽可能多匹配 print(li) print('------------------------------') li1=re.match('.*?\d','a22222').group() #非贪婪模式，在满足条件下，尽可能少匹配 print(li1) 运行结果 ...
python中贪婪与非贪婪
一只菜鸟的博客
02-14 621
Python里数量词默认是贪婪的（在少数语言里默认非贪婪），总是尝试匹配尽可能多的字符，非贪婪则相反，总是尝试尽可能少的字符。 在 “*”, “?”, “+”,"{m,n}" 后面加上？，便贪婪变成非贪婪。 贪婪： """ 1.导入模块 2.通过match方法，验证正则 3.判断、验证是否成功 4.如果成功，获取匹配的结果 """ # 1.导入模块 import re # 2.通过match方法，...
python3-贪婪与非贪婪
jeffrey_feng2018的博客
10-23 347
# 贪婪与非贪婪 import re a = 'python 111java678php' # 打印字符串a-z，长度是3-6,贪婪模式 r = re.findall('[a-z]{3,6}', a) # python的非贪婪模式,如果第一个条件满足，就返回结果 r1 = re.findall('[a-z]{3,6}?', a) print(r) print(r1) 打印结果 ['py...
python中的贪婪与非贪婪【？详解】
浩-先生的博客
08-15 1312
Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符； 非贪婪则相反，总是尝试匹配尽可能少的字符。 在”*”,”?”,”+”,”{m,n}”后面加上？，使贪婪变成非贪婪。 举例： ret = re.match(r'#.*?#', '#吾之初心#永世不忘#') print(ret.group()) 解析：？后面的的数据让我自己（这里指的是？后面...
python正则中的贪婪与非贪婪
09-28 188
当重复一个正则表达式时，如用 a*，操作结果是尽可能多地匹配模式。当你试着匹配一对对称的定界符，如 HTML 标志中的尖括号。匹配单个 HTML 标志的模式不能正常工作，因为 .* 的本质是“贪婪”的 >>> s = '<html><head><title>Title</title>'>>> len(s...
Python: 贪婪匹配与非贪婪匹配
手写我对你的温柔
11-16 804
时间过得可真快。一眨眼，离上次学python爬虫已经是1年零1个月了。 最近，突然 ^_^ ,想干点老本行，爬点美女图片瞅瞅~~ but 以前学过的基本都忘完了。好在“拾起来”还不算太困难。 贪婪匹配与非贪婪匹配。 就好比一个男人，一个渣男心里想的，老子就要全天下所有的女人。 而像我这种老实人，只想对喜欢自己的人好。 所以，这里的我就是非贪婪。而渣男就是贪婪的。即贪婪：想要的更多，...
正则表达式---之后，换行符之前
最新发布
10-16
<think>首先，用户的问题是关于正则表达式的：用户想查找一个正则表达式，用于匹配在'---'之后、但在换行符之前的内容。用户提供的引用内容涉及正则表达式如何处理换行符。 关键点是： - 用户要匹配'---'之后的内容，直到换行符。 - 引用中提到： - [^1]：正则表达式中"."不匹配换行符，但可以使用[\s\S]来匹配任何字符，包括换行符。 - [^2]：基本正则表达式中"."匹配除了换行符以外的所有字符；\n匹配换行符；在BRE中，可以使用点号但不包括换行。 - [^3]：在Python中，使用[\s\S]可以匹配包括换行符的任意字符。 用户的具体需求是：匹配'---'之后、换行符之前的内容。这意味着我们需要捕获从'---'之后开始，到第一个换行符之前的文本。 所以，正则表达式应该： 1. 匹配字符串"---"。 2. 然后捕获接下来直到换行符的所有内容。 在正则表达式中，换行符通常是\n。因此，我们需要一个模式来匹配： - 文字字符串"---"，可能使用转义如果必要，但'---'不是特殊字符，所以可以直接使用。 - 然后使用一个子组来捕获直到换行符的字符。 一个常见的方法是使用非贪婪匹配或直接匹配直到特定字符。既然我们要匹配到换行符之前，我们可以使用： - \r?\n 来匹配换行符（考虑Windows和Linux的差异），但更好的是使用一个模式来匹配所有字符直到换行符。 由于"."不匹配换行符，我们可以使用[^\n]*来匹配任何字符除了换行符，这会匹配直到换行符。 具体步骤： - 先用"---"匹配三个连字符。 - 然后使用一个捕获组：([^\n]*) 来匹配零个或多个非换行字符。 - 最后，可能需要匹配换行符本身，但用户说"换行符之前"，所以我们应该停在换行符前。 正则表达式：---([^\n]*) 解释： - --- : 匹配字面字符串"---" - ([^\n]*) : 捕获组，匹配零个或多个非换行字符（这意味着它会捕获直到换行符或字符串结束的内容） 在捕获组中，我们使用[^\n]，这匹配任何字符除了换行符，所以它会匹配直到遇到换行符。 在引用[^3]中提到，[\s\S]可以用来匹配任何字符包括换行符，但在这里，我们不想要匹配换行符，所以[^\n]更直接。 用户的需求是："'---'之后换行符之前内容"，所以内容不包括换行符。 因此，正则表达式应该是：---([^\n]*) 在上下文中有可能"---"是模式的一部分，可能需要转义，但因为它是普通字符，不需要。 现在，考虑多行的情况。用户可能需要处理多行文本。 例如，假设文本是： some text ---match this part next line 正则表达式---([^\n]*)应该匹配"---match this part"，并捕获"match this part"。 在捕获组中，我们捕获了"---"之后的字符直到换行符。[^\n]*匹配任何非换行字符序列。 如果"---"之后有多个换行符，但用户说"换行符之前"，可能指的是第一个换行符。 引用[^2]提到在Linux中换行符是\n，在Windows中是\r\n，所以为了跨平台，最好使用\r?\n来匹配换行符。 但在匹配直到换行符时，使用[^\n]应该工作，因为在大多数正则引擎中，[^\n]匹配任何字符除了换行符（ASCII 10）。 在捕获组中，我们不需要匹配换行符本身；我们只需匹配非换行字符。 另一个方式是使用懒惰匹配：---(.*?)\n 但[^\n]*更高效，因为它直接指定了字符集。 现在，用户提到"用于匹配'---'之后、换行符之前内容"，所以要返回匹配的内容，通常是捕获组。 在回答中，我应该提供一个完整的正则表达式示例。 由于用户引用了Python和Java，正则表达式语法可能因语言而异，但基本模式相同。 核心正则表达式：---([^\n]*) 但为了捕获内容，我们使用捕获组。 在替换或查找中，使用这个模式可以提取内容。 现在，构建回答： - 系统指令要求使用中文回答。 - 结构清晰：先解释问题，然后给出解决方案。 - 在回答中引用的段落末尾添加引用标识，如[^1]。 - 生成相关问题。 - 数学表达式用$...$，但这里没有数学。 - 独立段落用$$...$$，但也没有。 回答结构： 1. 理解用户需求：用户想匹配在'---'之后、换行符之前的文本。 2. 基于引用，解释为什么某些方法不工作（如"."不匹配换行符）。 3. 给出正则表达式：---([^\n]*) 4. 解释：这个表达式匹配"---"，然后捕获接下来直到换行符的所有字符。 5. 提供示例。 6. 生成相关问题。 引用处理： - 当提到引用内容时，添加[^1], [^2], [^3]。 - 例如：在正则表达式中，点号"."不匹配换行符[^1]，因此需要使用其他方法如[^\n]。 最终正则表达式：---([^\n]*) 在Python或其他语言中使用时，可能需要考虑多行标志或具体实现。 但核心是相同的。 </think>基于您的查询，我将逐步解释如何构建一个正则表达式，用于匹配字符串 `---` 之后、换行符之前的内容。您的需求聚焦于捕获 `---` 之后的所有字符，直到遇到第一个换行符（但不包括换行符本身）。我会结合您提供的引用内容（特别是关于正则表达式如何处理换行符的说明），给出一个可靠的正则表达式方案。 ### 步骤分析 1. **理解需求**: - 您需要匹配 `---` 之后的文本，直到换行符前。 - 关键点：正则表达式中，点号 `.` 默认不匹配换行符[^1][^2]。这意味着使用 `.(.*)` 无法捕获换行后的内容。 - 解决方案：使用字符类 `[^\n]`（匹配除换行符外的任意字符）或 `[\s\S]`（匹配所有字符，包括换行符）[^3]。但您的需求是“换行符之前”，因此 `[^\n]` 更直接高效。 2. **构建正则表达式**: - 核心模式：`---([^\n]*)` - `---`: 匹配字面字符串 `---`（无需转义，因为不是正则元字符）。 - `([^\n]*)`: 捕获组 `(...)`，用于提取内容： - `[^\n]`: 匹配任何非换行符的字符（例如字母、数字、空格等）。 - `*`: 表示零个或多个匹配（允许 `---` 后无内容）。 - 这个模式会匹配 `---` 后到第一个换行符前的所有字符，并捕获到分组中。 - **完整正则表达式**: `---([^\n]*)` - 它在大多数编程语言（如 Python、Java）中通用。 - 示例：在文本 `---hello world\n---next line` 中，它会捕获 `hello world`（第一组）。 3. **为什么这个方案可靠？** - 避免点号问题：点号 `.` 不匹配换行符[^1]，而 `[^\n]` 专门排除换行符，确保只捕获到换行符前的内容。 - 跨平台兼容：换行符在 Linux 是 `\n`，在 Windows 是 `\r\n`[^2]。`[^\n]` 能正确处理所有情况，因为它只关注非换行字符。 - 高效性：比使用 `[\s\S]` 或懒惰匹配 `.*?` 更简洁，避免不必要的开销（因为您不需要匹配换行符本身）。 ### 示例代码（Python 演示） 以下是一个 Python 示例，展示如何使用该正则表达式提取内容： ```python import re # 示例文本（包含 '---' 和换行符） text = """some text ---match this part next line ---another match""" # 正则表达式模式 pattern = r'---([^\n]*)' # 查找所有匹配 matches = re.findall(pattern, text) print(matches) # 输出: ['match this part', 'another match'] ``` - 解释：`re.findall` 返回所有捕获组的内容（即 `---` 后到换行符前的文本）。 - 在其他语言（如 Java）中，语法类似： ```java import java.util.regex.*; Pattern pattern = Pattern.compile("---([^\n]*)"); Matcher matcher = pattern.matcher(text); while (matcher.find()) { System.out.println(matcher.group(1)); // 输出捕获内容 } ``` ### 注意事项 - **多行处理**: 如果文本是多行的，模式 `---([^\n]*)` 默认会逐行匹配。无需额外标志（如多行模式），因为它不依赖行起始/结束锚点。 - **边界情况**: - 如果 `---` 后立即是换行符，捕获组为空字符串。 - 如果 `---` 出现在文本末尾且无换行符，将匹配到字符串结束（但您的需求是“换行符之前”，所以需确保文本中有换行）。 - **性能**: `[^\n]*` 比替代方案（如 `[\s\S]*?`）更高效[^3]，因为它避免回溯。 如果您需要进一步调整（如处理特定语言的正则引擎细节），请提供更多上下文！
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值