正則表達式---python

正則表達式相關注解

開源中國提供的正則表達式測試工具

正則表達式常用模塊

模式	描述
\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
( )	匹配括號內的表達式，也表示一個組

正則表達式相關注解

（1）數量詞的貪婪模式與非貪婪模式正則表達式通常用於在文本中查找匹配的字符串。Python裏數量詞默認是貪婪的（在少數語言裏也可能是默認非貪婪），總是嘗試匹配儘可能多的字符；非貪婪的則相反，總是嘗試匹配儘可能少的字符。例如：正則表達式”ab”如果用於查找”abbbc”，將找到”abbb”。而如果使用非貪婪的數量詞”ab?”，將找到”a”。注：我們一般使用非貪婪模式來提取。

python中使用正則表達式

match()

這裏首先介紹第一個常用的匹配方法——match()，向它傳入要匹配的字符串以及正則表達式，就可以檢測這個正則表達式是否匹配字符串。
match()方法會嘗試從字符串的起始位置匹配正則表達式，如果匹配，就返回匹配成功的結果；如果不匹配，就返回None。示例如下：

  
  
  
   
   
   import re
   
   
   
   
   
   content = 'Hello 123 4567 World_This is a Regex Demo'
   
   
   print(len(content))
   
   
   result = re.match('^Hello\s\d\d\d\s\d{4}\s\w{10}', content)
   
   
   print(result)
   
   
   print(result.group())
   
   
   print(result.span())
   
   
   
   
   
   
   
   
   41
   
   
   <_sre.SRE_Match object; span=(0, 25), match='Hello 123 4567 World_This'>
   
   
   Hello 123 4567 World_This
   
   
   (0, 25)
   
   
   
   
   
   
   
   
   match()方法中，第一個參數傳入了正則表達式，第二個參數傳入了要匹配的字符串。
   
   
   
   
   
   打印輸出結果，可以看到結果是SRE_Match對象，這證明成功匹配。該對象有兩個方法：group()方法可以輸出匹配到的內容，結果是Hello 123 4567 World_This，這恰好是正則表達式規則所匹配的內容；span()方法可以輸出匹配的範圍，結果是(0, 25)，這就是匹配到的結果字符串在原字符串中的位置範圍

匹配目標

剛纔我們用match()方法可以得到匹配到的字符串內容，但是如果想從字符串中提取一部分內容，該怎麼辦呢？就像最前面的實例一樣，從一段文本中提取出郵件或電話號碼等內容。
這裏可以使用()括號將想提取的子字符串括起來。()實際上標記了一個子表達式的開始和結束位置，被標記的每個子表達式會依次對應每一個分組，調用group()方法傳入分組的索引即可獲取提取的結果。示例如下：

  
  
  
   
   
   import re
   
   
   
   
   
   content = 'Hello 1234567 World_This is a Regex Demo'
   
   
   result = re.match('^Hello\s(\d+)\sWorld', content)
   
   
   print(result)
   
   
   print(result.group())
   
   
   print(result.group(1))
   
   
   print(result.span())
   
   
   
   
   
   
   
   
   <_sre.SRE_Match object; span=(0, 19), match='Hello 1234567 World'>
   
   
   Hello 1234567 World
   
   
   1234567
   
   
   (0, 19)
   
   
   
   
   
   可以看到，我們成功得到了1234567。這裏用的是group(1)，它與group()有所不同，後者會輸出完整的匹配結果，而前者會輸出第一個被()包圍的匹配結果。假如正則表達式後面還有()包括的內容，那麼可以依次用group(2)、group(3)等來獲取。

通用匹配

