來,一分鐘搞定正則表達式!
首先,先了解正則表達式的整體知識框架,明確其作用和匹配的分類,以及如何重複使用正則表達的方法。
由上圖可知,正則表達式的作用是用於字符串匹配、替換和分割。對於替換和分割相對來說,使用python中的re實現比較簡單,將會在最後用例子進行簡單展示。重點是理解匹配這塊,下面將詳細講解匹配。
一、匹配
首先,對於匹配而言,可分爲單匹配、全匹配,單匹配是指在字符串中找到一個符合條件的元素即可,全匹配是指匹配到所有符合條件的元素。然後,爲了重複使用同一個正則表達式,還可以採用指定的格式來實現效果。
1.1 單匹配
單匹配中分爲簡單匹配、靈活匹配、按類型匹配、重複匹配、分組匹配這五個方面。
- 簡單匹配:直接採用指定字符串進行搜索,即’ '。re.search(‘cat’,‘dog run to cat’);
- 靈活匹配:按照正式的正則表示方式進行匹配,即r’ '的形式。re.search(r’cat’,‘dog run to cat’);
- 按類型匹配:爲了規定選擇是數字、字母還是任意字符。
- 重複匹配:爲規定一個元素是零個、一個還是多個匹配。
- 分組匹配:分組匹配便於後期的查詢。
1.1.1 簡單匹配
按照給定的字符串,在目標字符串找到符合條件的元素。
因爲較爲簡單,直接上例子,來:
import re
#簡單匹配
pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
print(re.search(pattern1, string)) # <_sre.SRE_Match object; span=(12, 15), match='cat'>
print(re.search(pattern2, string)) # None
1.1.2 靈活匹配
中規中矩地用正則表達式的格式,設置匹配格式,即r’ '。
來看下面這個例子:
import re
ptn = r"r[au]n" #按格式進行匹配,意爲匹配ran或者run
print(re.search(ptn, "dog runs to cat")) # 匹配結果爲:<_sre.SRE_Match object; span=(4, 7), match='run'>
print(re.search(ptn, "dog rauns to cat")) # None,不存在ran或者run
#還有下面的例子
print(re.search(r"r[A-Z]n", "dog runs to cat")) # None
print(re.search(r"r[a-z]n", "dog runs to cat")) # <_sre.SRE_Match object; span=(4, 7), match='run'>
print(re.search(r"r[0-9]n", "dog r2ns to cat")) # <_sre.SRE_Match object; span=(4, 7), match='r2n'>
print(re.search(r"r[0-9a-z]n", "dog run r2an to cat")) # <_sre.SRE_Match object; span=(4, 7), match='run'>
1.1.3 按類型匹配
首先,先了解每個規定類型的含義:
\d : 任何數字
\D : 不是數字
\s : 任何 white space, 如 [\t\n\r\f\v]
\S : 不是 white space
\w : 任何大小寫字母, 數字和 “” [a-zA-Z0-9]
\W : 不是 \w
\b : 空白字符 (只在某個字的開頭或結尾)
\B : 空白字符 (不在某個字的開頭或結尾)
\\ : 匹配 \
. : 匹配任何字符 (除了 \n)
^ : 匹配開頭
$ : 匹配結尾
? : 前面的字符可有可無
然後,再來看幾個實例:
# \d : decimal digit
print(re.search(r"r\dn", "run r4n")) # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \D : any non-decimal digit
print(re.search(r"r\Dn", "run r4n")) # <_sre.SRE_Match object; span=(0, 3), match='run'>
# \s : any white space [\t\n\r\f\v]
print(re.search(r"r\sn", "r\nn r4n")) # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \S : opposite to \s, any non-white space
print(re.search(r"r\Sn", "r\nn r4n")) # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \w : [a-zA-Z0-9_]
print(re.search(r"r\wn", "r\nn r4n")) # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \W : opposite to \w
print(re.search(r"r\Wn", "r\nn r4n")) # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \b : empty string (only at the start or end of the word)
print(re.search(r"\bruns\b", "dog runs to cat")) # <_sre.SRE_Match object; span=(4, 8), match='runs'>
# \B : empty string (but not at the start or end of a word)
print(re.search(r"\B runs \B", "dog runs to cat")) # <_sre.SRE_Match object; span=(8, 14), match=' runs '>
# \\ : match \
print(re.search(r"runs\\", "runs\ to me")) # <_sre.SRE_Match object; span=(0, 5), match='runs\\'>
# . : match anything (except \n)
print(re.search(r"r.n", "r[ns to me")) # <_sre.SRE_Match object; span=(0, 3), match='r[n'>
# ^ : match line beginning
print(re.search(r"^dog", "dog runs to cat")) # <_sre.SRE_Match object; span=(0, 3), match='dog'>
# $ : match line ending
print(re.search(r"cat$", "dog runs to cat")) # <_sre.SRE_Match object; span=(12, 15), match='cat'>
# ? : may or may not occur
print(re.search(r"Mon(day)?", "Monday")) # <_sre.SRE_Match object; span=(0, 6), match='Monday'>
print(re.search(r"Mon(day)?", "Mon")) # <_sre.SRE_Match object; span=(0, 3), match='Mon'>
#當存在多行時,匹配首字符,可以採用frags=re.M,M表示多行的意思
string = '''dog run to cat,
I run to dog.
'''
print(re.search(r'^I',string))#None
print(re.search(r'^I',string,flags=re.M))#<re.Match object; span=(16, 17), match='I'>
1.1.4 重複匹配
* : 重複零次或多次
+ : 重複一次或多次
{n, m} : 重複 n 至 m 次
{n} : 重複 n 次
來看個例子:
import re
print(re.search(r"ab*", "a")) # <_sre.SRE_Match object; span=(0, 1), match='a'>
print(re.search(r"ab*", "abbbbb")) # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>
# + : occur 1 or more times
print(re.search(r"ab+", "a")) # None
print(re.search(r"ab+", "abbbbb")) # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>
# {n, m} : occur n to m times
print(re.search(r"ab{2,10}", "a")) # None
print(re.search(r"ab{2,10}", "abbbbb")) # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>
1.1.5 分組匹配
主要使用()可實現分組效果。直接看例子:
import re
match = re.search(r"(\d+), Date: (.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group()) # 021523, Date: Feb/12/2017
print(match.group(1)) # 021523
print(match.group(2)) # Date: Feb/12/2017
# ?P<名字> 就給這個組定義了一個名字
match = re.search(r"(?P<id>\d+), Date: (?P<date>.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group('id')) # 021523
print(match.group('date')) # Date: Feb/12/2017
1.2 全匹配
1.1節中採用的re.search()是單個匹配,找到符合條件的後就不再搜索。想要到達全部查找,可使用re.findall()。
來,上例子:
import re
# findall
print(re.findall(r"r[ua]n", "run ran ren")) # ['run', 'ran']
# | : or
print(re.findall(r"(run|ran)", "run ran ren")) # ['run', 'ran']
1.3 重複使用正則匹配
如果重複使用同一個正則,可採用re.compile() 。
來,上例子:
import re
#重複使用正則
compiled_re = re.compile(r"r[ua]n")
print(compiled_re.search("dog ran to cat")) # <_sre.SRE_Match object; span=(4, 7), match='ran'>
二、分割
分割也屬於匹配的一種,先是找個符合條件的元素,去除已匹配到的元素,剩下的元素存儲到數組中。
採用re.split(),來,上例子:
import re
print(re.split(r"[,;\.]", "a;b,c.d;e"))#由於.本身表示任意字符,需要用轉移字符'\'區分
# 結果:['a', 'b', 'c', 'd', 'e']
print(re.split(r"[,;\.]", "a;b,c.d.f,h;e"))
#結果:['a', 'b', 'c', 'd', 'f', 'h', 'e']
三、替換
先匹配到指定字符,再進行相應的替換。
採用re.sub(),只能匹配到第一個滿足條件的元素,並給予替換。
來,上例子:
import re
print(re.sub(r"r[au]ns", "catches", "dog runs to cat"))
#結果:dog catches to cat
print(re.sub(r"r[au]ns", "catches", "dog runs run ran to cat"))
#結果:dog catches run ran to cat
好啦!一分鐘的正則表達式解釋完啦,嘿嘿,不知道看完後懂了沒?