python正则表达式findall的使用

戴斌發表於 2019-5-23 17:19:00

<div id="cnblogs_post_body" class="blogpost-body">
文章来源与：http://www.cnblogs.com/zjltt/p/6955965.html
正则表达式
正则表达式本身是一种小型的、高度专业化的编程语言，而在python中，通过内嵌集成re模块，程序员们可以直接调用来实现正则匹配。正则表达式模式被编译成一系列的字节码，然后由用C编写的匹配引擎执行。
<img src="https://images2015.cnblogs.com/blog/955761/201608/955761-20160805200743450-1819053688.png" alt="">
正则表达式是用来匹配处理字符串的 python 中使用正则表达式需要引入re模块
如：
import re #第一步，要引入re模块
a = re.findall("匹配规则", "要匹配的字符串") #第二步，调用模块函数
以列表形式返回匹配到的字符串
如：
<div class="cnblogs_code"><img id="code_img_closed_367ae0fc-73a5-4b66-825a-1001f20b1a09" class="code_img_closed" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_367ae0fc-73a5-4b66-825a-1001f20b1a09" class="code_img_opened" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_367ae0fc-73a5-4b66-825a-1001f20b1a09" class="cnblogs_code_hide" style="display: block">
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("匹配规则", "这个字符串是否有匹配规则的字符") #第二步，调用模块函数
print(a)#以列表形式返回匹配到的字符串
#打印出 ['匹配规则']</pre>
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
</div>
View Code</div>
 
^元字符
字符串开始位置与匹配规则符合就匹配，否则不匹配
匹配字符串开头。在多行模式中匹配每一行的开头
<pre>^元字符如果写到[]字符集里就是反取 </pre>
<div class="cnblogs_code"><img id="code_img_closed_4ef8bba4-04f8-4b3e-b703-ad5a2faaa23f" class="code_img_closed" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_4ef8bba4-04f8-4b3e-b703-ad5a2faaa23f" class="code_img_opened" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_4ef8bba4-04f8-4b3e-b703-ad5a2faaa23f" class="cnblogs_code_hide" style="display: block">
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("^匹配规则", "匹配规则这个字符串是否匹配") #字符串开始位置与匹配规则符合就匹配，否则不匹配
print(a)#以列表形式返回匹配到的字符串
#打印出 ['匹配规则']</pre>
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
</div>
View Code</div>
<pre> </pre>
<pre>[^a-z]反取，匹配出除字母外的字符，^元字符如果写到字符集里就是反取 </pre>
<div class="cnblogs_code"><img id="code_img_closed_14dcfba9-0b2f-4565-8aa5-5a8e72bf11f7" class="code_img_closed" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_14dcfba9-0b2f-4565-8aa5-5a8e72bf11f7" class="code_img_opened" style="display: inline" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_14dcfba9-0b2f-4565-8aa5-5a8e72bf11f7" class="cnblogs_code_hide" style="display: block">
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("[^a-z]", "匹配s规则这s个字符串是否s匹配f规则则re则则则") #反取，匹配出除字母外的字符
print(a)#以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']</pre>
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
</div>
View Code</div>
<pre></pre>
$元字符
字符串结束位置与匹配规则符合就匹配，否则不匹配
匹配字符串末尾，在多行模式中匹配每一行的末尾
<div class="cnblogs_code"><img id="code_img_closed_b60a9f8a-fc34-4fce-8fc4-ec74dc86a781" class="code_img_closed" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_b60a9f8a-fc34-4fce-8fc4-ec74dc86a781" class="code_img_opened" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_b60a9f8a-fc34-4fce-8fc4-ec74dc86a781" class="cnblogs_code_hide" style="display: block">
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("匹配规则$", "这个字符串是否匹配规则") #字符串结束位置与匹配规则符合就匹配，否则不匹配
print(a)#以列表形式返回匹配到的字符串
#打印出 ['匹配规则']</pre>
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
</div>
View Code</div>
 
