正則表達式對數據處理而言非常重要。近日，Dataquest 博客發(fā)布了一篇針對入門級數據科學家的正則表達式介紹文章，通過實際操作詳細闡述了正則表達式的使用方法和一些技巧。

[[226711]]

數據科學家的一部分使命是操作大量數據。有時候，這些數據中會包含大量文本語料。比如，假如我們需要搞清楚「巴拿馬文件 [注意，可能是敏感詞]」丑聞中誰給誰發(fā)送過郵件，那么我們就要篩查 1150 萬份文檔!我們可以采用人工方式，親自閱讀每一封電子郵件，但我們也可以利用 Python 的力量。畢竟，代碼存在的意義就是自動執(zhí)行任務。

即便如此，從頭開始寫一個腳本也需要大量時間和精力。這就是正則表達式的用武之地。正則表達式(regular expression)也被稱為 RE、regex 和 regular pattern，這是一種讓我們能快速篩查和分析文本的緊湊型語言。正則表達式始于 1956 年——Stephen Cole Kleene 創(chuàng)造了它并將其用于描述人類神經系統(tǒng)的 McCulloch-Pitts 模型。到了 60 年代，Ken Thompson 將這種標記方法添加到了一個類似 Windows 記事本的文本編輯器中，自那以后，正則表達式不斷發(fā)展壯大。

正則表達式的一大關鍵特征是其經濟實用的腳本。你甚至可以將其看作是代碼中的捷徑。沒有它，我們就要碼更多代碼才能實現相同的功能。學習本教程需要基本的 Python 知識。如果你理解 if-else 語句、while 和 for 循環(huán)、列表(list)和字典(dictionary)，你就能讀懂本教程的大部分內容。你也需要一個代碼編輯器，比如 Visual Code Studio、PyCharm 或 Atom。此外，了解一點 pandas 的基本知識會很有幫助，這樣在我們解讀每一行代碼時你才不會迷失方向。如果你需要學學 pandas，可以參考這個教程：

https://www.dataquest.io/blog/pandas-python-tutorial/

學習完本教程后，你將熟悉一些正則表達式的工作原理，并能使用其基本模式和 Python 的 re 模塊提供的函數來分析字符串。我們還將體驗正則表達式和 pandas 庫高效處理大規(guī)模無組織數據集的能力。

現在，我們來看看正則表達式的能力。

介紹我們的數據集

我們將使用來自 Kaggle 的 Fraudulent Email Corpus(欺詐電子郵件語料庫)。其中包含 1998 年到 2007 年之間發(fā)送的數千封釣魚郵件。這些郵件讀起來很有意思。我們首先將使用單封郵件學習基本的正則表達式命令，然后我們會對整個語料庫進行處理。

語料庫地址：https://www.kaggle.com/rtatman/fraudulent-email-corpus

介紹 Python 的正則表達式模塊

首先，準備數據集：打開那個文本文件，將其設置成「只讀」，然后讀取它。我們也為其分配了一個變量 fh，表示文件句柄(file handle)。

fh = open(r"test_emails.txt", "r").read() 

注意我們直接在目錄路徑之前使用了 r。這項技術會將一個字符串轉換成一個原始字符串，這有助于避免由某些機器閱讀字符的方式所導致的沖突，比如 Windows 中目錄路徑中的反斜杠。

你可能注意到了我們目前沒有使用整個語料庫。我們只是人工地取了該語料庫中前面幾封郵件，然后將其做成了一個測試文件。這樣做的目的是在本教程中輸出顯示測試結果時，就不用每次都顯示數千行結果了。這能免除很多煩惱。你自己練習的時候使用完整語料庫或我們的測試文件都不會有問題。

現在，假設我們想知道這些電子郵件的發(fā)件人。我們可以試試只用原始的 Python 來實現：

for line in fh.split("\n"): 
 if "From:" in line: 
 print(line) 

也可以使用正則表達式：

import re 
 
for line in re.findall("From:.*", fh): 
 print(line) 

我們來解讀一下這段代碼。我們首先導入了 Python 的 re 模塊。然后我們寫了操作代碼。在這個簡單的示例中，這段代碼只比原始 Python 少一行。但是，隨著任務的增加，正則表達式可以讓你的腳本繼續(xù)保持簡單經濟。

re.findall() 返回字符串中滿足其模式的所有實例的列表。這是 Python 內置的 re 模塊中最常用的函數之一。分解看看。該函數的形式是 re.findall(pattern, string)，有兩個參數。其中，pattern 表示我們希望尋找的子字符串，string 表示我們要在其中查找的主字符串。主字符串可以包含很多行。

.* 是字符串模式的簡寫。我們馬上就會詳細解釋?，F在只需知道它們的作用是匹配 From: 字段中的名稱和電子郵箱地址。

在我們繼續(xù)深入之前，我們先了解一些常見的正則表達式模式。

常見的正則表達式模式

