正则表达式学习笔记----python处理

桃扇骨 2023-07-18 12:56 25阅读 0赞

**目录**

一.Python处理正则表达式的流程

1.利用python在字符串“my phone number is 010-63748239”中查找电话号码

2.python处理正则表达式流程总结

3.分组--将区号和主号码从电话号码中分离出来--group()

4.分组--一次返回所有的分组--groups()

5.查找字符串中符合条件的所有子串--Regex对象的findall函数

二.正则表达式的匹配模式

1. ?：匹配问号之前的分组0次或1次、非贪心匹配（见下文第9项）

2.\*：匹配星号之前的分组0次或多次

3.+：匹配加号之前的分组1次或多次

4.用\{\}花括号匹配之前的分组指定次数

5.\\d：匹配0到9的任意单个数字；\\D：匹配除0-9以外的任意单个字符

6.\\w：匹配字母、数组或下划线的单个字符；\\W:匹配除左侧以外的任意单个字符

7.\\s：匹配空格、制表符或换行符的单个字符；\\S:匹配除左侧以外的任意单个字符

8.管道符|：匹配多个表达式中的一中（逻辑含义：或）

9.贪心匹配和非贪心匹配

10.用方括号\[\]定义自己的字符分类

11.^和$：分别表示匹配的字符串必须以该匹配模式开头和结尾

12.句点（.）表示通配符，匹配除换行符以外的所有单个字符

13.用“.\*”（点星）匹配所有字符

14.如何用句点（.）匹配换行符

15.如何不区分大小写进行匹配

16.正则表达式太长，需要换行和注释时，如何忽略换行和注释？

17.re.compile()函数需要同时传入re.VERBOSE、re.DOTALL、re.I时，用管道符|连接作为一个参数传入

18.替换字符串，用Regex对象的sub方法

--------------------

# 一.Python处理正则表达式的流程 #

### 1.利用python在字符串“my phone number is 010-63748239”中查找电话号码 ###

import re #re是python的一个内置模块，用来处理正则表达式
    PhoneNumRegex=re.compile(r'\d\d\d-\d\d\d\d\d\d\d\d')#re.compile函数，输入一个正则表达式，返回一个Regex对象；为了避免python将正则表达式中的反斜杠处理为转义字符，用"r"放在正则表达式前，表示保持原始字符串
    PhoneNum=PhoneNumRegex.search("my phone number is 010-63748239")#search函数查找输入字符串中符合正则表达式的第一个子字符串，返回一个match对象
    print("the number is: ",PhoneNum.group())#group函数返回查询结果
    
    #输出
    '''
    the number is:  010-63748239
    '''

### 2.python处理正则表达式流程总结 ###

*  导入re模块：import re
 *  调用re.compile函数，输入一个正则表达式，返回一个Regex对象
 *  调用Regex对象的search函数，输入待查找的字符串；若未查找到结果返回None；若查找到结果返回Match对象
 *  调用Match对象的group函数，返回查找到的字符串

### 3.分组--将区号和主号码从电话号码中分离出来--group() ###

*  在正则表达式中用英文的小括号()将需要分离出来的部分括起来
 *  最后调用Match对象的group方法将区号和实际号码输出
 *  若group()中传入1，表示输出第一个括号（分组）内的内容
 *  若group()中传入2，表示输出第二个括号（分组）内的内容
 *  若group()中传入0或不传值，表示输出整个匹配内容

import re 
    PhoneNumRegex=re.compile(r'(\d\d\d)-(\d\d\d\d\d\d\d\d)')#将区号和实际号码用()括起来
    PhoneNum=PhoneNumRegex.search("my phone number is 010-63748239")#match对象
    print("区号是: ",PhoneNum.group(1))
    print("主号码是: ",PhoneNum.group(2))
    print("电话号码是: ",PhoneNum.group())
    
    #输出：
    '''
    区号是:  010
    主号码是:  63748239
    电话号码是:  010-63748239
    ...

###  4.分组--一次返回所有的分组--groups() ###

*  用Match对象的groups函数返回所有分组，返回类型为一个元组，每个元素为一个字符串

import re 
    PhoneNumRegex=re.compile(r'(\d\d\d)-(\d\d\d\d\d\d\d\d)')
    PhoneNum=PhoneNumRegex.search("my phone number is 010-63748239")#match对象
    print("所有分组信息: ",PhoneNum.groups())#用groups函数输出所有分组
    
    
    #输出：
    '''
    所有分组信息:  ('010', '63748239')
    ...

