python編程基礎—正則表達式

正則表達式

• 正則表達式就是描述字符串排列的一套規則。利用正則表達式能夠作不少事情，主要用於字符串的匹配
• 在實際項目中，咱們常常須要找到某一類符合某種格式的信息，此時，咱們能夠觀察這些數據的規律，而後將這些數據的格式規律用正則表達式形式描述出來，而後利用正則表達式函數進行相應的處理便可。
  本節主要爲你們介紹正則表達式怎麼去寫，將從原子、原子符、模式修正符、貪婪模式與懶惰模式等方面介紹

1.原子

原子是正則表達式中最基本的組成單位，每一個正則表達式中至少要包含一個原子
常見的原子有這幾類：普通字符做爲原子、非打印字符做爲原子、通用字符做爲原子和原子表

(1) 普通字符做爲原子

• 咱們可使用一些普通的字符，好比數字，大小寫字母，下劃線等均可做爲原子使用，以下程序中，‘yue’做爲原子使用，這裏有三個原子，分別是y,u,e

#普通字符做爲原子
import re
pattern = "yue"#yue做爲原子使用，有三個原子，分別是y,u,e
string = "http://yum.iqianyue.com"
resultl = re.search(pattern,string)#在string中匹配正確的正則表達式，若匹配成功，將匹配結果返回給變量result
print(resultl)

<_sre.SRE_Match object; span=(16, 19), match='yue'>

(2) 非打印字符做爲原子

• 指的是一些在字符串中用於格式控制的符號，好比換行符等（經常使用的非打印字符爲 ‘\n’ :用於匹配一個換行符， ‘\t’ ：用於匹配一個製表符）

##非打印字符做爲原子
import re
pattern = "\n"
string = '''http://yum.iqianyue.com
http://baidu.com'''  #字符串變量string中包含一個多行的數據，因此這個數據裏面包含了對應的換行符，因此，此時進行換行符匹配
resultl = re.search(pattern,string)
print(resultl)

<_sre.SRE_Match object; span=(23, 24), match='\n'>

import re
pattern = "\n"
string = '''http://yum.iqianyue.comhttp://baidu.com'''#在字符串中不包含換行，因此沒法成功匹配，故最後輸出None
resultl = re.search(pattern,string)
print(resultl)

None

(3) 通用字符做爲原子（即一個原子能夠匹配一類字符）

• 通用字符，即一個原子能夠匹配一類字符
• 常見的通用字符及其含義：

符號	含義
\w	匹配任意一個字母、數字和下劃線
\W	匹配除任意一個字母、數字和下劃線之外的任意一個字符
\d	匹配任意一個十進制數
\D	匹配除十進制數之外的任意一個其餘字符
\s	匹配任意一個空白字符
\S	匹配除空白字符之外的任意一個其餘字符

#通用字符做爲原子示例
import re 
pattern = "\w\dpython\w"#'\w'匹配任意一個字母、數字、下劃線;'\d'匹配任意一個十進制數；
string = "abcdfphp345pythony_py"
result1 = re.search(pattern,string)
print(result1)

<_sre.SRE_Match object; span=(9, 18), match='45pythony'>

(4) 原子表

• 由[]表示，好比[xyz]就是一個原子表，這個原子表中定義了3個原子，這3個原子的地位平等。如咱們定義的正則表達式爲「[xyz]py」,對應的源字符串爲「xpython」,若用 re.search()函數進行匹配，就能夠匹配出結果「xpy」，由於此時只要py前一位是x y z字母中的其中一個字母，就能夠匹配成功。
  
• 相似的，[^]表明的是除了中括號裏面的原子都可以匹配成功。好比"[^xyz]py"能匹配「apy」，可是不能匹配xpy等。

#原子表示例
import re 
pattern1 = "\w\dpython[xyz]\w"
pattern2 = "\w\python[^xyz]\w"
pattern3 ="\w\dpython[xyz]\W"
string = "abcdfphp345pythony_py"
result1 = re.search(pattern1,string)
result2= re.search(pattern2,string)
result3 = re.search(pattern3,string)
print(result1)
print(result2)
print(result3)

<_sre.SRE_Match object; span=(9, 19), match='45pythony_'>
None
None

2 原子符

• 原子符就是正則表達式中具備一些特殊含義的字符，好比重複N次前面的字符等。
  常見的元子符:

符號	含義
.	匹配除換行符之外的任意字符
^	匹配字符串的開始位置
$	匹配字符串的終止位置
*	匹配0次、1次或屢次前面的原子
?	匹配0次或1次前面的原子
+	匹配1次或屢次前面的原子
{n}	前面的原子正好出現n次
{n,}	前面的原子至少出現n次
{m,n}	前面的原子至少出現n次，至多出現m次

(1) 任意匹配原子符

首先看任意匹配符‘.’，能夠用‘.’匹配一個除換行符之外的任意字符。
好比，用正則表達式「.python...」匹配一個「python」字符前面有1位，後面有3位格式的字符，這前面的1位和後面的3位能夠是除了換行符意外的任意字符。如如下程序：

import re
pattern=".python..."
string = "abcdfphp345pythony_py"
result1 = re.search(pattern1,string)
print(result1)

<_sre.SRE_Match object; span=(9, 19), match='45pythony_'>

(2) 邊界限制原子符

可使用「^」匹配字符串的開始，使用「$」匹配字符串的結束，以下例：

import re 
pattern1 = "^abd"#限制以abd開始
pattern2 = "^abc"#限制以abc開始
pattern3 ="py$"#限制以py結束
pattern4 = "ay$"#限制以ay結束
string = "abcdfphp345pythony_py"#源字符串
result1 = re.search(pattern1,string)
result2= re.search(pattern2,string)
result3 = re.search(pattern3,string)
result4 = re.search(pattern4,string)
print(result1)
print(result2)
print(result3)
print(result4)