我們在上面的 re.findall() 中使用的模式中包含一個完全拼寫出來的字符串 From:。這在我們知道我們所要尋找的東西是什么時非常有用，可以確定到實際的字母以及大小寫。如果我們不知道我們所想要的字符串的確切格式，我們將難以為繼。幸運的是，正則表達式有解決這類情況的基本模式。我們看看本教程中會使用的一些模式：

• \w 匹配字母數字字符，即 a-z、A-Z 和 0-9，也會匹配下劃線 _ 和連接號 –
• \d 匹配數字，即 0-9
• \s 匹配空白字符，包括制表符、換行符、回車符和空格符
• \S 匹配非空白字符
• . 匹配除換行符 \n 之外的任意字符

有了這些正則表達式模式，你就能在我們繼續(xù)解釋代碼時很快理解。

使用正則表達式模式

我們現在可以解釋上面 re.findall("From:.*", text) 一行中的 .* 了。首先來看

for line in re.findall("From:.", fh): 
 print(line) 

通過在 From: 后面添加一個 .，我們是要尋找 From: 之后另外的一個字符。因為 . 是查找除 \n 之外的任意字符，所以這會得到我們看不到的空格。我們可以多加一些點來驗證這個情況

for line in re.findall("From:...........", fh): 
 print(line) 

看起來加點就能讓我們得到這一行的其余內容了。但這很單調乏味，而且我們不知道需要加多少個點。這就是星號 * 發(fā)揮作用的地方。

* 匹配 0 個或更多個其左側的模式的實例。也就是說它會查找重復的模式。當我們查找重復模式時，我們說我們的搜索是「貪婪匹配」。如果我們沒有查找重復模式，我們可以說我們的搜索是「非貪婪匹配」或「懶惰匹配」。

讓我們使用 * 構建一個 . 的貪婪搜索

for line in re.findall("From:.*", fh): 
 print(line) 

因為 * 匹配 0 個或多個其左側模式的實例且 . 在其左側，所以我們可以獲取 From: 字段中的所有字符，直到該行結束。這樣就用美麗而簡潔的代碼輸出顯示了一整行。

我們甚至可以更進一步只取出其中的名稱。

match = re.findall("From:.*", fh) 
 
for line in match: 
 print(re.findall("\".*\"", line)) 

這里，我們先使用之前的做法通過 re.findall() 得到了包含 From:.* 模式的行的列表。接下來，我們遍歷這個列表。在這一次訓練中，我們都再執(zhí)行一次 re.findall()。這一次，該函數先從匹配***個引號開始。

注意我們在***個引號后使用了一個反斜杠。這個反斜杠是一個用于給其它特殊字符轉義的特殊字符。比如說，當我們想將引號用作字符串本身而不是特殊字符時，我們可以像 \" 這樣使用反斜杠對其轉義。如果我們不使用反斜杠轉義上述模式，它就會變成 "".*""，Python 解釋器就會將其看作是兩個空字符串之間的一個句號和一個星號。這會出錯并使該腳本中斷。因此，我們這里必須使用反斜杠給引號轉義。

在***個引號匹配后，.* 會獲取這一行中下一個引號前的所有字符。當然，該模式中的下一個引號也經過了轉義。這讓我們可以得到引號之中的名稱。每個名稱都輸出顯示在方括號中，因為 re.findall 以列表形式返回匹配結果。

如果我們想得到電子郵箱地址呢?

match = re.findall("From:.*", fh) 
 
for line in match: 
 print(re.findall("\w\S*@.*\w", line)) 

看起來很簡單，是不是?只是模式不一樣而已。讓我們詳細看看。

這是我們匹配電子郵箱地址前半部分的方式：

for line in match: 
 print(re.findall("\w\S*@", line)) 

電子郵箱地址中總會包含一個 @ 符號，所以我們從它開始入手。電子郵箱地址中 @ 符號前面的部分可能包含字母數字字符，這意味著需要 \w。但是，由于某些電子郵箱地址包含句號或連接號，所以這還不夠。我們增加了 \S 來查找非空白字符。但 \w\S 只能得到兩個字符，所以增加 * 來重復查找。所以 @ 符號之前部分的模式是 \w\S*@。接下來看 @ 符號之后的部分。

for line in match: 
 print(re.findall("@.*", line)) 

域名通常包含字母數字字符、句號，有時候還會有連接號。這很簡單，一個 . 就行。為了實現貪婪搜索，我們使用 * 來延展。這讓我們可以匹配直到該行結束的任意字符。

簡單看看這些行，我們可以發(fā)現每個電子郵箱地址都被放在一對尖括號 <> 之中。我們的模式 .* 會將右尖括號 > 包含進來。我們再調整一下：

for line in match: 
 print(re.findall("@.*\w", line)) 