剛纔我們寫的正則表達式其實比較複雜，出現空白字符我們就寫\s匹配，出現數字我們就用\d匹配，這樣的工作量非常大。其實完全沒必要這麼做，因爲還有一個萬能匹配可以用，那就是.（點星）。其中.（點）可以匹配任意字符（除換行符），（星）代表匹配前面的字符無限次，所以它們組合在一起就可以匹配任意字符了。有了它，我們就不用挨個字符地匹配了。
接着上面的例子，我們可以改寫一下正則表達式：

  
  
  
   
   
   import re
   
   
   
   
   
   content = 'Hello 123 4567 World_This is a Regex Demo'
   
   
   result = re.match('^Hello.*Demo$', content)
   
   
   print(result)
   
   
   print(result.group())
   
   
   print(result.span())
   
   
   
   
   
   <_sre.SRE_Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
   
   
   Hello 123 4567 World_This is a Regex Demo
   
   
   (0, 41)
   
   
   
   
   
   可以看到，group()方法輸出了匹配的全部字符串，也就是說我們寫的正則表達式匹配到了目標字符串的全部內容；span()方法輸出(0, 41)，這是整個字符串的長度。

貪婪與非貪婪

使用上面的通用匹配.*時，可能有時候匹配到的並不是我們想要的結果。看下面的例子：

  
  
  
   
   
   import re
   
   
   
   
   
   content = 'Hello 1234567 World_This is a Regex Demo'
   
   
   result = re.match('^He.*(\d+).*Demo$', content)
   
   
   print(result)
   
   
   print(result.group(1))
   
   
   
   
   
   
   
   
   <_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
   
   
   7

奇怪的事情發生了，我們只得到了7這個數字，這是怎麼回事呢？

這裏就涉及一個貪婪匹配與非貪婪匹配的問題了。在貪婪匹配下，.會匹配儘可能多的字符。正則表達式中.後面是\d+，也就是至少一個數字，並沒有指定具體多少個數字，因此，.*就儘可能匹配多的字符，這裏就把123456匹配了，給\d+留下一個可滿足條件的數字7，最後得到的內容就只有數字7了。

但這很明顯會給我們帶來很大的不便。有時候，匹配結果會莫名其妙少了一部分內容。其實，這裏只需要使用非貪婪匹配就好了。非貪婪匹配的寫法是.*?，多了一個?，那麼它可以達到怎樣的效果？我們再用實例看一下：

  
  
  
   
   
   import re
   
   
   
   
   
   content = 'Hello 1234567 World_This is a Regex Demo'
   
   
   result = re.match('^He.*?(\d+).*Demo$', content)
   
   
   print(result)
   
   
   print(result.group(1))

這裏我們只是將第一個.改成了.?，轉變爲非貪婪匹配。結果如下：

  
  
  
   
   
   <_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
   
   
   1234567

此時就可以成功獲取1234567了。原因可想而知，貪婪匹配是儘可能匹配多的字符，非貪婪匹配就是儘可能匹配少的字符。當.?匹配到Hello後面的空白字符時，再往後的字符就是數字了，而\d+恰好可以匹配，那麼這裏.?就不再進行匹配，交給\d+去匹配後面的數字。所以這樣.*?匹配了儘可能少的字符，\d+的結果就是1234567了。

所以說，在做匹配的時候，字符串中間儘量使用非貪婪匹配，也就是用.?來代替.，以免出現匹配結果缺失的情況。

但這裏需要注意，如果匹配的結果在字符串結尾，.*?就有可能匹配不到任何內容了，因爲它會匹配儘可能少的字符。例如：

  
  
  
   
   
   import re
   
   
   
   
   
   content = 'http://weibo.com/comment/kEraCN'
   
   
   result1 = re.match('http.*?comment/(.*?)', content)
   
   
   result2 = re.match('http.*?comment/(.*)', content)
   
   
   print('result1', result1.group(1))
   
   
   print('result2', result2.group(1))
   
   
   
   
   
   #out
   
   
   
   
   
   result1 
   
   
   result2 kEraCN
   
   
   
   
   
   可以觀察到，.*?沒有匹配到任何結果，而.*則儘量匹配多的內容，成功得到了匹配結果。