*元字符
需要字符串里完全符合，匹配规则，就匹配，（规则里的*元字符）前面的一个字符可以是0个或多个原本字符
匹配前一个字符0或多次，贪婪匹配前导字符有多少个就匹配多少个很贪婪
如果规则里只有一个分组，尽量避免用*否则会有可能匹配出空字符串
<div class="cnblogs_code"><img id="code_img_closed_71b53a42-49ef-4481-99ea-9b21a2c56fd4" class="code_img_closed" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_71b53a42-49ef-4481-99ea-9b21a2c56fd4" class="code_img_opened" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_71b53a42-49ef-4481-99ea-9b21a2c56fd4" class="cnblogs_code_hide" style="display: block">
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("匹配规则*", "这个字符串是否匹配规则则则则则") #需要字符串里完全符合，匹配规则，就匹配，（规则里的*元字符）前面的一个字符可以是0或多个原本字符
print(a)#以列表形式返回匹配到的字符串
#打印出 ['匹配规则则则则则']</pre>
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
</div>
View Code</div>
+元字符
需要字符串里完全符合，匹配规则，就匹配，（规则里的+元字符）前面的一个字符可以是1个或多个原本字符
匹配前一个字符1次或无限次，贪婪匹配前导字符有多少个就匹配多少个很贪婪
<div class="cnblogs_code"><img id="code_img_closed_efac0100-d827-479e-99a8-9e9c0f90c7cd" class="code_img_closed" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_efac0100-d827-479e-99a8-9e9c0f90c7cd" class="code_img_opened" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_efac0100-d827-479e-99a8-9e9c0f90c7cd" class="cnblogs_code_hide" style="display: block">
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
<pre>#!/usr/bin/env python
# -*- coding:gbk -*-
import re #第一步，要引入re模块
a = re.findall("匹配+", "匹配配配配配规则这个字符串是否匹配规则则则则则") #需要字符串里完全符合，匹配规则，就匹配，（规则里的+元字符）前面的一个字符可以是1个或多个原本字符
print(a)#以列表形式返回匹配到的字符串
#打印出 ['匹配配配配配', '匹配']</pre>
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
</div>
View Code</div>
?元字符，和防止贪婪匹配
需要字符串里完全符合，匹配规则，就匹配，（规则里的?元字符）前面的一个字符可以是0个或1个原本字符
匹配一个字符0次或1次
还有一个功能是可以防止贪婪匹配，详情见防贪婪匹配
<div class="cnblogs_code"><img id="code_img_closed_b1b47217-6bfb-4f1c-9d6d-e015cb5b5232" class="code_img_closed" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_b1b47217-6bfb-4f1c-9d6d-e015cb5b5232" class="code_img_opened" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_b1b47217-6bfb-4f1c-9d6d-e015cb5b5232" class="cnblogs_code_hide" style="display: block">
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("匹配规则?", "匹配规这个字符串是否匹配规则则则则则") #需要字符串里完全符合，匹配规则，就匹配，（规则里的?元字符）前面的一个字符可以是0个或1个原本字符
print(a)#以列表形式返回匹配到的字符串
#打印出 ['匹配规', '匹配规则']</pre>
<div class="cnblogs_code_toolbar"><img src="//common.cnblogs.com/images/copycode.gif" alt="复制代码"></div>
</div>
View Code</div>
{}元字符,范围
需要字符串里完全符合，匹配规则，就匹配，（规则里的 {} 元字符）前面的一个字符，是自定义字符数，位数的原本字符
{m}匹配前一个字符m次，{m,n}匹配前一个字符m至n次，若省略n，则匹配m至无限次
{0,}匹配前一个字符0或多次,等同于*元字符 {+,}匹配前一个字符1次或无限次,等同于+元字符 {0,1}匹配前一个字符0次或1次,等同于?元字符
<div class="cnblogs_code"><img id="code_img_closed_0de8fd44-f0ab-4cb8-aebb-10b182123576" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_0de8fd44-f0ab-4cb8-aebb-10b182123576" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_0de8fd44-f0ab-4cb8-aebb-10b182123576" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("匹配规则{3}", "匹配规这个字符串是否匹配规则则则则则") #{m}匹配前一个字符m次，{m,n}匹配前一个字符m至n次，若省略n，则匹配m至无限次
print(a)#以列表形式返回匹配到的字符串
#打印出 ['匹配规则则则']</pre>
</div>
View Code</div>
[]元字符,字符集
需要字符串里完全符合，匹配规则，就匹配，（规则里的 [] 元字符）对应位置是[]里的任意一个字符就匹配
字符集。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，如或。[^abc]表示取反，即非abc。 所有特殊字符在字符集中都失去其原有的特殊含义。用\反斜杠转义恢复特殊字符的特殊含义。
<div class="cnblogs_code"><img id="code_img_closed_c9d2113b-c14c-4c86-8658-4ba466d3e0b7" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_c9d2113b-c14c-4c86-8658-4ba466d3e0b7" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_c9d2113b-c14c-4c86-8658-4ba466d3e0b7" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("匹配规则", "匹配a规则这个字符串是否匹配b规则则则则则") #需要字符串里完全符合，匹配规则，就匹配，（规则里的 [] 元字符）对应位置是[]里的任意一个字符就匹配
print(a)#以列表形式返回匹配到的字符串</pre>
</div>
View Code</div>
<pre>[^]非，反取，匹配出除[^]里面的字符，^元字符如果写到字符集里就是反取 </pre>
<div class="cnblogs_code"><img id="code_img_closed_220aea90-69b5-477e-b4d0-b860274e2345" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_220aea90-69b5-477e-b4d0-b860274e2345" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_220aea90-69b5-477e-b4d0-b860274e2345" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("[^a-z]", "匹配s规则这s个字符串是否s匹配f规则则re则则则") #反取，匹配出除字母外的字符
print(a)#以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']</pre>
</div>
View Code</div>
 