電子郵箱地址是以字母數字字符結尾的，所以我們用 \w 作為這一模式的結尾。因此，@ 符號之后的部分是 .*\w，也就是說我們想要的模式是一組以字母數字字符結尾的任意類型的字符。這樣就排除了 >。因此，完整的電子郵箱地址模式就為 \w\S*@.*\w

看起來有些麻煩。實際上正則表達式確實需要花些時間才能熟練，但一旦你掌握了，在寫分析字符串的代碼時就會快很多。接下來，我們會介紹一些常見的 re 函數，這些函數在重新組織這個語料庫時會很有用。

常見的正則表達式函數

re.findall() 毫無疑問非常有用，re 模塊還提供了一些同樣方便的函數，其中包括：

• re.search()
• re.split()
• re.sub()

我們先逐一介紹一下這些函數，然后再將它們用來整理笨重難讀的語料庫。

1. re.search()

re.findall() 匹配的是一個模式在一個字符串中的所有實例然后以列表的形式返回它們，而 re.search() 匹配的是一個模式在一個字符串中的***個實例，然后以 re 匹配對象的形式返回它。

match = re.search("From:.*", fh) 
print(type(match)) 
print(type(match.group())) 
print(match) 
print(match.group()) 

與 re.findall() 類似，re.search() 也有兩個參數。***個參數是所要匹配的模式，第二個是要在其中查找的字符串。這里為了簡潔我們已經分配了 match 變量的結果。

因為 re.search() 返回的是一個 re 匹配對象，所以我們不能直接通過 print 展示其中的名稱和電子郵箱地址。我們必須首先為其應用 group() 函數。我們已經在上面的代碼中將它們輸出顯示了出來。如我們所見，group() 函數的作用是將匹配對象轉換成字符串。

我們還能看到 print(match) 會顯示字符串以及除字符串本身之外的屬性，而 print(match.group()) 只會顯示字符串。

2. re.split()

假設我們需要一種獲取電子郵箱地址域名的快速方式。我們可以用 3 個正則表達式操作來完成。如下：

address = re.findall("From:.*", fh) 
for item in address: 
 for line in re.findall("\w\S*@.*\w", item): 
 username, domain_name = re.split("@", line) 
 print("{}, {}".format(username, domain_name)) 

***行我們很熟悉。我們返回一個字符串列表并為其分配一個變量，其中每個字符串都包含了 From: 字段的內容。接下來我們遍歷整個列表，尋找電子郵箱地址。與此同時，我們遍歷這些電子郵箱地址并使用 re 模塊的 split() 函數以 @ 符號為分割符將每個電子郵件一分為二。***，我們將其顯示出來。

3. re.sub()

re.sub() 是另一個很好用的 re 函數。顧名思義，它的功能是替換一個字符串的一部分。舉個例子：

sender = re.search("From:.*", fh) 
address = sender.group() 
email = re.sub("From", "Email", address) 
print(address) 
print(email) 

其中***行和第二行的任務我們之前已經見過。第三行我們在 address 上應用 re.sub(); address 是電子郵件標頭中的完整的 From: 字段。

re.sub() 有三個參數。***個是所要替換的子字符串，第二個是用來替換前者的字符串，第三個是主字符串本身。

pandas 的正則表達式

現在我們已經有了正則表達式的基礎，我們可以試試一些更高級的功能。但是，我們需要將正則表達式與 pandas Python 數據分析庫結合起來。在將數據整理成整潔的表格(也稱為 dataframe)方面，pandas 非常有用，而且還能讓我們從不同的角度理解數據。與正則表達式那經濟簡練的代碼結合到一起，就好像是用快刀切黃油——簡單利落。

如果你之前從未用過 pandas，也不要擔心。我們會一步步地介紹代碼，這樣你絕不會迷失方向。正如我們在引言中提到的那樣，如果你想詳細學習這個庫，請訪問那個教程。

我們可以通過 Anaconda 或 pip 獲取 pandas，詳情參閱安裝指南：

https://pandas.pydata.org/pandas-docs/stable/install.html

使用正則表達式和 pandas 整理電子郵件

我們的語料庫是包含了數千封電子郵件的單個文本文件。我們將使用正則表達式和 pandas 將每封電子郵件的各部分整理到合適的類別中，以便對該語料庫的讀取和分析更簡單。

我們將會將每封電子郵件整理成以下類別：

• sender_name(發(fā)件人名稱)
• sender_address(發(fā)件人地址)
• recipient_address(收件人地址)
• recipient_name(收件人名稱)
• date_sent(發(fā)送時間)
• subject(主題)
• email_body(郵件正文)

其中每個類別都會成為我們的 pandas dataframe 或表格中的一列。這會很有用，因為這讓我們可以操作每一列本身。比如，這讓我們可以編寫代碼來查找這些電子郵件來自哪些域名，而無需先編寫代碼將電子郵箱地址與其它部分隔開。本質上講，將我們的數據集中的重要部分分門別類讓我們可以之后用簡練得多的代碼獲取細粒度的信息。反過來，簡潔的代碼也能減少我們的機器必須執(zhí)行的運算的數量，這能加速我們的分析過程，尤其是當操作大規(guī)模數據集時。

