正則表達(dá)式

1.原子

2.元字符

3.模式修正

4.貪婪模式

5.懶惰模式

1.原子

原子是正則表達(dá)式中最基本的組成單位,每個(gè)正則表達(dá)式中至少要包含一個(gè)原子,
常見的原子有一下幾類:

1. 普通字符作為原子

2. 非打印字符作為原子

3. 通用字符作為原子

4. 原子表

5. 普通字符作為原子
   一些普通字符,例如:字母,數(shù)字,下劃線都可以作為原子.

     import re
     pattern = "test" # 普通字符作為原子
     string = "asdfatestsdfasd"
     result1 = re.search(pattern, string)
     print(result1)

     <_sre.SRE_Match object; span=(5, 9), match='test'>

2. 非打印字符作為原子
   非打印字符就像換行符之類的符號(hào).

     import re
     pattern = '\n'
     string = '''http://baidu.com
test'''
     result1 = re.search(pattern, string)
     print(result1) 

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

     #!/usr/bin/env python3
     import re
     pattern = '\n'
     string = '''http://baidu.com
     test
     test'''
     result1 = re.search(pattern, string)
     print(result1)
     
     <_sre.SRE_Match object; span=(16, 17), match='\n'>

 但是即使有多個(gè)換行符也只能匹配到一個(gè).

3. 通用字符作為原子
   通用字符可以匹配一類字符,經(jīng)常用到.

#!/usr/bin/env python3
import re

string1 = 'asdfas234234234python234234_py'
string2 = 'asdfas234234234\npython234234_py'

pattern1 = '\w\dpython'
pattern2 = '\Wpython'
pattern3 = '\dpython'
pattern4 = '\Dpython'
pattern5 = '\s'
pattern6 = '\S'

result1 = re.search(pattern1, string1)
result2 = re.search(pattern2, string2)
result3 = re.search(pattern3, string1)
result4 = re.search(pattern4, string1)
result5 = re.search(pattern5, string2)
result6 = re.search(pattern6, string2)

print(result1)
print(result2)
print(result3)
print(result4)
print(result5)
print(result6)

    <_sre.SRE_Match object; span=(13, 21), match='34python'>
<_sre.SRE_Match object; span=(15, 22), match='\npython'>
<_sre.SRE_Match object; span=(14, 21), match='4python'>
None
<_sre.SRE_Match object; span=(15, 16), match='\n'>
<_sre.SRE_Match object; span=(0, 1), match='a'>

4. 原子表
   使用原子表,可以定義一組地位平等的原子,然后匹配時(shí)會(huì)去該原子表中的任意一個(gè)原子
   進(jìn)行匹配,在python中,原子表由[]表示,例如[xyz]就是一個(gè)原子表,在這個(gè)原子表中定義
   了3個(gè)原子,這3個(gè)原子的地位平等,如

#!/usr/bin/env python3
import re

string1 = 'asdfas234234234python234234_py'

pattern1 = '[1234]python'
pattern2 = '[opq]ython'

result1 = re.search(pattern1, string1)
result2 = re.search(pattern2, string1)

print(result1)
print(result2)
 類似的,[^]代表的是除了中括號(hào)里面的原子均可以匹配,比如
#!/usr/bin/env python3
import re

string1 = 'asdfas234234234pythony234234_py'

pattern1 = '\w\dpython[xyz]\w'
pattern2 = '\w\dpython[^xz]\w'
pattern3 = '\w\dpython[xyz]\W'

result1 = re.search(pattern1, string1)
result2 = re.search(pattern2, string1)
result3 = re.search(pattern3, string1)

print(result1)
print(result2)
print(result3)

<_sre.SRE_Match object; span=(13, 23), match='34pythony2'>
<_sre.SRE_Match object; span=(13, 23), match='34pythony2'>
None

2.元字符
元字符就是正則表達(dá)式中含有一些特殊意義的字符,比如重復(fù)N次前面的字符
元字符可以分成五類:

1. 任意匹配元字符 如:"."
2. 邊界限制元字符 如:"^"和"$"
3. 限定符 如:"*","?","+","{n}","{n,}","{n,m}"
4. 模式選擇符 如:"|"
5. 模式單元符 如:"()"
   常見的元字符及含義

一些使用例子:

  #!/usr/bin/env python3
  import re
  pattern = '.python...'
  string = 'bacdefphp345python_py'
  result = re.search(pattern, string)
  print(result)

  <_sre.SRE_Match object; span=(11, 21), match='5python_py'>
 ------------------------------------------------------------- 
  #!/usr/bin/env python3
  import re
  pattern1 = '^abd'   # 從字符串的開始去找abd
  pattern2 = '^abc'   # 從字符串的開始去找abc
  pattern3 = 'py$'    # 從字符串的結(jié)尾去找py
  pattern4 = 'ay$'    # 從字符串的尾部去找ay
  string = 'abcdfphp345python_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=(18, 20), match='py'>
  None
 -------------------------------------------------------------  
  #!/usr/bin/env python3
  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'>
  <_sre.SRE_Match object; span=(2, 6), match='cddd'>
 -------------------------------------------------------------
  #!/usr/bin/env python3
  import re
  pattern1 = 'python|php'   
  string = 'abcdddfphp345pythony_py'
  result1 = re.search(pattern1, string)
  print(result1)

  <_sre.SRE_Match object; span=(7, 10), match='php'>
 -------------------------------------------------------------
  #!/usr/bin/env python3
  import re
  pattern1 = '(cd){1,}'   
  pattern2 = 'cd{1,}'
  string = 'abcdcdcddfphp345pythony_py'
  result1 = re.search(pattern1, string)
  result2 = re.search(pattern2, string)
  print(result1)
  print(result2)

  <_sre.SRE_Match object; span=(2, 8), match='cdcdcd'>
  <_sre.SRE_Match object; span=(2, 4), match='cd'>
 -------------------------------------------------------------