反斜杠后边跟普通字符实现特殊功能；（即预定义字符）
预定义字符是在字符集和组里都是有用的
\d匹配任何十进制数，它相当于类
<div class="cnblogs_code"><img id="code_img_closed_21c0493e-4798-4b0a-b274-e775c5340dbe" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_21c0493e-4798-4b0a-b274-e775c5340dbe" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_21c0493e-4798-4b0a-b274-e775c5340dbe" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("\d", "匹配规则这2个字符串3是否匹配规则5则则则7则") #\d匹配任何十进制数，它相当于类
print(a)#以列表形式返回匹配到的字符串
#打印出 ['2', '3', '5', '7']</pre>
</div>
View Code</div>
\d+如果需要匹配一位或者多位数的数字时用
<div class="cnblogs_code"><img id="code_img_closed_ac74396b-dac5-478b-a74c-62953fb7372b" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_ac74396b-dac5-478b-a74c-62953fb7372b" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_ac74396b-dac5-478b-a74c-62953fb7372b" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:gbk -*-
import re #第一步，要引入re模块
a = re.findall("\d+", "匹配规则这2个字符串134444是否匹配规则5则则则7则") #\d+如果需要匹配一位或者多位数的数字时用
print(a)#以列表形式返回匹配到的字符串
#打印出 ['2', '134444', '5', '7']</pre>
</div>
View Code</div>
\D匹配任何非数字字符，它相当于类[^0-9]
<div class="cnblogs_code"><img id="code_img_closed_28957160-dd9e-4ea0-8ed0-a379e24a7a41" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_28957160-dd9e-4ea0-8ed0-a379e24a7a41" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_28957160-dd9e-4ea0-8ed0-a379e24a7a41" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("\D", "匹配规则这2个字符串3是否匹配规则5则则则7则") #\D匹配任何非数字字符，它相当于类[^0-9]
print(a)#以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']</pre>
</div>
View Code</div>
\s匹配任何空白字符，它相当于类[\t\n\r\f\v]
<div class="cnblogs_code"><img id="code_img_closed_80796e6e-9131-4da4-9ba5-fd78c0336e48" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_80796e6e-9131-4da4-9ba5-fd78c0336e48" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_80796e6e-9131-4da4-9ba5-fd78c0336e48" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("\s", "匹配规则这2个字符串3是否匹\n配规则5则则则7则") #\s匹配任何空白字符，它相当于类[\t\n\r\f\v]
print(a)#以列表形式返回匹配到的字符串
#打印出[' ', ' ', ' ', '\n']</pre>
</div>
View Code</div>
\S匹配任何非空白字符，它相当于类[^\t\n\r\f\v]
<div class="cnblogs_code"><img id="code_img_closed_ecf991a8-9ff4-4cf3-8d38-ddd4f5f5ff00" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_ecf991a8-9ff4-4cf3-8d38-ddd4f5f5ff00" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_ecf991a8-9ff4-4cf3-8d38-ddd4f5f5ff00" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("\S", "匹配规则这2个字符串3是否匹\n配规则5则则则7则") #\S匹配任何非空白字符，它相当于类[^\t\n\r\f\v]
print(a)#以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '规', '则', '这', '2', '个', '字', '符', '串', '3', '是', '否', '匹', '配', '规', '则', '5', '则', '则', '则', '7', '则']</pre>
</div>
View Code</div>
\w匹配包括下划线在内任何字母数字字符，它相当于类
<div class="cnblogs_code"><img id="code_img_closed_850877de-6af7-4138-9fb4-c7de23f72370" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_850877de-6af7-4138-9fb4-c7de23f72370" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_850877de-6af7-4138-9fb4-c7de23f72370" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re #第一步，要引入re模块
a = re.findall('\w',"https://www.cnblogs.com/")#\w匹配包括下划线在内任何字母数字字符，它相当于类
print(a)#以列表形式返回匹配到的字符串
#打印出 ['h', 't', 't', 'p', 's', 'w', 'w', 'w', 'c', 'n', 'b', 'l', 'o', 'g', 's', 'c', 'o', 'm']</pre>
</div>
View Code</div>
\W匹配非任何字母数字字符包括下划线在内，它相当于类[^a-zA-Z0-9_]
<div class="cnblogs_code"><img id="code_img_closed_50a11bce-a96c-4b47-8da4-8014231b6df9" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_50a11bce-a96c-4b47-8da4-8014231b6df9" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_50a11bce-a96c-4b47-8da4-8014231b6df9" class="cnblogs_code_hide">
<pre>import re #第一步，要引入re模块
a = re.findall('\W',"https://www.cnblogs.com/")#\w匹配包括下划线在内任何字母数字字符，它相当于类
print(a)#以列表形式返回匹配到的字符串
#打印出[':', '/', '/', '.', '.', '/']</pre>
</div>
View Code</div>
()元字符，分组
也就是分组匹配，()里面的为一个组也可以理解成一个整体
如果()后面跟的是特殊元字符如   (adc)*   那么*控制的前导字符就是()里的整体内容，不再是前导一个字符
列1
<div class="cnblogs_code"><img id="code_img_closed_4b865012-8bd0-4caf-ad0d-d03abaed4697" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_4b865012-8bd0-4caf-ad0d-d03abaed4697" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_4b865012-8bd0-4caf-ad0d-d03abaed4697" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re #第一步，要引入re模块
#也就是分组匹配，()里面的为一个组也可以理解成一个整体
a = re.search("(a4)+", "a4a4a4a4a4dg4g654gb") #匹配一个或多个a4
b = a.group()
print(b)
#打印出 a4a4a4a4a4</pre>
</div>
View Code</div>
 列2
<div class="cnblogs_code"><img id="code_img_closed_d9e2b9e5-901e-4cbe-90ea-116547487e3c" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_d9e2b9e5-901e-4cbe-90ea-116547487e3c" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_d9e2b9e5-901e-4cbe-90ea-116547487e3c" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re #第一步，要引入re模块
#也就是分组匹配，()里面的为一个组也可以理解成一个整体
a = re.search("a(\d+)", "a466666664a4a4a4dg4g654gb") #匹配 (a) (\d0-9的数字) (+可以是1个到多个0-9的数字)
b = a.group()
print(b)
#打印出 a466666664</pre>
</div>
View Code</div>
 