### 5.查找字符串中符合条件的所有子串--Regex对象的findall函数 ###

*  Regex对象的findall方法和search方法进行对比：

1.  search方法查找字符串“第一次”出现匹配的字符串；findall方法查找字符串中所有匹配的字符串
2.  search方法返回一个Match对象或者None；findall方法返回一个列表，无分组时，每个元素是每一个匹配的字符串，有分组时，每个元素是一个元组，元组内每个元素是每个分组子串。

*  无分组时，用findall查找电话号码

import re 
    PhoneNumRegex=re.compile(r'\d\d\d-\d\d\d\d\d\d\d\d')
    PhoneNum=PhoneNumRegex.findall("my phone number is 010-63748239, and his is 021-23138212")
    print(PhoneNum)
    
    
    #输出：
    '''
    ['010-63748239', '021-23138212']
    ...

*  有分组时，用findall查找电话号码

import re 
    PhoneNumRegex=re.compile(r'(\d\d\d)-(\d\d\d\d\d\d\d\d)')
    PhoneNum=PhoneNumRegex.findall("my phone number is 010-63748239, and his is 021-23138212")
    print(PhoneNum)
    
    
    #输出：
    '''
    [('010', '63748239'), ('021', '23138212')]
    ...

*   没有匹配时，用findall查找电话号码，返回空列表

import re 
    PhoneNumRegex=re.compile(r'(\d\d\d)-(\d\d\d\d\d\d\d\d)')
    PhoneNum=PhoneNumRegex.findall("my phone number is")
    print(PhoneNum)
    
    
    #输出：
    '''
    []
    ...

# 二.正则表达式的匹配模式 #

### 1. ?：匹配问号之前的分组0次或1次、非贪心匹配（见下文第9项） ###

import re 
    PhoneNumRegex=re.compile(r'(\d\d\d-)?(\d\d\d\d\d\d\d\d)') #(\d\d\d-)匹配0次或1次
    PhoneNum_once=PhoneNumRegex.search("my phone number is 010-12342313")
    print("PhoneNum_once:",PhoneNum_once.group())
    
    PhoneNum_zero=PhoneNumRegex.search("my phone number is 12342313")
    print("PhoneNum_zero:",PhoneNum_zero.group())
    
    
    #输出：
    '''
    PhoneNum_once: 010-12342313
    PhoneNum_zero: 12342313
    ...

### 2.\*：匹配星号之前的分组0次或多次 ###

### 3.+：匹配加号之前的分组1次或多次 ###

### 4.用\{\}花括号匹配之前的分组指定次数 ###