修飾符

正則表達式可以包含一些可選標誌修飾符來控制匹配的模式。修飾符被指定爲一個可選的標誌。我們用實例來看一下

  
  
  
   
   
   import re
   
   
   
   
   
   content = '''Hello 1234567 World_This
   
   
   is a Regex Demo
   
   
   '''
   
   
   result = re.match('^He.*?(\d+).*?Demo$', content)
   
   
   print(result.group(1))

和上面的例子相仿，我們在字符串中加了換行符，正則表達式還是一樣的，用來匹配其中的數字。看一下運行結果：

  
  
  
   
   
   AttributeError Traceback (most recent call last)
   
   
   <ipython-input-18-c7d232b39645> in <module>()
   
   
         5 '''
   
   
         6 result = re.match('^He.*?(\d+).*?Demo$', content)
   
   
   ----> 7 print(result.group(1))
   
   
   
   
   
   AttributeError: 'NoneType' object has no attribute 'group'

運行直接報錯，也就是說正則表達式沒有匹配到這個字符串，返回結果爲None，而我們又調用了group()方法導致AttributeError。

那麼，爲什麼加了一個換行符，就匹配不到了呢？這是因爲.匹配的是除換行符之外的任意字符，當遇到換行符時，.*?就不能匹配了，所以導致匹配失敗。這裏只需加一個修飾符re.S，即可修正這個錯誤：

  
  
  
   
   
   result = re.match('^He.*?(\d+).*?Demo$', content, re.S)

這個修飾符的作用是使.匹配包括換行符在內的所有字符。此時運行結果如下：

修飾符	描述
re.I	使匹配對大小寫不敏感
re.L	做本地化識別（locale-aware）匹配
re.M	多行匹配，影響^和$
re.S	使.匹配包括換行在內的所有字符
re.U	根據Unicode字符集解析字符。這個標誌影響\w、\W、 \b和\B
re.X	該標誌通過給予你更靈活的格式以便你將正則表達式寫得更易於理解

轉義匹配

我們知道正則表達式定義了許多匹配模式，如.匹配除換行符以外的任意字符，但是如果目標字符串裏面就包含.，那該怎麼辦呢？

這裏就需要用到轉義匹配了，示例如下：

  
  
  
   
   
   import re
   
   
   
   
   
   content = '(百度)www.baidu.com'
   
   
   result = re.match('\(百度\)www\.baidu\.com', content)
   
   
   print(result)
   
   
   
   
   
   #當遇到用於正則匹配模式的特殊字符時，在前面加反斜線轉義一下即可。例如.就可以用\.來匹配，運行結果如下：    
   
   
   <<_sre.SRE_Match object; span=(0, 17), match='(百度)www.baidu.com'>

search()

前面提到過，match()方法是從字符串的開頭開始匹配的，一旦開頭不匹配，那麼整個匹配就失敗了。我們看下面的例子：

  
  
  
   
   
   import re
   
   
   
   
   
   content = 'Extra stings Hello 1234567 World_This is a Regex Demo Extra stings'
   
   
   result = re.match('Hello.*?(\d+).*?Demo', content)
   
   
   print(result)

這裏的字符串以Extra開頭，但是正則表達式以Hello開頭，整個正則表達式是字符串的一部分，但是這樣匹配是失敗的。運行結果如下：

這裏就有另外一個方法search()，它在匹配時會掃描整個字符串，然後返回第一個成功匹配的結果。也就是說，正則表達式可以是字符串的一部分，在匹配時，search()方法會依次掃描字符串，直到找到第一個符合規則的字符串，然後返回匹配內容，如果搜索完了還沒有找到，就返回None。
我們把上面代碼中的match()方法修改成search()，再看下運行結果：

  
  
  
   
   
   <_sre.SRE_Match object; span=(13, 53), match='Hello 1234567 World_This is a Regex Demo'>
   
   
   1234567

這時就得到了匹配結果。

因此，爲了匹配方便，我們可以儘量使用search()方法。

下面再用幾個實例來看看search()方法的用法。

首先，這裏有一段待匹配的HTML文本，接下來寫幾個正則表達式實例來實現相應信息的提取：

這時就得到了匹配結果。

因此，爲了匹配方便，我們可以儘量使用search()方法。

下面再用幾個實例來看看search()方法的用法。

首先，這裏有一段待匹配的HTML文本，接下來寫幾個正則表達式實例來實現相應信息的提取：

  
  
  
   
   
   html = '''<div id="songs-list">
   
   
       <h2 class="title">經典老歌</h2>
   
   
       <p class="introduction">
   
   
           經典老歌列表
   
   
       </p>
   
   
       <ul id="list" class="list-group">
   
   
           <li data-view="2">一路上有你</li>
   
   
           <li data-view="7">
   
   
               <a href="/2.mp3" singer="任賢齊">滄海一聲笑</a>
   
   
           </li>
   
   
           <li data-view="4" class="active">
   
   
               <a href="/3.mp3" singer="齊秦">往事隨風</a>
   
   
           </li>
   
   
           <li data-view="6"><a href="/4.mp3" singer="beyond">光輝歲月</a></li>
   
   
           <li data-view="5"><a href="/5.mp3" singer="陳慧琳">記事本</a></li>
   
   
           <li data-view="5">
   
   
               <a href="/6.mp3" singer="鄧麗君"><i class="fa fa-user"></i>但願人長久</a>
   
   
           </li>
   
   
       </ul>
   
   
   </div>'''

可以觀察到，ul節點裏有許多li節點，其中li節點中有的包含a節點，有的不包含a節點，a節點還有一些相應的屬性——超鏈接和歌手名。

首先，我們嘗試提取class爲active的li節點內部的超鏈接包含的歌手名和歌名，此時需要提取第三個li節點下a節點的singer屬性和文本。

此時正則表達式可以以li開頭，然後尋找一個標誌符active，中間的部分可以用.?來匹配。接下來，要提取singer這個屬性值，所以還需要寫入singer="(.?)"，這裏需要提取的部分用小括號括起來，以便用group()方法提取出來，它的兩側邊界是雙引號。然後還需要匹配a節點的文本，其中它的左邊界是>，右邊界是。然後目標內容依然用(.*?)來匹配，所以最後的正則表達式就變成了：

  
  
  
   
   
   <li.*?active.*?singer="(.*?)">(.*?)</a>
   
   
   result = re.search('<li.*?active.*?singer="(.*?)">(.*?)</a>', html, re.S)
   
   
   if result:
   
   
       print(result.group(1), result.group(2))

調用search()方法，它會搜索整個HTML文本，找到符合正則表達式的第一個內容返回。

另外，由於代碼有換行，所以這裏第三個參數需要傳入re.S。

可以看到，這正是class爲active的li節點內部的超鏈接包含的歌手名和歌名。

如果正則表達式不加active（也就是匹配不帶class爲active的節點內容），那會怎樣呢？我們將正則表達式中的active去掉，代碼改寫如下：

  
  
  
   
   
   result = re.search('<li.*?singer="(.*?)">(.*?)</a>', html, re.S)
   
   
   if result:
   
   
       print(result.group(1), result.group(2))

由於search()方法會返回第一個符合條件的匹配目標，這裏結果就變了：

  
  
  
   
   
   任賢齊 滄海一聲笑

把active標籤去掉後，從字符串開頭開始搜索，此時符合條件的節點就變成了第二個li節點，後面的就不再匹配，所以運行結果就變成第二個li節點中的內容。

注意，在上面的兩次匹配中，search()方法的第三個參數都加了re.S，這使得.*?可以匹配換行，所以含有換行的li節點被匹配到了。如果我們將其去掉，結果會是什麼？代碼如下：

  
  
  
   
   
   result = re.search('<li.*?singer="(.*?)">(.*?)</a>', html)
   
   
   if result:
   
   
       print(result.group(1), result.group(2))
   
   
   
   
   
   
   
   
   #beyondb  光輝歲月

可以看到，結果變成了第四個li節點的內容。這是因爲第二個和第三個li節點都包含了換行符，去掉re.S之後，.*?已經不能匹配換行符，所以正則表達式不會匹配到第二個和第三個li節點，而第四個li節點中不包含換行符，所以成功匹配。

由於絕大部分的HTML文本都包含了換行符，所以儘量都需要加上re.S修飾符，以免出現匹配不到的問題。

findall()

前面我們介紹了search()方法的用法，它可以返回匹配正則表達式的第一個內容，但是如果想要獲取匹配正則表達式的所有內容，那該怎麼辦呢？這時就要藉助findall()方法了。該方法會搜索整個字符串，然後返回匹配正則表達式的所有內容。

還是上面的HTML文本，如果想獲取所有a節點的超鏈接、歌手和歌名，就可以將search()方法換成findall()方法。如果有返回結果的話，就是列表類型，所以需要遍歷一下來依次獲取每組內容。代碼如下：

  
  
  
   
   
   results = re.findall('<li.*?href="(.*?)".*?singer="(.*?)">(.*?)</a>', html, re.S)
   
   
   print(results)
   
   
   print(type(results))
   
   
   for result in results:
   
   
       print(result)
   
   
       print(result[0], result[1], result[2])

  
  
  
   
   
   [('/2.mp3', '任賢齊', '滄海一聲笑'), ('/3.mp3', '齊秦', '往事隨風'), ('/4.mp3', 'beyond', '光輝歲月'), ('/5.mp3', '陳慧琳', '記事本'), ('/6.mp3', '鄧麗君', '但願人長久')]
   
   
   <class 'list'>
   
   
   ('/2.mp3', '任賢齊', '滄海一聲笑')
   
   
   /2.mp3 任賢齊 滄海一聲笑
   
   
   ('/3.mp3', '齊秦', '往事隨風')
   
   
   /3.mp3 齊秦 往事隨風
   
   
   ('/4.mp3', 'beyond', '光輝歲月')
   
   
   /4.mp3 beyond 光輝歲月
   
   
   ('/5.mp3', '陳慧琳', '記事本')
   
   
   /5.mp3 陳慧琳 記事本
   
   
   ('/6.mp3', '鄧麗君', '但願人長久')
   
   
   /6.mp3 鄧麗君 但願人長久

可以看到，返回的列表中的每個元素都是元組類型，我們用對應的索引依次取出即可。

如果只是獲取第一個內容，可以用search()方法。當需要提取多個內容時，可以用findall()方法。

sub()

除了使用正則表達式提取信息外，有時候還需要藉助它來修改文本。比如，想要把一串文本中的所有數字都去掉，如果只用字符串的replace()方法，那就太煩瑣了，這時可以藉助sub()方法。示例如下：

  
  
  
   
   
   import re
   
   
   
   
   
   content = '54aK54yr5oiR54ix5L2g'
   
   
   content = re.sub('\d+', '', content)
   
   
   print(content)
   
   
   #1aKyroiRixLg

這裏只需要給第一個參數傳入\d+來匹配所有的數字，第二個參數爲替換成的字符串（如果去掉該參數的話，可以賦值爲空），第三個參數是原字符串。

在上面的HTML文本中，如果想獲取所有li節點的歌名，直接用正則表達式來提取可能比較煩瑣。比如，可以寫成這樣子：

  
  
  
   
   
   results = re.findall('<li.*?>\s*?(<a.*?>)?(\w+)(</a>)?\s*?</li>', html, re.S)
   
   
   for result in results:
   
   
       print(result[1])

  
  
  
   
   
   一路上有你
   
   
   滄海一聲笑
   
   
   往事隨風
   
   
   光輝歲月
   
   
   記事本
   
   
   但願人長久

此時藉助sub()方法就比較簡單了。可以先用sub()方法將a節點去掉，只留下文本，然後再利用findall()提取就好了：

  
  
  
   
   
   html = re.sub('<a.*?>|</a>', '', html)
   
   
   print(html)
   
   
   results = re.findall('<li.*?>(.*?)</li>', html, re.S)
   
   
   for result in results:
   
   
       print(result.strip())

  
  
  
   
   
   <div id="songs-list">
   
   
       <h2 class="title">經典老歌</h2>
   
   
       <p class="introduction">
   
   
           經典老歌列表
   
   
       </p>
   
   
       <ul id="list" class="list-group">
   
   
           <li data-view="2">一路上有你</li>
   
   
           <li data-view="7">
   
   
               滄海一聲笑
   
   
           </li>
   
   
           <li data-view="4" class="active">
   
   
               往事隨風
   
   
           </li>
   
   
           <li data-view="6">光輝歲月</li>
   
   
           <li data-view="5">記事本</li>
   
   
           <li data-view="5">
   
   
               但願人長久
   
   
           </li>
   
   
       </ul>
   
   
   </div>
   
   
   一路上有你
   
   
   滄海一聲笑
   
   
   往事隨風
   
   
   光輝歲月
   
   
   記事本
   
   
   但願人長久

可以看到，a節點經過sub()方法處理後就沒有了，然後再通過findall()方法直接提取即可。可以看到，在適當的時候，藉助sub()方法可以起到事半功倍的效果。

compile()

前面所講的方法都是用來處理字符串的方法，最後再介紹一下compile()方法，這個方法可以將正則字符串編譯成正則表達式對象，以便在後面的匹配中複用。示例代碼如下：

  
  
  
   
   
   import re
   
   
   
   
   
   content1 = '2016-12-15 12:00'
   
   
   content2 = '2016-12-17 12:55'
   
   
   content3 = '2016-12-22 13:21'
   
   
   pattern = re.compile('\d{2}:\d{2}')
   
   
   result1 = re.sub(pattern, '', content1)
   
   
   result2 = re.sub(pattern, '', content2)
   
   
   result3 = re.sub(pattern, '', content3)
   
   
   print(result1, result2, result3)

例如，這裏有3個日期，我們想分別將3個日期中的時間去掉，這時可以藉助sub()方法。該方法的第一個參數是正則表達式，但是這裏沒有必要重複寫3個同樣的正則表達式，此時可以藉助compile()方法將正則表達式編譯成一個正則表達式對象，以便複用。

另外，compile()還可以傳入修飾符，例如re.S等修飾符，這樣在search()、findall()等方法中就不需要額外傳了。所以，compile()方法可以說是給正則表達式做了一層封裝，以便我們更好地複用。

到此爲止，正則表達式的基本用法就介紹完了，後面會通過具體的實例來講解正則表達式的用法。

本文分享自微信公衆號 - 我愛問讀書（wawds_）。
如有侵權，請聯繫 [email protected] 刪除。
本文參與“OSC源創計劃”，歡迎正在閱讀的你也加入，一起分享。

正則表達式---python

正則表達式相關注解

正則表達式相關注解

python中使用正則表達式

match()

匹配目標

通用匹配

貪婪與非貪婪

修飾符

轉義匹配

search()

findall()

sub()

compile()

【面試準備】又一次失敗的面試經歷，題目離譜～資深軟件測試工程師

dotnet 8 版本與銀河麒麟V10和UOS系統的 glibc 兼容性

pandas-利用python進行數據分析

Hadoop的整體介紹及安裝

Sqoop知識點整理

正則表達式---python

Numpy--利用python做數據分析

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結