準備腳本

我們上面已經了解過了一個簡單的腳本。接下來讓我們從頭開始，了解如何將它們聚合到一起。

import re 
import pandas as pd 
import email 
 
emails = [] 
 
fh = open(r"test_emails.txt", "r").read() 

首先在腳本最上面，我們按照標準慣例導入 re 和 pandas。我們也導入了 Python 的 email 包，電子郵件正文的處理尤其需要這個包。如果只使用正則表達式，那么電子郵件正文處理起來會相當復雜，甚至可能還需要一篇單獨的教程才能說請。所以我們使用開發(fā)優(yōu)良的 email 包來節(jié)省時間，讓我們專注學習正則表達式。

接下來我們創(chuàng)建一個空列表 emails，用來存儲字典。每個字典都將包含每封電子郵件的細節(jié)。

我們經常把代碼的結果顯示在屏幕上，以了解代碼正確或出錯的位置。但是，因為數據集中存在數千封電子郵件，所以這會在屏幕上打印出數千行，從而讓本教程臃腫不堪。我們肯定不想不斷滾動數千行結果。因此，正如我們在本教程開始時做的那樣，我們打開并閱讀一個語料庫的縮短版。我們是通過人工的方式專為本教程準備的。但你自己練習的時候可以使用實際的數據集。每當你運行 print() 函數時，你都能在幾秒之內在屏幕上看到數千行結果。

現在，開始使用正則表達式。

contents = re.split(r"From r", fh) 
contents.pop(0) 

我們使用 re 模塊的 split 函數來將 fh 中的整個文本塊分割成單獨的電子郵件構成的列表，我們將其分配給變量 contents。這很重要，因為我們希望通過一個 for 循環(huán)遍歷這個列表，一封封地處理郵件。但我們怎么知道如何通過字符串 From r 來進行分割?因為我們在寫這個腳本之前先查看了文件。我們不必仔細閱覽這里的數千封郵件。只需看看前面幾封郵件，了解一下其數據結構即可?？梢钥吹?，每封電子之前都有字符串 From r。我們給這個文本文件截了個圖：

「From r」起頭的電子郵件

綠色區(qū)域是***封郵件，藍色區(qū)域是第二封郵件。可以看到，這兩封郵件都是以 From r 開始的(紅框所示)。

本教程使用 Fraudulent Email Corpus 的原因之一是表明當數據未經整理、不熟悉且沒有說明文檔時，只通過編寫代碼不能整理好它。這還需要人眼。正如剛才我們做的那樣，我們必須閱讀這個語料庫，了解它的結構。此外，這些數據可能還需要大量清理工作;這個語料庫也是如此。比如說，盡管我們使用本教程即將構建好的完整腳本算出這個數據集中有 3977 封郵件，但實際上還有更多。某些電子郵件不是以 From r 開始的，所以就沒有被分開。但我們還是這樣使用我們的數據集，否則本教程還會更長。

還要注意，我們使用了 contents.pop(0) 來避開列表中的***個元素。這是因為 From r 也在***封電子郵件之前。當分割該字符串時，它會在索引 0 的位置產生一個空字符串。我們即將編寫的腳本是為電子郵件設計的。如果用它來操作空字符串，可能會報錯。避開空字符串能讓我們避開會造成腳本執(zhí)行中斷的錯誤。

用 for 循環(huán)獲取每個名稱和地址

現在，我們處理 contents 列表中的電子郵件。

for item in contents: 
 emails_dict = {} 

在上面的代碼中，我們使用了一個 for 循環(huán)來遍歷 contents，以便我們依次處理每封郵件。我們創(chuàng)建了一個字典 emails_dict，其中有每封郵件的所有細節(jié)，比如發(fā)件人的地址和名稱。實際上，這就是我們首先要查找的項。

這是一個三步式的過程。首先從查找 From: 字段開始。

for item in contents: # First two lines again so that Jupyter runs the code. 
 emails_dict = {} 
 
# Find sender's email address and name. 
 
 # Step 1: find the whole line beginning with "From:". 
 sender = re.search(r"From:.*", item) 

第 1 步，使用 re.search() 函數查找整個 From: 字段。. 代表除 \n 之外的任意字符，* 將其延展到這一行的末尾。然后我們將其分配給變量 sender

但是，數據并不總是簡單直觀的，也可能有意外情況。比如，要是沒有 From: 字符呢?這個腳本會報錯并且中斷。我們在第 2 步預先排除這種情況。

# Step 2: find the email address and name. 
if sender is not None: 
 s_email = re.search(r"\w\S*@.*\w", sender.group()) 
 s_name = re.search(r":.*<", sender.group()) 
else: 
 s_email = None 
 s_name = None 

