正则表达式与RE库

Posted 2021-05-02 海的字码

前言

首先要明白什么是正则表达式?

正则表达式又称规则表达式，是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符及这些特定字符的组合，组成一个“规则字符串“，这个”规则“用来表达对字符串的一种过滤逻辑。通俗讲就是给定一个规则(模式)，然后根据这个规则去匹配文本。

常见的匹配模式

ps:上下滑动查看更多，高清原照后台回复：正则

查看re模块的功能信息

import re
print(re.__doc__)

re的主要功能函数

常用的功能函数包括：

compile、search、match、split、findall（finditer）、sub（subn）、escape等等。

re.match

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置就匹配成功的话，match()就返回None,即它返回从位置 0 开始有匹配的情况。
这个方法并不是完全匹配。当pattern结束时若string还有剩余字符，仍然视为成功。想要完全匹配，可以在表达式末尾加上边界匹配符'$'

语法格式：

re.match(pattern, string［, flags］)

flags： 编译标志位，用于修改正则表达式的匹配方式，如：是否区分大小写，多行匹配等。
编译标志：

• re.S(DOTALL)    使.匹配包括换行在内的所有字符

• re.I（IGNORECASE）   使匹配对大小写不敏感

• re.L（LOCALE）   做本地化识别（locale-aware)匹配，法语等,即让\w、\W、\b、\B、\s和\S依赖当前的locale。

• re.M(MULTILINE)   多行匹配，影响^和$

• re.X(VERBOSE)    该标志通过给予更灵活的格式以便将正则表达式写得更易于理解,即可以在规则中加#注释

• re.U   根据Unicode字符集解析字符，这个标志影响\w,\W,\b,\B

示例：

import re

string = 'hello world!! 123 ABC $9.99 +feg'
result = re.match('world',string)
print(result)

None

import re

string = 'hello world!! 123 ABC $9.99 +feg'
result1 = re.match('he.*!!\s(\d{2}).*B',string)  # 贪婪匹配
print(result1)
print(result1.group())
print(result1.group(1))

result2 = re.match('he.*?!!\s\d{3}\s\w\w\w\s\$\d\.\d\d',string)  # 非贪婪匹配: .任意字符 *零到多次 ?非贪婪
print(result2)
print(result2.group())

<_sre.SRE_Match object; span=(0, 20), match='hello world!! 123 AB'> hello world!! 123 AB12
<_sre.SRE_Match object; span=(0, 27), match='hello world!! 123 ABC $9.99'> hello world!! 123 ABC $9.99

re.search

re.search 扫描整个字符串并返回第一个成功的匹配,如果没有匹配的就返回None。

语法格式：

re.search(pattern, string[, flags])

示例：

import re

string = 'hello world!! 123 ABC $9.99 +feg'
result = re.search('!!\s(\d{2}).*?(BC).*?\.(\d+).*?f(\w)+',string)  # 贪婪匹配  #注：(\w)+只匹配最后一个字母g 
print(result)
print(result.group())
print(result.group(2))
print(result.group(1,2,3))
print(result.groups())

<_sre.SRE_Match object; span=(11, 32), match='!! 123 ABC $9.99 +feg'> !! 123 ABC $9.99 +feg BC ('12', 'BC', '99') ('12', 'BC', '99', 'g')

小结：为匹配方便，尽量用search而不用match

re.findall

搜索字符串，以列表形式返回全部能匹配的子串。

语法格式：

re.findall(pattern, string[, flags])

示例：

import re
string = '''
<ul id="list" class="list-group">
        <li>哈哈哈哈</li>
        <li data-view="1">
            <a href="/1.com" singer="one">123456789</a>
        </li>
        <li data-view="2" class="active">
            <a href="/2.com" singer="two">abc</a>
        </li>
        <li data-view="3"><a href="/4.com" singer="three">ABCDEF</a></li>
        <li data-view="4"><a href="/5.com" singer="four">000000</a></li>
</ul>
'''
results = re.findall('<li.*?href="(.*?)".*?singer="(.*?)">(.*?)</a>', string, re.S)
print(results)
for result in results:
    print(result)
    print(result[0], result[1], result[2]))