import re 
    PhoneNumRegex=re.compile(r'(\d{3})-(\d{8})') #{3}表示匹配数字3次
    PhoneNum=PhoneNumRegex.search("my phone number is 010-12342313")
    print("PhoneNum:",PhoneNum.group())
    
    
    
    
    #输出：
    '''
    PhoneNum: 010-12342313
    ...

*  \{3\}：匹配3次前面的分组
 *  \{3,5\}：匹配至少3次，至多5次前面的分组
 *  \{3,\}：匹配3次或更多次前面的分组
 *  \{,5\}：匹配0次或1次或2次或3次或4次或5次前面的分组

### 5.\\d：匹配0到9的任意单个数字；\\D：匹配除0-9以外的任意单个字符 ###

### 6.\\w：匹配字母、数字或下划线的单个字符；\\W:匹配除左侧以外的任意单个字符 ###

### 7.\\s：匹配空格、制表符或换行符的单个字符；\\S:匹配除左侧以外的任意单个字符 ###

### 8.管道符|：匹配多个表达式中的一种（逻辑含义：或） ###

*  r'Alex|Amber'：如果用search函数，匹配出Alex和Amber在字符串中最先出现的一个；如果用findall函数，匹配出字符串中所有的Alex和Amber
 *  r'Alex(ab|cd|ef)'：匹配出Alexab或Alexcd或Alexef

### 9.贪心匹配和非贪心匹配 ###

*  在字符串“AbAbAbAb”中，若用正则表达式"(Ab)\{2,4\}"来匹配，那么匹配结果是“AbAbAbAb”。
 *  这是因为默认匹配是贪婪匹配，即匹配能够匹配上的最长的字符串
 *  若要匹配最短的字符串，即非贪心匹配，可以在这段匹配后面加上“?”如："(Ab)\{2,4\}？"，那么匹配结果是“Ab”

import re
    
    #贪心匹配
    greed=re.compile(r'(Ab){2,4}')
    match_greed=greed.search('AbAbAbAb')
    print(match_greed.group())  #输出：AbAbAbAb
    
    #非贪心匹配
    ungreed=re.compile(r'(Ab){2,4}?')
    match_ungreed=ungreed.search('AbAbAbAb')
    print(match_ungreed.group())  #输出：AbAb

### 10.用方括号\[\]定义自己的字符分类 ###

*  匹配0至5的单个字符：\[0-5\]
 *  匹配小写字母的单个字符：\[a-z\]
 *  匹配一个或多个\[字母或数字的单个字符\]：\[a-zA-Z0-9\]+
 *  匹配“ABCD”四个字母中的任意一个：\[ABCD\]
 *  匹配“ABCD”以外的任意单个字符：\[^ABCD\]

### 11.^和$：分别表示匹配的字符串必须以该匹配模式开头和结尾 ###

*  在字符串“Hello world!”中，用正则表达式“^Hello”来匹配，则匹配结果返回“Hello”
 *  在字符串“Hello world!”中，用正则表达式“^Kello”来匹配，则匹配结果返回None
 *  在字符串“Hello world!”中，用正则表达式“^\[A-Z\]”来匹配，则匹配结果返回"H"
 *  在字符串“Hello world!”中，用正则表达式“^\[a-z\]”来匹配，则匹配结果返回None
 *   
 *  在字符串“Hello world!”中，用正则表达式“!$”来匹配，则匹配结果返回"!"
 *  在字符串“Hello world!”中，用正则表达式“\[a-z\]!$”来匹配，则匹配结果返回"d!"
 *  在字符串“Hello world!”中，用正则表达式“\[A-Z\]!$”来匹配，则匹配结果返回None
 *   
 *  在字符串“Hello”中，用正则表达式“^\[A-Za-z\]+$”来匹配，则匹配结果返回整个字符串“Hello”
 *  在字符串“Hello”中，用正则表达式“^\\d+$”来匹配(应匹配都是数字的序列)，则匹配结果返回None

### 12.句点（.）表示通配符，匹配除换行符以外的所有单个字符 ###

*  在字符串“The cat in the hat sat on the flat mat.”中，用正则表达式“.at”匹配，匹配结果为\['cat', 'hat', 'sat', 'lat', 'mat'\]

### 13.用“.\*”（点星）匹配所有字符 ###

*  .匹配除换行外的所有字符；\*表示前面的分组出现0次或多次

### 14.如何用句点（.）匹配换行符 ###

*  通过传入 re.DOTALL 作为 re.compile()的第 二个参数，可以让句点字符匹配所有字符，包括换行字符。

### 15.如何不区分大小写进行匹配 ###

*  通过传入 re.I 作为 re.compile()的第 二个参数，可以让正则表达式中的字母不用区分大小写。

import re
    ignoreCase = re.compile(r'hello',re.I)
    mat = ignoreCase.search('HELLo')
    print(mat.group())#匹配成功：HELLo
    
    mat2 = ignoreCase.search('hello')
    print(mat2.group())#匹配成功：hello

### 16.正则表达式太长，需要换行和注释时，如何忽略换行和注释？ ###

*  通过传入  re.VERBOSE作为 re.compile()的第二个参数，可以让正则表达式忽略空白符和注释。

### 17.re.compile()函数需要同时传入re.VERBOSE、re.DOTALL、re.I时，用管道符|连接作为一个参数传入 ###

### 18.替换字符串，用Regex对象的sub方法 ###

*  sub函数的传入参数，第一个参数是用于取代匹配字符串的新字符串；第二个参数是待匹配的字符串
 *  sub函数的输出是替换后的新字符串

import re
    #将字符串中的张三换成李四
    Reg = re.compile(r'张三') #Regex对象
    mat = Reg.sub('李四',"张三考了第一名")
    print(mat) #输出：李四考了第一名

*  若需要用匹配到的字符串中某一部分来替换匹配字符串，比如姓名Alex用首字母A来替换，那么可以用如下示例来解决

import re
    #用"Alex"的首字母替换"Alex"
    Reg = re.compile(r'(.)lex') #Regex对象
    mat = Reg.sub(r'\1...',"Alex and Blex") #用第一个分组的内容替换匹配到的模式，同理可以用\2表示第二个分组的内容
    print(mat) #输出：A... and B...