為了避免因缺失 From: 字段而出錯，我們使用 if 語句檢查 sender 是否不為 None。如果是 None，則為 s_email 和 s_name 分配 None 值，這樣這個腳本就不會意外中斷了。

盡管本教程中使用正則表達式(和下面的 pandas)時看起來相當簡單，但你的實際體驗可能不會這么好。比如，我們看起來自然地使用了 if-else 語句來檢查數據是否存在。但實際上，我們知道這一點的原因是我們在這個語料庫上嘗試了很多次這個腳本。編寫代碼是一個迭代式的過程。需要指出，就算教程看起來是一次成型的，但實際操作起來涉及到很多實驗過程。

在第 2 步中，我們使用了與之前類似的正則表達式模式 \w\S*@.*\w 來匹配電子郵箱地址。

我們使用了不同的策略來匹配名稱。每個名稱的左邊都有 From: 之中的冒號 :，且右邊都有電子郵箱地址左邊的左尖括號 <。因此，我們使用 :.*< 來查找姓名。我們馬上就要去掉每個結果中的 : 和 <。

現在讓我們顯示結果，看看代碼的效果。

print("sender type: " + str(type(sender))) 
print("sender.group() type: " + str(type(sender.group()))) 
print("sender: " + str(sender)) 
print("sender.group(): " + str(sender.group())) 
print("\n") 

注意，在每次應用 re.search() 時，我們不使用 sender 作為要搜索的字符串。我們打印了 sender 和 sender.group() 的類型以便了解它們的不同。看起來 sender 是一個 re 匹配對象，所以不能用 re.search() 進行搜索。但是，sender.group() 是一個字符串，正好適合 re.search() 處理。

讓我們看看 s_email 和 s_name 是怎樣的。

print(s_email) 
print(s_name) 

同樣是匹配對象。每當我們對字符串應用 re.search() 時，都會得到匹配對象。我們必須將其轉換成字符串對象。

在我們做這件事之前，要記得如果沒有 From: 字段，sender 的值是 None;因此 s_email 和 s_name 的值也是 None。因此，我們必須再次檢查這個情況，讓該腳本不會意外中斷。首先來看如何使用 s_email 來構建代碼。

# Step 3A: assign email address as string to a variable. 
if s_email is not None: 
 sender_email = s_email.group() 
else: 
 sender_email = None 
 
# Add email address to dictionary. 
emails_dict["sender_email"] = sender_email 

在第 3A 步，我們使用一個 if 語句來檢查 s_email 是否不是 None，否則它會報錯并中斷腳本。

然后，我們將 s_email 匹配對象轉換成字符串并分配給變量 sender_email。我們將其添加到 emails_dict 字典，這讓我們之后可以非常輕松地將這些細節(jié)變成 pandas dataframe。

我們在第 3B 步為 s_name 做幾乎一樣的事情。

# Step 3B: remove unwanted substrings, assign to variable. 
if s_name is not None: 
 sender_name = re.sub("\s*<", "", re.sub(":\s*", "", s_name.group())) 
else: 
 sender_name = None 
 
# Add sender's name to dictionary. 
emails_dict["sender_name"] = sender_name 

正如我們之前的做法，我們首先檢查 s_name 是否不是 None。

然后，我們使用 re 模塊的 re.sub() 函數兩次，之后再將所得到的字符串分配給一個變量。在***次使用 re.sub() 時，我們移除冒號以及其和名稱之間的任何空格字符。我們使用空字符串 "" 替換 :\s* 即可實現。然后我們移除名稱另一邊的空格字符和尖括號，同樣用一個空字符串替換它。***，在將其分配給變量 sender_name 后，我們將其添加到字典。

檢查結果：

print(sender_email) 
print(sender_name) 

***。我們分離出了發(fā)件人的電子郵箱地址和名稱，我們也將它們添加進了字典，后面會有用的。

現在，我們已經找到了發(fā)件人的電子郵箱地址和名稱，我們再通過同樣的步驟獲取收件人的電子郵箱地址和名稱，并加入字典。

首先，我們查找 To: 字段。

rerecipient = re.search(r"To:.*", item) 

接下來，我們預先設定好 recipient 為 None 的情況。

if recipient is not None: 
 r_email = re.search(r"\w\S*@.*\w", recipient.group()) 
 r_name = re.search(r":.*<", recipient.group()) 
else: 
 r_email = None 
 r_name = None 

如果 recipient 不為 None，我們就使用 re.search() 查找包含電子郵箱地址和收件人名稱的匹配對象。否則，我們就將 r_email 和 r_name 賦值為 None。

然后，我們將匹配對象變成字符串，并將它們加入字典。

if r_email is not None: 
 recipient_email = r_email.group() 
else: 
 recipient_email = None 
 
emails_dict["recipient_email"] = recipient_email 
 
if r_name is not None: 
 rerecipient_name = re.sub("\s*<", "", re.sub(":\s*", "", r_name.group())) 
