【python3】 【regular expression】笔记

【python3】 【regular expression】【问题】： python3 - 【regular expression】 笔记

【回答】


	1、	【re.MULTILINE】	模式：		
		--	[^$]从匹配字符串，扩展到匹配‘行’的首位。
		--	即[^$]从匹配“字符串”，扩展到匹配“行”。
		
		--	“行”，以“newline(\n)”结尾标志的计量单位。
		--	“行【\n】”的结尾标识符，既是“一个行”的结尾位置；也是“另一个行（下位相邻的行）”的开始位置。
			--	“[\n]”示例：	"abcd\nefgh"：
				--	d:	是第一个行的结尾位置；
				--	e:	是下位相邻行的开始位置；

　　　--【总结：re.MULTILINE】：
　　　　--　　行的标识符：'\n'；这个字符，是“行的标识符”。
　　　　--　　常规（默认）情况下，“一个字符串”包含“一行”。x1 = "abc123def"；“这个字符串”包含一行"abc123def\n"
　　　　--　　当启用“re.MULTILINE”后，“一个字符串”可以包含“多个行”。
　　　　　　　　--　　x2 = "123abc\n456def\n789hij"；　　“这个字符串”包含“3行”。
　　　　　　　　--　　x2等价于3行（3个字符串）：　　"123abc\n"、"456def\n"、"789hij\n"。

		
	
	2、	回溯：	
			--	第一次匹配失败后；调整pattern中选择,重新匹配。
			--	允许匹配两次；允许“被匹配的字符串”第二次匹配pattern.
		不能回溯：
			--	当pattern匹配失败后，直接结束本次匹配。
			--	只有一次匹配机会；	无论pattern是否涉及“重复次数”。

		
	3、	贪婪：
			--	贪婪模式：	--	涉及“重复次数”的pattern时，在匹配成功的前提下，尽可能匹配到“被匹配的字符串中”到最长的“子字符串”。
						--	在匹配成功的前提下，在涉及“重复次数”的pattern中，匹配“被匹配字符串中最长的子字符串”。
						--	pattern，在“被匹配的字符串中”，匹配到“最长子字串”。
	
	
	4、	(*/+/?)【?+】
	
			--	回溯：		第一次匹配失败；	通过调整pattern中的次数，再次匹配“被匹配的字符串”； 两次匹配。
				--	当“pattern”匹配到“被匹配字符串str1”的末尾时，发现匹配失败；
						然后通过调整（减少）被匹配字符串(str1)中字符的数量，来重新适配“pattern”规则。
				--	回溯：		当匹配失败后；通过调整被匹配字符串的字符数量，来重新适配“pattern”；允许二次匹配。
				--	回溯的本质：	进行两次匹配；	允许进行第二次匹配。
						
			--	(*/+/?)?	最少匹配；	非贪婪模式；	匹配尽可能少的字符串；	

			--	(*/+/?)+	最多匹配；	匹配尽可能多的字符串；		不可回溯；
	
	
	5、	{a,b}【?+】
			--	{a,b}?		匹配最少的次数，能匹配a次就匹配a次；	非贪婪模式；
			--	{a,b}+		匹配最多的次数，能匹配b次就匹配b次；	最多模式；	不可回溯；
			
			

	6、	(...)
			--	创建一个组，可能允许取回匹配到的子字符串。


	7、	(?X...)
			--	这个东西，只是一种通用语法的描述；它没有定义任何具体功能。
			--	这个东西的功能，由“X”定义。
			
			
	8、	(?aiLmsux)
			--	匹配“空字符串”
	
	
	9、	(?:...) 和 (?X-Y:...)
			--	主要用于“丢弃不需要的内容 ... ”。
			--	用于“排除”不想匹配的内容。丢弃“不需要的内容 ... ”
			--	不捕捉：	不能“取回捕捉内容”，不能“引用匹配内容”。
			--	不捕捉，不取回，不引用


	10、	（*+？）+ 等价形式：	最多匹配，可捕捉，不能回溯
			--	A*+		<==>	(？>A*)
			--	A++		<==>	(？>A+)
			--	A?+		<==>	(？>A?)


	11、	(?P<name>...) 和 (?P=name)
			--	(?P<name>...)
				--	创建“有名称的组”；
				--	创建一个带有“名字”的组；
			--	(?P=name)
				--	引用“有名称的组”


	12、	(?#...)：		
			--	在pattern中，添加“注释内容”
			--	示例
				--	pattern	=	r"xyz(?#variable name)-abc"
				--	pattern	起作用的部分为：		r"xyz-abc"
				


	13、	定义：		lookahead和lookbehind
			---ABC--	（被匹配的字符串）
				--	B：	为当前位置（匹配时，当前指针所在位置）
				--	A:	A相对于B，为behind； 在时序上，behind叫做“过去（前续/前相邻）”；
				--	C：	C相对于B，为ahead； 在时序上，ahead叫做“未来（后续/后相邻）”


	14、	(?=...) 和 (?!...)
			--	(?=...)
				--	not consume;	lookahead match;
				--	限定了“后续匹配内容”；	后续匹配内容为...
				--	s="xyzdef",	pattern = "xyz(?=def)"
					--	匹配“后续为def”的xyz；
					--	"xyzdef"中的xyz，匹配成功。
			--	(?!...) 
				--	not consume;	lookahead not match;
				--	限定了“后续匹配内容”；	后续匹配能容不能为...
				--	s="xyzdef",	pattern = "xyz(?!def)"
					--	匹配“后续内容不为def”的xyz；
					--	"xyzdef"中的xyz，匹配失败。

			--	概述：
				--	这两个匹配模式，是限定了“后续匹配内容”的模式。
				--	这两个匹配模式，都是以“后续内容”为匹配的限定条件；
					这属于双次限定（第一次限定了匹配的字符串；第二次限定了匹配字符串的后续内容）


	15、	(?<=...) 和 (?<!...)
			--	(?<=...)
				--	not consume;	lookbehind
				--	限定了“前续匹配内容”；	前续匹配内容为...
					--	s="defxyz",	pattern = "xyz(?<=def)"
					--	匹配“前续内容为def”的xyz
					--	"defxyz"中的xyz，匹配成功。
			--	(?<!...)
				--	not consume;	lookbehind
				--	限定了“前续匹配内容”；	前续匹配内容不为...
					--	s1="defxyz",	s2="abcxyz",	pattern = "xyz(?<!def)"
					--	"defxyz"中的xyz，匹配失败。
					--	"abcxyz中的xyz"，匹配成功。
			
			--	概述：
				--	这两个匹配模式，是限定了“前续匹配内容”的模式；
				--	这两个模式，属于双次限定的匹配模式。


	16、	(?(id/name)yes-patter|no-pattern)
			--	当（id/name）存在时，执行"yes-patter"；	当（id/name）不存在时，执行"no-pattern"。
			
	
	17、	(?>...)
		--	概要：		原子分组内容，pattern一旦匹配，便不回溯；		用途是“快速筛选”。
		--	概述：		在Python的re模块中，(?>...)是一个原子分组(atomic grouping)语法，属于正则表达式的高级特性。
		--	功能：
			--	它的作用是：
				--	原子分组内的匹配一旦开始，就会独占匹配，不会进行回溯
				--	如果原子分组内的模式匹配失败，正则引擎会立即放弃整个分组，不会尝试其他可能性
				--	这可以提高匹配效率，特别是在处理复杂模式时
		--	举例：
			--	普通分组 (a|ab)c 匹配 "abc" 时会先尝试 "a"，失败后再回溯尝试 "ab"
			--	原子分组 (?>a|ab)c 匹配 "abc" 时，如果选择了 "a" 就会直接失败，不会回溯尝试 "ab"
				原子分组常用于：
				--	优化正则表达式性能
				--	防止灾难性回溯
				--	确保某些模式必须完整匹配
				注意：这个特性在Python 3.11+中才被完整支持，早期版本可能需要使用第三方regex库。

 

 

二、参考内容

 

　　1、　　re　　-　　https://docs.python.org/3/library/re.html