运行结果及语句问题

147380124

程序代码：
#!/usr/bin/python
import re

line = "Cats are smarter than dogs";

searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)

if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"



想问一下各位大佬，为什么程序运行出来是下面这样的结果啊？
searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

主要是下面这句话不太懂：
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)



还请各位大佬帮助一下

z5560636

这是正则表达式   group  是输出第一个括号内的内容，以下是我的笔记：
\w        匹配字符  数字及下划线
\W       匹配不是字母  数字及下划线
\s         匹配任意空白字符, 等价于[\t\n\r\f]
\S         匹配任意非空字符
\d         匹配任意数字,等价于[0-9]
\D         匹配任意非数字的字符
\A         匹配字符串开头
\Z         匹配字符串结尾,如果存在换行,只匹配到换行前的结束字符串
\z         匹配字符串结尾,如果存在换行,同事还会匹配换行符
\G         匹配最后匹配完成的位置
\n         匹配一个换行符
\t         匹配一个制表符
^         匹配一行字符串的开头
$         匹配一行字符串的结尾
.         匹配任意字符,除了换行符,当re.DOTALL标记被指定时,则可以匹配包括换行符的任意字符
[...]      用来表示一组字符,单独列出,比如[amk]匹配a,m,k
[^...]    不在[]中的字符,比如[^abc]匹配除了a,  b,  c之外的字符
*         匹配0个或多个表达式
+        匹配1个或多个表达式
?        匹配0个或1个前面的正则表达式定义的片段,非贪婪模式
{n}     精准匹配n个前面的表达式
{n,m} 匹配n到m次由前面正则表达式定义的片段,贪婪方式
a|b     匹配a或b
()        匹配括号内的表达式,也表示一个组

147380124

z5560636 发表于 2021-4-12 09:13
这是正则表达式   group  是输出第一个括号内的内容，以下是我的笔记：
\w        匹配字符  数字及下划线 ...

searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
主要是这句话，单个都懂，连起来就不知道啥意思了

z5560636

147380124 发表于 2021-4-12 12:55
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
主要是这句话，单个都懂，连起来就不 ...

你把把笔记内的东西带入进去看，
(.*)   # 连起来就是 匹配一组任意字符。  依次类推。  
()        匹配括号内的表达式,也表示一个组
.         匹配任意字符,除了换行符,当re.DOTALL标记被指定时,则可以匹配包括换行符的任意字符
*         匹配0个或多个表达式

阿奇_o

理解的正则的关键是：
  0. 此模式 代表 什么字符？
  1. 依 此模式  逐个字符、逐个字符 地 匹配，会怎样？到哪个字符停止？
  2. 分组，和 不分组，有啥区别？
  3. 所谓的“贪婪模式”，和 “非贪婪模式” 到底什么意思？ 区别在哪？

1. 
   
2. import re
   
3. line = "Cats are smarter than dogs"
   
4. # line_1 = "Cats are smarter than xxxy dogs"
   
5. # line_2 = "Cats are smarter than  dogs"
   
6. matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
   
7. # 理解 ? 非贪婪模式，到底是什么意思？
   
8. # matchObj = re.match( r'(.*) are (.*).*', line, re.M|re.I)     # 意思是：? 对前一个正则模式进行匹配次数判断,最多匹配一次，即0次或1次；
   
9.                                                                 # 这里 .* 是 ? 所要判断的 正则模式，.代表任一一个字符，*代表允许有.这样的若干个字符（0个到无限个）
   
10.                                                                 # ? 要判断 .* 的匹配发生次数，.和*的共同作用，使字符串smarter，开始逐个字符匹配出来，
    
11.                                                                 # 但随后遇到了 空格 是 新的正则模式，且只匹配 单个空格符，于是匹配到字符 r 时，.* 的作用，就结束了。
    
12. # matchObj = re.match( r'(.*) are (.*)', line, re.M|re.I)         # 若没有 空格和随后的匹配模式影响，.*将匹配到最后所有字符（故又叫“贪婪模式”）
    
13. 
    
14. matchObj = re.match( r'(.*) are (.*) .*', line, re.M|re.I)    # 理解：这里为什么会匹配出 smarter than
    
15. # 因为 少了 ? 进行约束，.*的共同作用，可以一直匹配下去，但 你上面说 空格 的影响，为什么它没有在r后的空格停止，而是到了 than的 n 后的空格才停止？
    
16. # 因为 随后的还有 匹配模式 r' .*' 的影响，即最后部分，它需要匹配出一个 空格+任意字符若干个 这样的模式， 所以 它是到了 n后停止。
    
17. # 你可以尝试 line_2 的字符串，并打印匹配出的字符长度，你会发现 than的n后，还有一个空格。而后部分，必然也有个空格，即 空格+dogs
    
18. 
    
19. if matchObj:
    
20.     print( "matchObj.group() : ", matchObj.group())     # 所有符合正则模式的匹配结果，包括 非分组部分。（没小括号的，即 非分组部分，也匹配出，只是不分组）
    
21.     print( "matchObj.group(1) : ", matchObj.group(1))   # 匹配到的 分组部分的 第一组结果
    
22.     print( "matchObj.group(2) : ", matchObj.group(2))   # 匹配到的 分组部分的 第二组结果   
    
23.     # print(len(matchObj.group(2))) # 为什么会是 13 字符？
    
24. else:
    
25.     print( "No match!!" )
    

复制代码