else: 
 recipient_name = None 
 
emails_dict["recipient_name"] = recipient_name 

因為 From: 和 To: 字段的結構是一樣的，所以我們可以為兩者使用同樣的代碼——只需針對性地稍微調整一下即可。

獲取電子郵件日期

現在獲取電子郵件的發(fā)送日期：

for item in contents: # First two lines again so that Jupyter runs the code. 
 emails_dict = {} 
 
 date_field = re.search(r"Date:.*", item) 

我們使用獲取 From: 和 To: 字段一樣的代碼來獲取 Date: 字段。而且和上面的操作一樣，我們要檢查賦值為 date_field 的 Date: 字段是否為 None。

if date_field is not None: 
 date = re.search(r"\d+\s\w+\s\d+", date_field.group()) 
else: 
 date = None 
 
print(date_field.group()) 

我們輸出顯示了 date_field.group()，以便我們更清楚地了解這個字符串的結構。它包含了 DD MMM YYYY 格式的日期以及具體的時間。我們只需要日期。針對日期的代碼和針對名稱與電子郵箱地址的代碼差不多，但卻更加簡單。也許這里最讓人迷惑的是正則表達式模式 \d+\s\w+\s\d+。

日期是以一個數字開始的。因此我們使用 \d 表示它。但是，DD 部分的日期可能是一個數字，也可能是兩個數字。因此這里的 + 號就很重要了。在正則表達式中，+ 匹配 1 個或多個其左側模式的實例。因此 \d+ 可以匹配 DD 部分，不管是一個數字還是兩個數字。

在那之后，有一個空格。用 \s 代表，可以查找空白字符。月份由三個字母組成，因此用 \w+。然后是另一個空格 \s。年份由數字組成，所以再次使用 \d+。

完整的模式 \d+\s\w+\s\d+ 是有效的，因為它是兩邊都有空白字符的精確模式。

接下來，我們想之前一樣檢查 None 值。

if date is not None: 
 datedate_sent = date.group() 
 date_star = date_star_test.group() 
else: 
 date_sent = None 
 
emails_dict["date_sent"] = date_sent 

如果 date 不是 None，我們就將其從匹配對象變成字符，并分配給變量 date_sent。然后插入字典。

在繼續(xù)前進之前，我們應該指出：+ 和 * 看起來相似但結果非常不同。我們以這里的日期字符串為例看看。

date = re.search(r"\d+\s\w+\s\d+", date_field.group()) 
 
# What happens when we use * instead? 
date_star_test = re.search(r"\d*\s\w*\s\d*", date_field.group()) 
 
datedate_sent = date.group() 
date_star = date_star_test.group() 
 
print(date_sent) 
print(date_star) 

如果我們使用 *，我們會匹配 0 或更多個實例;而 + 是匹配 1 或多個實例。我們顯示了兩種情況的結果。差距很大。如你所見 + 得到了完整的日期，而 * 則得到了一個空格和數字 1.

接下來，獲取電子郵件的主題行。

獲取電子郵件主題

和之前一樣，我們使用同樣的代碼和代碼結構來獲取我們所需的信息。

for item in contents: # First two lines again so that Jupyter runs the code. 
 emails_dict = {} 
 
 subject_field = re.search(r"Subject: .*", item) 
 
 if subject_field is not None: 
 subject = re.sub(r"Subject: ", "", subject_field.group()) 
 else: 
 subject = None 
 
 emails_dict["subject"] = subject 

我們越來越熟悉使用正則表達式了。這和之前的代碼基本一樣，只是我們使用空字符串替換了 "Subject: "，以便只得到主題本身。

獲取電子郵件正文

我們的字典要插入的***一項是電子郵件正文。

full_email = email.message_from_string(item) 
body = full_email.get_payload() 
emails_dict["email_body"] = body 

將郵件標頭與正文分開是一項很復雜的任務，尤其是當很多標頭都不一樣時。在原始的未整理的數據中，一致的情況很少見。幸運的是，這項工作已經被完成了。Python 的 email 包非常適合這項任務。我們之前已經導入了這個包。現在我們將 message_from_string() 應用在 item 上，將整封電子郵件變成一個 email 消息對象。消息對象包含一個標頭和一個 payload，分別對應電子郵件的標頭和正文。

接下來，我們在這個消息對象上應用 get_payload() 函數。這個函數可以分離出電子郵件的主體。我們將其分配給變量 body，然后插入到我們的 emails_dict 字典中的 "email_body" 下。

你可能會問：為什么要使用 email 包，而不使用正則表達式?因為目前來看，如果沒有大量數據清理工作，使用正則表達式還不能很好地做到這一點。這意味著需要另外一些代碼，還需要再寫一個教程才能說請。

但值得說明一下我們做出這個決定的方式。但是，首先我們需要了解一下方括號 [ ] 在正則表達式中的含義。