|元字符，或
|或，或就是前后其中一个符合就匹配
<div class="cnblogs_code"><img id="code_img_closed_1614573b-17bb-4f77-84e8-5f32146bc3a3" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_1614573b-17bb-4f77-84e8-5f32146bc3a3" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_1614573b-17bb-4f77-84e8-5f32146bc3a3" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re #第一步，要引入re模块
a = re.findall(r"你|好", "a4a4a你4aabc4a4dgg好dg4g654g") #|或，或就是前后其中一个符合就匹配
print(a)
#打印出 ['你', '好']</pre>
</div>
View Code</div>
 
r原生字符
将在python里有特殊意义的字符如\b，转换成原生字符（就是去除它在python的特殊意义），不然会给正则表达式有冲突，为了避免这种冲突可以在规则前加原始字符r
 
<h2>re模块中常用功能函数</h2>
正则表达式有两种书写方式，一种是直接在函数里书写规则，
<div class="cnblogs_code"><img id="code_img_closed_47873858-1f9b-4b42-a062-173399f6ff56" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_47873858-1f9b-4b42-a062-173399f6ff56" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_47873858-1f9b-4b42-a062-173399f6ff56" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re #第一步，要引入re模块
a = re.findall("匹配规则", "这个字符串是否有匹配规则的字符") #第二步，调用模块函数
print(a)#以列表形式返回匹配到的字符串
#打印出 ['匹配规则']</pre>
</div>
View Code</div>
match()函数（以后常用）
match，从头匹配一个符合规则的字符串，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None match(pattern, string, flags=0) # pattern：正则模型 # string ：要匹配的字符串 # falgs ：匹配模式
注意：match()函数与 search()函数基本是一样的功能，不一样的就是match()匹配字符串开始位置的一个符合规则的字符串，search()是在字符串全局匹配第一个合规则的字符串
<div class="cnblogs_code"><img id="code_img_closed_391c8da3-42d8-4481-abef-1e42d7d6abaf" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_391c8da3-42d8-4481-abef-1e42d7d6abaf" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_391c8da3-42d8-4481-abef-1e42d7d6abaf" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
origin = "hello egon bcd egon lge egon acd 19"
r = re.match("h\w+", origin) #match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
#输出结果
# hello 匹配到的全部拿出来
# () 没有分组所以为空
# {} 没分组部分定义了key的组所以为空

# 有分组
# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
r = re.match("h(\w+)", origin) #match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
#输出结果
# hello 匹配到的全部拿出来
# ('ello',) 有分组，在匹配到的字符串中拿出分组的部分
# {} 没分组部分定义了key的组所以为空

# 有两个分组定义了key
# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
r = re.match("(?P<n1>h)(?P<n2>\w+)", origin) #?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容
print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
#输出结果
# hello 匹配到的全部拿出来
# ('h', 'ello') 有分组，在匹配到的字符串中拿出分组的部分
# {'n1': 'h', 'n2': 'ello'} 有定义了key的组所以，将定义了key的组里的内容以字典形式拿出来</pre>
</div>
View Code</div>
?P<n1>  #?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容（只对正则函数返回对象的有用）
取出匹配对象方法
只对正则函数返回对象的有用
group() # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来，有参取匹配到的第几个如2 groups() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果 groupdict() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
 
 
search()函数 search,浏览全部字符串，匹配第一符合规则的字符串，浏览整个字符串去匹配第一个，未匹配成功返回None search(pattern, string, flags=0) # pattern：正则模型 # string ：要匹配的字符串 # falgs ：匹配模式
注意：match()函数与 search()函数基本是一样的功能，不一样的就是match()匹配字符串开始位置的一个符合规则的字符串，search()是在字符串全局匹配第一个合规则的字符串
<div class="cnblogs_code"><img id="code_img_closed_87441fc1-2e1b-4e6c-9281-96a6574aca5c" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_87441fc1-2e1b-4e6c-9281-96a6574aca5c" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_87441fc1-2e1b-4e6c-9281-96a6574aca5c" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
origin = "hello alex bcd alex lge alex acd 19"
r = re.search("a\w+", origin) #search浏览全部字符串，匹配第一符合规则的字符串，浏览整个字符串去匹配第一个，未匹配成功返回None
print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
#输出结果
# alex 匹配到的全部拿出来
# () 没有分组所以为空
# {} 没分组部分定义了key的组所以为空

# 有分组
# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
r = re.search("a(\w+).*(\d)", origin)
print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
#输出结果
# alex bcd alex lge alex acd 19 匹配到的全部拿出来
# ('lex', '9') 有分组，在匹配到的字符串中拿出分组的部分
# {} 没分组部分定义了key的组所以为空

# 有两个分组定义了key
# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
r = re.search("a(?P<n1>\w+).*(?P<n2>\d)", origin) #?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容
print(r.group()) # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
#输出结果
# alex bcd alex lge alex acd 19 匹配到的全部拿出来
# ('lex', '9') 有分组，在匹配到的字符串中拿出分组的部分
# {'n1': 'lex', 'n2': '9'} 有定义了key的组所以，将定义了key的组里的内容以字典形式拿出来</pre>
</div>
View Code</div>
findall()函数（以后常用）
findall(pattern, string, flags=0) # pattern：正则模型 # string ：要匹配的字符串 # falgs ：匹配模式
浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中，未匹配成功返回空列表
注意：一旦匹配成，再次匹配，是从前一次匹配成功的，后面一位开始的，也可以理解为匹配成功的字符串，不在参与下次匹配
<div class="cnblogs_code"><img id="code_img_closed_e90108ed-a2ed-4e72-b10b-1b22b14bb7b9" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_e90108ed-a2ed-4e72-b10b-1b22b14bb7b9" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_e90108ed-a2ed-4e72-b10b-1b22b14bb7b9" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
r = re.findall("\d+\w\d+", "a2b3c4d5") #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中
print(r)
#输出结果
#['2b3', '4d5']
#注意：匹配成功的字符串，不在参与下次匹配,所以3c4也符合规则但是没匹配到</pre>
</div>
View Code</div>
 注意：如果没写匹配规则，也就是空规则，返回的是一个比原始字符串多一位的，空字符串列表