None
<_sre.SRE_Match object; span=(0, 3), match='abc'>
<_sre.SRE_Match object; span=(19, 21), match='py'>
None

(3) 限定符

限定符也是元子符中的一種，常見的限定符包括*、?、+、{n}、{n,}、{n,m}

• 看如下例子

import re 
pattern1 = "py.*n"
pattern2 = "cd{2}"
pattern3 ="cd{3}"
pattern4 = "cd{2, }"
string = "abcdddfphp345pythony_py"
result1 = re.search(pattern1,string)
result2= re.search(pattern2,string)
result3 = re.search(pattern3,string)
result4 = re.search(pattern4,string)
print(result1)
print(result2)
print(result3)
print(result4)

<_sre.SRE_Match object; span=(13, 19), match='python'>
<_sre.SRE_Match object; span=(2, 5), match='cdd'>
<_sre.SRE_Match object; span=(2, 6), match='cddd'>
None

(4) 模式選擇符

來看模式選擇符「|」，使用模式選擇符，能夠設置多個模式，匹配時可從中選擇任意一個模式匹配。好比正則表達式「python|php」中，字符串「python」和「php」均知足匹配條件

#模式匹配符示例
import re 
pattern = "python|php"
string ="abcdfphp345pythony_py" 
result = re.search(pattern,string)
print(result)
#能夠看出，從源字符串中匹配到告終果「php」

<_sre.SRE_Match object; span=(5, 8), match='php'>

3 模式修正

• 模式修正符，就是能夠在不改變正則表達式的狀況下，經過模式修正符改變正則表達式的含義，從而實現一些匹配結果的調整等功能。
  經常使用的模式修正符：

符號	含義
I	匹配時忽略大小寫
M	多行匹配
L	作本地化識別匹配
U	根據Unicode字及解析字符
S	讓.匹配包括換行符，即用了該模式修正後，「.」匹配就能夠匹配任意的字符了

import re 
pattern1 = "python"
pattern2 = "python"
string = "abcdfphp345Pythony_py"
result1 = re.search(pattern1,string)
result2= re.search(pattern2,string,re.I)#忽略大小寫
print(result1)
print(result2)

None
<_sre.SRE_Match object; span=(11, 17), match='Python'>

import re
pattern = "\t"
string = '''http://yum.iqianyue.com
http://baidu.com'''
resultl = re.search(pattern,string)
print(resultl)

None

4 貪婪模式與懶惰模式

總的來講，貪婪模式就是的核心就是儘量多的匹配，而懶惰模式就是儘量少的匹配。
可看下面的示例：

import re 
pattern1 = "p.*y"#貪婪模式
pattern2 = "p.*? y"#懶惰模式
string = "abcdfphp345pythony_py"
result1= re.search(pattern1,string)
result2=re.search(pattern2,string)
print(result1)#找到結尾字符y才中止，即找到最後一個y字符才中止
print(result2)#一旦找到了字符y就中止

<_sre.SRE_Match object; span=(5, 21), match='php345pythony_py'>
None

5 正則表達式常見函數

常見的表達式函數有：re.match()函數、re.search()函數、全局匹配函數、re.sub()函數.

(1) re.match()函數

從源字符的起始位置匹配一個模式，就用re.match()函數，其格式爲：re.match(pattern,string,flag),第一個參數表示對應的正則表達式，第二個表示源字符，第三個是可選參數，表示對應的標誌位，能夠放模式修正等信息.

import re
pattern = ".python"
string = "apythonhellomypythonhispythonourpythononend"
result1=re.match(pattern,string)
result2 = re.match(pattern,string).span()#經過.span()能夠過濾掉一些信息，只留下匹配成功的結果在源字符串中的位置
print(result1)
print(result2)

<_sre.SRE_Match object; span=(0, 7), match='apython'>
(0, 7)

(2) re.search()函數

用該函數進行匹配，會掃描整個源字符串並進行對應的匹配。
與re.match()函數的不一樣之處，該函數在全文中進行檢索匹配，而re.match()函數是從源字符串的開頭進行匹配。

import re
pattern = ".python"
string = "hellomypythonhispythonourpythononend"
result1=re.match(pattern,string)
result2 = re.search(pattern,string)
print(result1)
print(result2)

None
<_sre.SRE_Match object; span=(6, 13), match='ypython'>

(3) 全局匹配函數

• 就是將符合模式的內容所有都匹配出來.思路：
• 1.使用re.compile()對正則表達式進行編譯
• 2.編譯後，使用indall()根據正則表達式從源字符中將匹配的結果所有找出

import re
string = "hellomypythonhispythonourpythonend"
pattern =re.compile(".python.")#預編譯
result =pattern.findall(string)#找出全部符合模式的結果
print(result)

['ypythonh', 'spythono', 'rpythone']

#對上式的整合
import re
string = "hellomypythonhispythonourpythonend"
pattern = ".python."
result =re.compile(pattern).findall(string)
print(result)

['ypythonh', 'spythono', 'rpythone']

(4) re.sub()函數

根據正則表達式實現替換某些字符串的功能，可使用re.sub()函數實現，其格式爲：re.sub(pattern,rep,string,max), 第一個參數表示對應的正則表達式，第二個參數表示要替換成的字符串，第三個參數表示爲源字符串，第四個表示可選項，表明最多替換的次數，若忽略不寫的話，會將符合模式的結果所有替換

import re
string = "hellomypythonhispythonourpythonend"
pattern = "python."
result = re.sub(pattern,"php",string)
result2=re.sub(pattern,"php",string,)
print(result1)
print(result2)

<_sre.SRE_Match object; span=(5, 19), match='php345pytho_py'>
hellomyphpisphpurphpnd