[ ] 匹配放置于其中的任意字符。比如如果我們想在一個字符串中查找 a、b 或 c，我們可以使用 [abc] 作為模式。我們前面討論的模式也適用。[\w\s] 是查找字母數字或空白字符。但 . 是例外，它在 [ ] 中就表示句號。

現在我們可以更好地理解我們使用 email 包的原因了。

看一看這個數據集，可以發(fā)現這個電子郵件標頭終止于 "Status: 0" 或 "Status: R0";而正文在下一封電子郵件的 "From r" 字符串之前終止。因此我們可以使用 Status:\s*\w*\n*[\s\S]*From\sr* 來獲取電子郵件正文。[\s\S]* 可用于大量文本、數字和標點符號構成的字符串，因為它既能搜索空白字符，也能搜索非空白字符。

不幸的是，有些郵件包含不止一個 Status: 字符串，還有一些郵件不包含 From r。這意味著我們分割得到的電子郵件數量會多于或少于電子郵件列表字典的數量。就會與我們已經得到的其它類別不匹配。這會在使用 pandas 時出現問題。因此，我們選擇使用 email 包。

創(chuàng)建字典列表

***，將字典 emails_dict 附加到 emails 列表之后：

emails.append(emails_dict) 

你可能需要輸出顯示看看 emails 列表，看看效果。你也可以運行 print(len(emails_dict)) 來了解列表中有多少字典，即電子郵件。正如我們之前提到的，完整的語料庫包含 3977 個。我們的小測試文件包含 7 個。以下是完整代碼：

import re 
import pandas as pd 
import email 
 
emails = [] 
 
fh = open(r"test_emails.txt", "r").read() 
 
contents = re.split(r"From r",fh) 
contents.pop(0) 
 
for item in contents: 
 emails_dict = {} 
 
 sender = re.search(r"From:.*", item) 
 
 if sender is not None: 
 s_email = re.search(r"\w\S*@.*\w", sender.group()) 
 s_name = re.search(r":.*<", sender.group()) 
 else: 
 s_email = None 
 s_name = None 
 
 if s_email is not None: 
 sender_email = s_email.group() 
 else: 
 sender_email = None 
 
 emails_dict["sender_email"] = sender_email 
 
 if s_name is not None: 
 sender_name = re.sub("\s*<", "", re.sub(":\s*", "", s_name.group())) 
 else: 
 sender_name = None 
 
 emails_dict["sender_name"] = sender_name 
 
 rerecipient = re.search(r"To:.*", item) 
 
 if recipient is not None: 
 r_email = re.search(r"\w\S*@.*\w", recipient.group()) 
 r_name = re.search(r":.*<", recipient.group()) 
 else: 
 r_email = None 
 r_name = None 
 
 if r_email is not None: 
 recipient_email = r_email.group() 
 else: 
 recipient_email = None 
 
 emails_dict["recipient_email"] = recipient_email 
 
 if r_name is not None: 
 rerecipient_name = re.sub("\s*<", "", re.sub(":\s*", "", r_name.group())) 
 else: 
 recipient_name = None 
 
 emails_dict["recipient_name"] = recipient_name 
 
 date_field = re.search(r"Date:.*", item) 
 
 if date_field is not None: 
 date = re.search(r"\d+\s\w+\s\d+", date_field.group()) 
 else: 
 date = None 
 
 if date is not None: 
 datedate_sent = date.group() 
 else: 
 date_sent = None 
 
 emails_dict["date_sent"] = date_sent 
 
 subject_field = re.search(r"Subject: .*", item) 
 
 if subject_field is not None: 
 subject = re.sub(r"Subject: ", "", subject_field.group()) 
 else: 
 subject = None 
 
 emails_dict["subject"] = subject 
 
 # "item" substituted with "email content here" so full email not displayed. 
 
 full_email = email.message_from_string(item) 
 body = full_email.get_payload() 
 emails_dict["email_body"] = "email body here" 
 
 emails.append(emails_dict) 
 
# Print number of dictionaries, and hence, emails, in the list. 
print("Number of emails: " + str(len(emails_dict))) 
 
print("\n") 
 
# Print first item in the emails list to see how it looks. 
for key, value in emails[0].items(): 
 print(str(key) + ": " + str(emails[0][key])) 

我們已經輸出顯示了 emails 列表中的***項，顯然這是帶有 key 和值配對的字典。因為我們使用了 for 訓練，所以每個字典都有相同的 key 和不同的值。

我們使用 email content here 替換了 item，這樣我們就無需輸出所有電子郵件來占領我們的屏幕了。如果你在操作實際數據集這樣顯示，你會看到整個電子郵件。

使用 pandas 操作數據

將字典放入列表后，我們就能使用 pandas 庫來輕松操作這些數據了。每個 key 都會成為一個列標題，每個值都是一列中的一行。

我們只需應用這些代碼：

import pandas as pd # Module imported above, imported again as reminder. 
emails_df = pd.DataFrame(emails) 