<div class="cnblogs_code"><img id="code_img_closed_39217207-46a2-44d9-a520-1e9fd7a8e40c" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_39217207-46a2-44d9-a520-1e9fd7a8e40c" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_39217207-46a2-44d9-a520-1e9fd7a8e40c" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
r = re.findall("", "a2b3c4d5") #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中
print(r)
#输出结果
#['', '', '', '', '', '', '', '', '']
#注意：如果没写匹配规则，也就是空规则，返回的是一个比原始字符串多一位的，空字符串列表 </pre>
</div>
View Code</div>
<pre></pre>
注意：正则匹配到空字符的情况，如果规则里只有一个组，而组后面是*就表示组里的内容可以是0个或者多过，这样组里就有了两个意思，一个意思是匹配组里的内容，二个意思是匹配组里0内容（即是空白）所以尽量避免用*否则会有可能匹配出空字符串
注意：正则只拿组里最后一位，如果规则里只有一个组，匹配到的字符串里在拿组内容是，拿的是匹配到的内容最后一位
<div class="cnblogs_code"><img id="code_img_closed_d9eddb69-9baa-4adc-82e8-dcac99a458a5" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_d9eddb69-9baa-4adc-82e8-dcac99a458a5" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_d9eddb69-9baa-4adc-82e8-dcac99a458a5" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)*", origin)
print(r)
#输出结果 ['', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', 'a', '', '', '', '', '', '']</pre>
</div>
View Code</div>
<pre> 无分组：匹配所有合规则的字符串，匹配到的字符串放到一个列表中 </pre>
<div class="cnblogs_code"><img id="code_img_closed_2611c652-bb72-47f2-8a82-ad841d635f39" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_2611c652-bb72-47f2-8a82-ad841d635f39" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_2611c652-bb72-47f2-8a82-ad841d635f39" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("a\w+", origin) #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中
print(r)
#输出结果
#['alex', 'alex', 'alex', 'acd']
#匹配所有合规则的字符串，匹配到的字符串放到一个列表中</pre>
</div>
View Code</div>
<pre> </pre>
有分组：只将匹配到的字符串里，组的部分放到列表里返回，相当于groups()方法
<div class="cnblogs_code"><img id="code_img_closed_65a4cc61-9ae5-4617-8211-d4b69ca40485" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_65a4cc61-9ae5-4617-8211-d4b69ca40485" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_65a4cc61-9ae5-4617-8211-d4b69ca40485" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("a(\w+)", origin) #有分组：只将匹配到的字符串里，组的部分放到列表里返回
print(r)
#输出结果
#['lex', 'lex', 'lex', 'cd']</pre>
</div>
View Code</div>
 多个分组：只将匹配到的字符串里，组的部分放到一个元组中，最后将所有元组放到一个列表里返
相当于在group()结果里再将组的部分，分别，拿出来放入一个元组，最后将所有元组放入一个列表返回
<div class="cnblogs_code"><img id="code_img_closed_ae5eeec9-7b42-4bb8-b6c7-e6855fadf5c8" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_ae5eeec9-7b42-4bb8-b6c7-e6855fadf5c8" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_ae5eeec9-7b42-4bb8-b6c7-e6855fadf5c8" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)(\w+)", origin) #多个分组：只将匹配到的字符串里，组的部分放到一个元组中，最后将所有元组放到一个列表里返回
print(r)
#输出结果
#[('a', 'lex'), ('a', 'lex'), ('a', 'lex'), ('a', 'cd')]</pre>
</div>
View Code</div>
 分组中有分组：只将匹配到的字符串里，组的部分放到一个元组中，先将包含有组的组，看作一个整体也就是一个组，把这个整体组放入一个元组里，然后在把组里的组放入一个元组，最后将所有组放入一个列表返回
<div class="cnblogs_code"><img id="code_img_closed_0e3b19ce-2020-41f0-86b3-4009cd1cca5a" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_0e3b19ce-2020-41f0-86b3-4009cd1cca5a" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_0e3b19ce-2020-41f0-86b3-4009cd1cca5a" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)(\w+(e))", origin) #分组中有分组：只将匹配到的字符串里，组的部分放到一个元组中，先将包含有组的组，看作一个整体也就是一个组，把这个整体组放入一个元组里，然后在把组里的组放入一个元组，最后将所有组放入一个列表返回
print(r)
#输出结果
#[('a', 'le', 'e'), ('a', 'le', 'e'), ('a', 'le', 'e')]</pre>
</div>
View Code</div>
<pre>?:在有分组的情况下findall()函数，不只拿分组里的字符串，拿所有匹配到的字符串，注意?:只用于不是返回正则对象的函数如findall() </pre>
<div class="cnblogs_code"><img id="code_img_closed_8a65c93c-fd2d-4729-9a97-58d7b80d2f94" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_8a65c93c-fd2d-4729-9a97-58d7b80d2f94" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_8a65c93c-fd2d-4729-9a97-58d7b80d2f94" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
b = re.findall("a(?:\w+)",origin) #?:在有分组的情况下，不只拿分组里的字符串，拿所有匹配到的字符串，注意?:只用于不是返回正则对象的函数如findall()
print(b)
#输出
# ['alex', 'alex', 'alex', 'acd']</pre>
</div>
View Code</div>
<pre></pre>
 