略

re.finditer

与 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并组成一个迭代器返回。

语法格式：

re.finditer(pattern, string[, flags])

re.sub

在字符串 string 中找到匹配正则表达式 pattern 的所有子串，用另一个字符串 repl 进行替换。如果没有找到匹配 pattern 的串，则返回未被修改的 string。Repl 既可以是字符串也可以是一个函数。

语法格式：

re.sub(pattern, repl, string[, count, flags]) re.subn(pattern, repl, string[, count, flags]) 返回内容包括替换次数

示例：

import re

string = 'hello world!! 123 ABC $9.99 +feg'
result1 = re.sub('\d+', '换', string)
print(result1)
result2 = re.sub('\d', '换', string)
print(result2)
result3 = re.sub('(\d+)', r'\1换', string)  #模式处追加
print(result3)

hello world!! 换 ABC $换.换 +feg hello world!! 换换换 ABC $换.换换 +feg hello world!! 123换 ABC $9换.99换 +feg

注：零长度的匹配也会被替换

re.split

语法格式：

re.split(pattern, string[, maxsplit=0, flags=0])

将字符串匹配正则表达式的部分割开，并返回一个列表。

用匹配pattern的子串来分割string，如果pattern里使用了圆括号，那么被pattern匹配到的串也将作为返回值列表的一部分。如果maxsplit不为0，则最多被分割为maxsplit个子串，剩余部分将整个地被返回。
如果正则有圆括号，并且可以匹配到字符串的开始位置的时候，返回值的第一项，会多出一个空字符串。匹配到字符结尾也是同样的道理
注：split不会被零长度的正则所分割。

示例：

import re

string = 'A-B-C-D-F-G'
print(re.split(r'-',string))
print(re.split(r'(-)',string))
print(re.split(r'-',string,1))
print(re.split(r'-',string,2))
print(re.split(r'(-)',string,2))

['A', 'B', 'C', 'D', 'F', 'G'] ['A', '-', 'B', '-', 'C', '-', 'D', '-', 'F', '-', 'G'] ['A', 'B-C-D-F-G'] ['A', 'B', 'C-D-F-G'] ['A', '-', 'B', '-', 'C-D-F-G']

re.escape

把string中，除了字母和数字以外的字符，都加上反斜杆。

示例：

import re

string = '123 A - B @ C 456 # D % F (G) 789*'
print(re.escape(string))

123\ A\ \-\ B\ \@\ C\ 456\ \#\ D\ \%\ F\ \(G\)\ 789\*

re.escape

把正则表达式语法转化成正则表达式对象,以便于复用该匹配模式

语法格式：

re.compile(pattern[, flags])

示例：

  
    
    
  

   
     
     
   
import re

string = 'haha 123 world is cool'
pattern = re.compile('ha.*cool')
result = re.match(pattern, string)
print(result)
print(result.group())

  
    
    
  

<_sre.SRE_Match object; span=(0, 22), match='haha 123 world is cool'> haha 123 world is cool

content = '''haha 123 world is cool123456789 I am a haha,what?
666 haha 123 world is cool euiujkldmfhgfg85df5hg5j6fg6h8
tycv haha 123 world is coolsgsreg19---41f351**165sd'''

r_m = re.match(pattern, content)
print(r_m.group())

r_s = re.search(pattern,content)
print(r_s.group())

r_f = re.findall(pattern,content)
print(r_f)

r_fter = re.finditer(pattern,content)
print(r_fter)

haha 123 world is cool haha 123 world is cool ['haha 123 world is cool', 'haha 123 world is cool', 'haha 123 world is cool'] <callable_iterator object at 0x7fb03ceca160>

荐读：

- End -