3.模式修正
模式修正符:可以在不改變正則表達(dá)式的情況下,通過模式修正符改變正則表達(dá)式的含義,
從而實(shí)現(xiàn)一些匹配結(jié)果的調(diào)整等功能.
常見模式修正符

  #!/usr/bin/env python3
  import re
  pattern1 = 'python'   
  pattern2 = 'python'
  pattern3 = 'Pythony.'
  string = 'abcdfphp345Pythony_py'
  result1 = re.search(pattern1, string)
  result2 = re.search(pattern2, string, re.I)
  result3 = re.search(pattern3, string, re.S)
  print(result1)
  print(result2)
  print(result3)

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

4.貪婪模式與懶惰模式
貪婪模式就是盡可能多的匹配
懶惰模式就是盡可能少的匹配

  #!/usr/bin/env python3
  import re
  pattern1 = 'p.*y'   
  pattern2 = 'p.*?y'
  string = 'abcdfphp345Pythony_py'
  result1 = re.search(pattern1, string)
  result2 = re.search(pattern2, string)
  print(result1)
  print(result2)
  
  <_sre.SRE_Match object; span=(5, 21), match='php345Pythony_py'>
  <_sre.SRE_Match object; span=(5, 13), match='php345Py'>

正則表達(dá)式常見函數(shù):re.match(), re.search(), 全局匹配函數(shù), re.sub()

1. re.match()
   從源字符串的起始位置匹配一個(gè)模式,我們可以使用re.match()
   re.match(pattern, string, flag)
   pattern:對(duì)應(yīng)的表達(dá)式
   string: 源字符串
   flag: 可選,對(duì)應(yīng)的標(biāo)志位,可放模式修正符

   import re
   string = 'apythonhellomypythonhispythonourpythonend'
   pattern = '.python'
   result = re.match(pattern, string)
   result2 = re.match(pattern, string).span()
   print(result)
   print(result2) 
   
   <_sre.SRE_Match object; span=(0, 7), match='apython'>
   (0, 7)

2. re.search()
   使用該函數(shù)進(jìn)行匹配,會(huì)掃描整個(gè)字符串進(jìn)行對(duì)應(yīng)的匹配. re.match()從源字符串的
   開頭進(jìn)行匹配,而re.search()會(huì)在全文進(jìn)行檢索并匹配.

   import re
   string = 'hellomypythonhispythonourpythonend'
   pattern = '.python.'
   result = re.match(pattern, string)
   result2 = re.search(pattern, string)
   print(result)
   print(result2)

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

re.mathc()從頭開始匹配,而開頭不符合正則表達(dá)式,所以返回None

3. 全局匹配函數(shù)
   前面兩個(gè)函數(shù)即使源字符串中多個(gè)結(jié)果符合模式,也只會(huì)返回一個(gè)結(jié)果.
   怎么把所有的內(nèi)容全部匹配出來?
   思路如下:
   1. 使用re.compile()對(duì)正則表達(dá)式進(jìn)行編譯
   2. 編譯后,使用findall()根據(jù)正則表達(dá)式從源字符串中將匹配結(jié)果全部找出

   import re
   string = 'hellomypythonhispythonourpythonend'
   pattern = re.compile('.python.') # 預(yù)編譯
   result = pattern.findall(string) # 找出符合模式的所有結(jié)果
   print(result) 
   
   ['ypythonh', 'spythono', 'rpythone']

也可以將兩步合并到一步

   import re
   string = 'hellomypythonhispythonourpythonend'
   result = re.compile('.python.').findall(string) # 找出符合模式的所有結(jié)果
   print(result)

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

4. re.sub()
   用來實(shí)現(xiàn)字符串替換功能
   re.sub(pattern, rep, string, max)
   pattern: 正則表達(dá)式
   rep: 為要替換成的字符串
   string: 源字符串
   max: 為可選項(xiàng),代表最多替換的次數(shù),如果忽略不寫,則會(huì)將符合模式的結(jié)果全部替換

   import re
   string = 'hellomypythonhispythonourpythonend'
   pattern = 'python.'
   result = re.sub(pattern, 'php', string)  # 全部替換
   result2 = re.sub(pattern, 'php', string, 2)      # 最多替換2次
   print(result)
   print(result2)

   hellomyphpisphpurphpnd
   hellomyphpisphpurpythonend