split()函数
根据正则匹配分割字符串，返回分割后的一个列表
<code class="python plain">split(pattern, string, maxsplit</code><code class="python keyword">=</code><code class="python value">0</code><code class="python plain">, flags</code><code class="python keyword">=</code><code class="python value">0</code><code class="python plain">)</code>
<div class="line number4 index3 alt1"><code class="python comments"># pattern：正则模型</code></div>
<div class="line number5 index4 alt2"><code class="python comments"># string ：要匹配的字符串</code></div>
<div class="line number6 index5 alt1"><code class="python comments"># maxsplit：指定分割个数</code></div>
<div class="line number7 index6 alt2"><code class="python comments"># flags  ：匹配模式</code></div>
<div class="line number7 index6 alt2"> </div>
<div class="line number7 index6 alt2">按照一个字符将全部字符串进行分割</div>
<div class="line number7 index6 alt2">
<div class="cnblogs_code"><img id="code_img_closed_55a7f3f5-796d-4632-b8b9-9ee2fb1eedaf" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_55a7f3f5-796d-4632-b8b9-9ee2fb1eedaf" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_55a7f3f5-796d-4632-b8b9-9ee2fb1eedaf" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.split("a", origin) #根据正则匹配分割字符串
print(r)
#输出结果 ['hello ', 'lex bcd ', 'lex lge ', 'lex ', 'cd 19']
#根据a进行分组</pre>
</div>
View Code</div>
</div>
<div class="line number7 index6 alt2">
将匹配到的字符串作为分割标准进行分割
<div class="cnblogs_code"><img id="code_img_closed_a51b39e2-05a5-4413-8887-53ff73101aec" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_a51b39e2-05a5-4413-8887-53ff73101aec" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_a51b39e2-05a5-4413-8887-53ff73101aec" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex 2acd 19"
r = re.split("a\w+", origin) #根据正则匹配分割字符串
print(r)
#输出结果 ['hello ', ' bcd ', ' lge ', ' 2', ' 19']
#将匹配到的字符串作为分割标准进行分割</pre>
</div>
View Code</div>
 sub()函数
替换匹配成功的指定位置字符串
<code class="python plain">sub(pattern, repl, string, count</code><code class="python keyword">=</code><code class="python value">0</code><code class="python plain">, flags</code><code class="python keyword">=</code><code class="python value">0</code><code class="python plain">)</code>
<div class="line number4 index3 alt1"><code class="python comments"># pattern：正则模型</code></div>
<div class="line number5 index4 alt2"><code class="python comments"># repl   ：要替换的字符串</code></div>
<div class="line number6 index5 alt1"><code class="python comments"># string ：要匹配的字符串</code></div>
<div class="line number7 index6 alt2"><code class="python comments"># count  ：指定匹配个数</code></div>
<div class="line number8 index7 alt1"><code class="python comments"># flags  ：匹配模式</code></div>
<div class="line number8 index7 alt1">
<div class="cnblogs_code"><img id="code_img_closed_0c973c27-2d76-4f8f-a973-587b20420849" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_0c973c27-2d76-4f8f-a973-587b20420849" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_0c973c27-2d76-4f8f-a973-587b20420849" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.sub("a","替换",origin) #替换匹配成功的指定位置字符串
print(r)
#输出
# hello 替换lex bcd 替换lex lge 替换lex 替换cd 19</pre>
</div>
View Code</div>
</div>
<div class="line number8 index7 alt1">
 
subn()函数
替换匹配成功的指定位置字符串,并且返回替换次数，可以用两个变量分别接受
<code class="python plain">subn(pattern, repl, string, count</code><code class="python keyword">=</code><code class="python value">0</code><code class="python plain">, flags</code><code class="python keyword">=</code><code class="python value">0</code><code class="python plain">)</code>
<div class="line number4 index3 alt1"><code class="python comments"># pattern：正则模型</code></div>
<div class="line number5 index4 alt2"><code class="python comments"># repl   ：要替换的字符串</code></div>
<div class="line number6 index5 alt1"><code class="python comments"># string ：要匹配的字符串</code></div>
<div class="line number7 index6 alt2"><code class="python comments"># count  ：指定匹配个数</code></div>
<div class="line number8 index7 alt1"><code class="python comments"># flags  ：匹配模式</code></div>
<div class="line number8 index7 alt1">
<div class="cnblogs_code"><img id="code_img_closed_eab094fd-4d86-4b6f-b30a-090e5bd4978e" class="code_img_closed" src="https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif" alt=""><img id="code_img_opened_eab094fd-4d86-4b6f-b30a-090e5bd4978e" class="code_img_opened" style="display: none" src="https://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif" alt="">
<div id="cnblogs_code_open_eab094fd-4d86-4b6f-b30a-090e5bd4978e" class="cnblogs_code_hide">
<pre>#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
a,b = re.subn("a","替换",origin) #替换匹配成功的指定位置字符串,并且返回替换次数，可以用两个变量分别接受
print(a)
print(b)
#输出
# hello 替换lex bcd 替换lex lge 替换lex 替换cd 19
# 4</pre>
</div>
View Code</div>
</div>
<div class="line number8 index7 alt1">
 