只需一行代碼，我們就使用 pandas 的 DataFrame() 函數將 emails 字典列表變成了一個 dataframe。我們也為其分配了一個變量。

完成了?，F在我們有了復雜精細的 pandas dataframe。這是一個簡練整潔的表格，包含了我們從這些電子郵件中提取的所有信息。

讓我們看看前面幾行：

pd.DataFrame.head(emails_df, n=3) 

dataframe.head() 函數只會展示前面幾行，而不會展示整個數據集。它有一個參數。還有一個可選參數可以指定所要展示的行數。這里 n=3 表示我們想看 3 行。

我們也可以精確查找我們想要的東西。比如，我們可以查找所有來自特定域名的郵件。但是，讓我們學習另一個正則表達式模式以提升我們查找所需項的準確性。

豎線符號 | 會查找其兩邊的字符，比如 a|b 會查找 a 或 b。

| 看起來似乎和 [ ] 一樣，但實際并不一樣。假如我們要查找 crab 或 lobster 或 isopod，那么使用 crab|lobster|isopod 會比使用 [crablobsterisopod] 要合理得多。前者是查找其中每個詞，而后者是搜索其中每個字母。

現在我們使用 | 來查找來自一個域名或另一個域名的電子郵件。

emails_df[emails_df["sender_email"].str.contains("maktoob|spinfinder")] 

這是一行相當長的代碼。讓我們從內部開始解讀。

emails_df['sender_email'] 是選擇有 sender_email 標簽的一列。接下來，str.contains(maktoob|spinfinder) 是指如果在該列中找到了 maktoob 或 spinfinder，則返回 Ture。***，外圍的 emails_df[] 返回一個行視圖，其中 sender_email 列包含了目標子字符串。干的漂亮!

我們也可以查看每個單元格的電子郵件。要做到這一點，我們要做 4 步。第 1 步，查找 sender_email 列中包含 @maktoob 字符串的行的索引。注意我們使用正則表達式的方式。

# Step 1: find the index where the "sender_email" column contains "@maktoob.com". 
index = emails_df[emails_df["sender_email"].str.contains(r"\w\S*@maktoob.com")].index.values 

第 2 步，我們使用該索引查找電子郵箱地址，loc[] 方法返回一個 Series 對象，其具有幾種不同的屬性。我們用以下方式顯示輸出其結果。

# Step 2: use the index to find the value of the cell in the "sender_email" column. 
# The result is returned as pandas Series object 
address_Series = emails_df.loc[index]["sender_email"] 
print(address_Series) 
print(type(address_Series)) 

第 3 步，我們從這個 Series 對象提取電子郵箱地址，就像我們從一個列表提取項一樣。你可以看到它現在的類型是類(class)。

# Step 3: extract the email address, which is at index 0 in the Series object. 
address_string = address_Series[0] 
print(address_string) 
print(type(address_string)) 

第 4 步，提取電子郵件正文。

# Step 4: find the value of the "email_body" column where the "sender email" column is address_string. 
print(emails_df[emails_df["sender_email"] == address_string]["email_body"].values) 

在第 4 步中，emails_df['sender_email'] == "james_ngola2002@maktoob.com" 是查找 sender_email 列中包含 james_ngola2002@maktoob.com 的行。接下來，['email_body'].values 查找對應行的 email_body 列。***，得到結果值。

可以看到，使用正則表達式的方式多種多樣，而且能很好地與 pandas 搭配使用。

其它資源

正則表達式自從生物學邁向工程領域之后，多年來發(fā)展迅速?，F在，正則表達式已經在各種不同的編程語言中得到了應用，其中某些變體已經超越了其基本模式。

• 在本教程中，我們使用 Python 進行了練習，如果你有進一步探索的興趣，可以參閱這個帖子：https://stackoverflow.com/questions/4644847/list-of-all-regex-implementations。
• 維基百科也有一個比較不同正則表達式引擎的表格：https://en.m.wikipedia.org/wiki/Comparison_of_regular_expression_engines#Part_1
• 一篇教程肯定不能說盡正則表達式的全部。完整參考可參閱 Python 的 re 模塊的文檔：https://docs.python.org/3/library/re.html。谷歌也有一個快速參考：https://developers.google.com/edu/python/regular-expressions
• 如果你需要數據集來做實驗，Kaggle 和 StatsModels 很不錯。
• 這里有個正則表達式快速參考表：https://github.com/dmikalova/sublime-cheat-sheets/blob/master/cheat-sheets/Regular%20Expressions.cheatsheet。這是為 Sublime 設計的，但對其它工具而言也很方便。

原文鏈接：https://www.dataquest.io/blog/regular-expressions-data-scientists/

【本文是51CTO專欄機構“機器之心”的原創(chuàng)譯文，微信公眾號“機器之心( id: almosthuman2014)”】

戳這里，看該作者更多好文