元字符表
<table border="1" cellspacing="0" cellpadding="0">
<tbody>
<tr>
<td valign="top">
.
</td>
<td valign="top">
需要字符串里完全符合，匹配规则，就匹配，（规则里的.元字符）可以是任何一个字符，匹配任意除换行符"\n"外的字符(在DOTALL模式中也能匹配换行符)
</td>
<td valign="top">
a.c
</td>
<td valign="top">
abc
</td>
</tr>
<tr>
<td valign="top">
\
</td>
<td valign="top">
1.反斜杠后边跟元字符去除特殊功能；（即将特殊字符转义成普通字符），2.反斜杠后边跟普通字符实现特殊功能；（即预定义字符），3.\2引用序号对应的字组
</td>
<td valign="top">
a\.c;a\\c
</td>
<td valign="top">
a.c;a\c
</td>
</tr>
<tr>
<td valign="top">
*
</td>
<td valign="top">
需要字符串里完全符合，匹配规则，就匹配，（规则里的*元字符）前面的一个字符可以是0个或多个原本字符，匹配前一个字符0或多次，贪婪匹配前导字符有多少个就匹配多少个很贪婪，如果规则里只有一个分组，尽量避免用*否则会有可能匹配出空字符串
</td>
<td valign="top">
abc*
</td>
<td valign="top">
ab;abccc
</td>
</tr>
<tr>
<td valign="top">
+
</td>
<td valign="top">
需要字符串里完全符合，匹配规则，就匹配，（规则里的+元字符）前面的一个字符可以是1个或多个原本字符，匹配前一个字符1次或无限次，贪婪匹配前导字符有多少个就匹配多少个很贪婪
</td>
<td valign="top">
abc+
</td>
<td valign="top">
abc;abccc
</td>
</tr>
<tr>
<td valign="top">
?
</td>
<td valign="top">
需要字符串里完全符合，匹配规则，就匹配，（规则里的?元字符）前面的一个字符可以是0个或1个原本字符，匹配一个字符0次或1次，还有一个功能是可以防止贪婪匹配，详情见防贪婪匹配
</td>
<td valign="top">
abc?
</td>
<td valign="top">
ab;abc
</td>
</tr>
<tr>
<td valign="top">
^
</td>
<td valign="top">
<pre>字符串开始位置与匹配规则符合就匹配，否则不匹配，匹配字符串开头。在多行模式中匹配每一行的开头，^元字符如果写到[]字符集里就是反取</pre>
</td>
<td valign="top">
^abc
</td>
<td valign="top">
abc
</td>
</tr>
<tr>
<td valign="top">
$
</td>
<td valign="top">
字符串结束位置与匹配规则符合就匹配，否则不匹配，匹配字符串末尾，在多行模式中匹配每一行的末尾
</td>
<td valign="top">
abc$
</td>
<td valign="top">
abc
</td>
</tr>
<tr>
<td valign="top">
|
</td>
<td valign="top">
|或，或就是前后其中一个符合就匹配
</td>
<td valign="top">
abc|def
</td>
<td valign="top">
abc
def
</td>
</tr>
<tr>
<td valign="top">
{}
</td>
<td valign="top">
需要字符串里完全符合，匹配规则，就匹配，（规则里的 {} 元字符）前面的一个字符，是自定义字符数，位数的原本字符，{m}匹配前一个字符m次，{m,n}匹配前一个字符m至n次，若省略n，则匹配m至无限次，{0,}匹配前一个字符0或多次,等同于*元字符，{+,}匹配前一个字符1次或无限次,等同于+元字符，{0,1}匹配前一个字符0次或1次,等同于?元字符
</td>
<td valign="top">
ab{1,2}c
</td>
<td valign="top">
abc
abbc
</td>
</tr>
<tr>
<td valign="top">
[]
</td>
<td valign="top">
需要字符串里完全符合，匹配规则，就匹配，（规则里的 [] 元字符）对应位置是[]里的任意一个字符就匹配，字符集。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，如或。[^abc]表示取反，即非abc。所有特殊字符在字符集中都失去其原有的特殊含义。用\反斜杠转义恢复特殊字符的特殊含义。
</td>
<td valign="top">
ae
</td>
<td valign="top">
abe
ace
ade
 
</td>
</tr>
<tr>
<td valign="top">
()
</td>
<td valign="top">
也就是分组匹配，()里面的为一个组也可以理解成一个整体，如果()后面跟的是特殊元字符如   (adc)*   那么*控制的前导字符就是()里的整体内容，不再是前导一个字符
</td>
<td valign="top">
(abc){2} a(123|456)c

</td>
<td valign="top">
abcabc
a456c

</td>

</tr>

</tbody>

</table>
预定义字符集表，可以写在字符集[...]中 
<table border="1" cellspacing="0" cellpadding="0">
<tbody>
<tr>
<td valign="top">
\d

</td>
<td valign="top">
\d匹配任何十进制数，它相当于类，\d+如果需要匹配一位或者多位数的数字时用

</td>
<td valign="top">
a\bc

</td>
<td valign="top">
a1c

</td>

</tr>
<tr>
<td valign="top">
\D

</td>
<td valign="top">
\D匹配任何非数字字符，它相当于类[^0-9]

</td>
<td valign="top">
a\Dc

</td>
<td valign="top">
abc

</td>

</tr>
<tr>
<td valign="top">
\s

</td>
<td valign="top">
\s匹配任何空白字符，它相当于类[\t\n\r\f\v]

</td>
<td valign="top">
a\sc

</td>
<td valign="top">
a c

</td>

</tr>
<tr>
<td valign="top">
\S

</td>
<td valign="top">
\S匹配任何非空白字符，它相当于类[^\t\n\r\f\v]

</td>
<td valign="top">
a\Sc

</td>
<td valign="top">
abc

</td>

</tr>
<tr>
<td valign="top">
\w

</td>
<td valign="top">
\w匹配包括下划线在内任何字母数字字符，它相当于类

</td>
<td valign="top">
a\wc

</td>
<td valign="top">
abc

</td>

</tr>
<tr>
<td valign="top">
\W

</td>
<td valign="top">
\W匹配非任何字母数字字符包括下划线在内，它相当于类[^a-zA-Z0-9_]

</td>
<td valign="top">
a\Wc

</td>
<td valign="top">
a c

</td>

</tr>
<tr>
<td valign="top">
\A

</td>
<td valign="top">
仅匹配字符串开头,同^

</td>
<td valign="top">
\Aabc

</td>
<td valign="top">
abc

</td>

</tr>
<tr>
<td valign="top">
\Z

</td>
<td valign="top">
仅匹配字符串结尾，同$

</td>
<td valign="top">
abc\Z

</td>
<td valign="top">
abc

</td>

</tr>
<tr>
<td valign="top">
\b

</td>
<td valign="top">
b匹配一个单词边界，也就是指单词和空格间的位置

</td>
<td valign="top">
\babc\b a\b!bc

</td>
<td valign="top">
空格abc空格 a!bc

</td>

</tr>
<tr>
<td valign="top">
\B

</td>
<td valign="top">
[^\b]

</td>
<td valign="top">
a\Bbc

</td>
<td valign="top">
abc

</td>

</tr>

</tbody>

</table>
 
特殊分组用法表：只对正则函数返回对象的有用
<table border="1" cellspacing="0" cellpadding="0">
<tbody>
<tr>
<td valign="top">
(?P<name>)

</td>
<td valign="top">
?P<>定义组里匹配内容的key(键)，<>里面写key名称，值就是匹配到的内容，在用groupdict()方法打印字符串

</td>
<td valign="top">
(?P<id>abc){2}

</td>
<td valign="top">
abcabc

</td>

</tr>
<tr>
<td valign="top">
(?P=name)

</td>
<td valign="top">
引用别名为<name>的分组匹配到字符串

</td>
<td valign="top">
(?P<id>\d)abc(?P=id)

</td>
<td valign="top">
1abc1
5abc5

</td>

</tr>
<tr>
<td valign="top">
\<number>

</td>
<td valign="top">
引用编号为<number>的分组匹配到字符串

</td>
<td valign="top">
(\d)abc\1

</td>
<td valign="top">
1abc1
5abc5

</td>

</tr>

</tbody>

</table>

</div>

</div>
 
正则匹配模式表
<table border="1" cellspacing="0" cellpadding="0">
<tbody>
<tr>
<td valign="top">
标志

</td>
<td valign="top">
含义

</td>

</tr>
<tr>
<td valign="top">
re.S(DOTALL)

</td>
<td valign="top">
使.匹配包括换行在内的所有字符

</td>

</tr>
<tr>
<td valign="top">
re.I（IGNORECASE）

</td>
<td valign="top">
使匹配对大小写不敏感

</td>

</tr>
<tr>
<td valign="top">
re.L（LOCALE）

</td>
<td valign="top">
做本地化识别（locale-aware)匹配，法语等

</td>

</tr>
<tr>
<td valign="top">
re.M(MULTILINE)

</td>
<td valign="top">
多行匹配，影响^和$

</td>

</tr>
<tr>
<td valign="top">
re.X(VERBOSE)

</td>
<td valign="top">
该标志通过给予更灵活的格式以便将正则表达式写得更易于理解

</td>

</tr>
<tr>
<td valign="top">
re.U

</td>
<td valign="top">
根据Unicode字符集解析字符，这个标志影响\w,\W,\b,\B

</td>

</tr>

</tbody>

</table>
 
正则表达式重点
一、
r原生字符
将在python里有特殊意义的字符如\b，转换成原生字符（就是去除它在python的特殊意义），不然会给正则表达式有冲突，为了避免这种冲突可以在规则前加原始字符r
 
二、
正则表达式，返回类型为表达式对象的
如：<_sre.SRE_Match object; span=(6, 7), match='a'>  
返回对象的，需要用正则方法取字符串，
方法有
group() # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来，有参取匹配到的第几个如2 groups() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果 groupdict() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了key的组结果
 
三、
匹配到的字符串里出现空字符
注意：正则匹配到空字符的情况，如果规则里只有一个组，而组后面是*就表示组里的内容可以是0个或者多过，这样组里就有了两个意思，一个意思是匹配组里的内容，二个意思是匹配组里0内容（即是空白）所以尽量避免用*否则会有可能匹配出空字符串

</div>
 
四、
()分组
注意：分组的意义，就是在匹配成功的字符串中，在提取()里，组里面的字符串
 
五、
 
<pre>?:在有分组的情况下findall()函数，不只拿分组里的字符串，拿所有匹配到的字符串，注意?:只用于不是返回正则对象的函数如findall()</pre>
</div>

</div>
<div id="MySignature" role="contentinfo">
<div>请尊重笔者的劳动成果哦，转载请说明出处哦 </div> 
来源：https://www.cnblogs.com/gufengchen/p/10913186.html

頁: [1]

琼殿技术论坛's Archiver

python正则表达式findall的使用