python正則re模塊

歡×××陳師傅”

re正則處理

正則定義

正則表達式是對字符串操作的一種邏輯公式，就是用事先定義好的一些特定字符、及這些特定字符的組合，組成一個“規則字符串”，這個“規則字符串”用來表達對字符串的一種過濾邏輯。

常用正則表達式的方法

• re.compile(編譯)
• pattern.match(從頭匹配)
• pattern.search(匹配一個)
• pattern.findall(匹配所有)
• pattern.sub(替換)

特殊字符集

正則表達式方法

• re.compile(pattern,flags=0)
  編譯一個正則表達式模式為正則表達式對象，其可用于使用他的匹配match(),search()以及其他方法

  >>> comp=re.compile(r'\d+')
  >>> ret=comp.match('123456')
  >>> ret.group()
  '123456'

  相當于

  ret=re.match(r'\d+','123456')

• re.search(pattern,string,flags = 0)
  查找正則表達式匹配到的第一個位置，并返回相應的匹配對象

• re.match(pattern,string,flags = 0)
  從字符串的開頭匹配，并返回相應的匹配對象

• re.fullmatch(pattern,string,flags = 0)
  將會對整個字符串進行匹配，并返回相應的匹配對象

• re.split(pattern,string,maxsplit = 0,flags = 0)
  按照正則匹配模式進行拆分字符串,maxsplit為最多拆分次數，并且字符串的其余部分將作為列表的最后一個元素返回，如果分隔符中有捕獲組并且它在字符串的開頭或者結尾匹配，則結果將以空字符串開頭。

  >>> re.split(r'\W+','Words words wordS')
  ['Words', 'words', 'wordS']
  >>> re.split(r'\W+','Words words wordS',1)
  ['Words', 'words wordS']
  >>> re.split(r'\d+','1q2W3e4R',flags=re.IGNORECASE)
  ['', 'q', 'W', 'e', 'R']
  >>> re.split(r'(\W+)', 'words, words...')
  ['words', ', ', 'words', '...', '']
  >>> re.split(r'\W+', 'words, words...')
  ['words', 'words', '']

• re.findall(pattern,string,flags=0)
  從左往右匹配，返回一個列表，如果模式中存在一個或多個組，則返回組列表; 如果模式有多個組，這將是一個元組列表。結果中包含空匹配。

  >>> re.findall(r'\d+','123,456')
  ['123', '456']
  >>> re.findall(r'(\d+)(\w+)','123qw,werrc')
  [('123', 'qw')]
  >>> re.findall(r'(\d+)|(\w+)','123qw,werrc')
  [('123', ''), ('', 'qw'), ('', 'werrc')]

• re.finditer(pattern,string,flags = 0 )
  返回一個匹配到每個結果的迭代器

  >>> for i in re.finditer(r'\d+','123456'):
  print(i.group())
  123456

• re.sub(pattern,repl,string,count = 0,flags = 0 )
  將匹配到的字符串替換成repl的值，count表示要替換的模式最多替換次數，repl可以是一個字符串也可以是一個函數，當repl為字符串時，會處理其中的任何反斜杠，，可以使用\id或\g< id>、\g< name>引用分組

  >>> re.sub(r'(\d+) (\w+)',r'\2 \1','12345 asdfd')
  'asdfd 12345'

  當repl是一個函數時，那么這個函數會只接受一個匹配對象參數。例如：

>>> def mat(m):
    if m.group(2)=='1234':
        return m.group(1)
    else:
        return '1234'

>>> re.sub(r'(\d+) (\d+)',mat,'123 1234qer')
'123qer'
>>> re.sub(r'(\d+) (\d+)',mat,'123 123qer')
'1234qer'

• re.subn(pattern,repl,string,count = 0,flags = 0 )
  與sub執行的操作相同，但是返回的是元組，元組最后一個元素為替換次數

  >>> def mat(m):
  if m.group(2)=='1234':
      return m.group(1)
  else:
      return '1234'
  >>> re.subn(r'(\d+) (\d+)',mat,'as123 1234qer')
  ('as123qer', 1)

  正則表達式對象

  使用re.compile可以編譯一個正則表達式對象

• regex.search(string[,pos[endpos]])
  查找正則表達式匹配到的第一個位置，并返回相應的匹配對象可選參數pos和endpos表示設置正則表達式匹配的字符串開始位置和結束位置

  >>> pattern=re.compile(r'\d+')
  >>> pattern.search('123456',2,5).group()                   
  '345'

• regex.match(string,posendpos)
  如果字符串開頭的零個或多個字符與此正則表達式匹配，則返回相應的匹配對象。pos和endpos用法和regex.search()意思相同
• 編譯的正則表達式的方法和屬性與正則匹配的函數相同，這里不一一說明

  編譯對象的常用參數

• re.A(re.ASCII)
  使\w,\W,\b,\B,\d,\D,\s和\S只匹配ASCII字符，而不匹配Unicode字符
• re.I(re.IGNORECASE)
  匹配時不區分大小寫
• re.L(re.LOCALE)'
  使\w \W \b \B \s \S \d \D和區分大小寫的匹配只取決于當前的環境設定
• re.M(re.MULTILINE)
  多行模式下，'^'和'$'由原來匹配字符串的開頭或者結尾變成匹配每行的開頭和結尾
• re.S(re.DOTALL)
  使'.'匹配包含換行符的任何字符
• re.X(re.VERBOSE)
  這個模式下正則表達式可以是多行，忽略空白字符，并可以加入注釋。以下兩個正則表達式是等價的

  a = re.compile(r"""\d +  # the integral part
                 \.    # the decimal point
                 \d *  # some fractional digits""", re.X)
  b = re.compile(r"\d+\.\d*")

match對象

• match.group([ group1,... ] )
  返回匹配的一個或多個子組，如果只有一個參數，則結果為單個字符串; 如果有多個參數，則結果是一個元組，每個參數有一個項目。如果沒有參數，group1默認為零（返回整個匹配）。 如果groupN參數為零，則相應的返回值是整個匹配的字符串

  >>> s=re.match(r'(\w+) (\w+)','hello world')
  >>> s.group(0)
  'hello world'
  >>> s.group(1)
  'hello'
  >>> s.group(2)
  'world'
  >>> s.group(1,0)
  ('hello', 'hello world')

  如果分組太多，我們可以對分組進行命名

  >>> m=re.match(r"(?P<first>\w+) (?P<second>\w+)",'hello world')
  >>> m.group('first')
  'hello'
  >>> m.group('second')
  'world'

  如果一個組匹配多次，那么最終將返回的最后一次匹配到的字符串

  >>> m=re.match(r'(\d)+','123456')
  >>> m.group()
  '123456'
  >>> m.group(1)
  '6'

• match. getitem(g)
  與m.group(g)相同，這樣使用會更簡單

  >>> m=re.match(r'(\d)+','123456')
  >>> m[0]
  '123456'
  >>> m[1]
  '6'

• match.groups(default=None)
  以元組的形式返回匹配到的所有子組，沒有被匹配到的分組，默認為None,當然可以設置默認參數

  >>> m=re.match(r'(\d+),(\w+)?','1234,')
  >>> m.groups()
  ('1234', None)
  >>> m.groups('0')
  ('1234', '0')

• match.groupdict(default=None)
  以字典的形式返回匹配到的值，字典的鍵為分組名，值為匹配到的字符串，沒有匹配到的分組將設置為None

  >>> m=re.match(r'(?P<first>\d+) (?P<second>\d+)','123 456')
  >>> m.groupdict()
  {'first': '123', 'second': '456'}
  >>> m=re.match(r'(\d+) (\d+)','123 456')
  >>> m.groupdict()
  {}

• match.start([group]) 和match.end([group])
  分別返回由分組匹配到的字符串的開始和結束的索引，結束字符串的索引為最后一個子符的索引加一group默認為零，將會表示所有匹配到的字符串

  >>> m=re.match(r'(\w+) (\w+) (\w+) (\w+)','my name is wanger')
  >>> m.start(2)                 
  3
  >>> m.end(2)                   
  7
  >>> m.end()                
  17
  >>> m.start()                  
  0

• match.span[group]
  返回一個二元組，元組的元素為分組匹配到的字符串開始的索引和結束的索引，group默認為0，表示匹配到的所有字符串

  >>> m=re.match(r'(\w+) (\w+) (\w+) (\w+)','my name is wanger')
  >>> m.span(2)                      
  (3, 7)
  >>> m.span()                   
  (0, 17)

• match.pos 和match.endpos
  分別返回要匹配字符串的開始搜索的索引和結束搜索的索引

  >>> m=re.match(r'(\w+) (\w+) ','my name is wanger')
  >>> m.pos                  
  0
  >>> m.endpos                   
  17

• match.lastindex
  最后匹配到的分組的索引

  >>> m=re.match(r'(\w+) (\w+) ','my name is wanger')
  >>> m.lastindex                
  2
  >>> m=re.match(r'(\w+) (\w+) (\w+)','my name is wanger')                       
  >>> m.lastindex                    
  3

• match.lastgroup
  最后匹配到的分組的名稱,沒有命名組則返回空

  >>> m=re.match(r'(\w+) (?P<last>\w+) ','my name is wanger')                
  >>> m.lastgroup                
  'last'

幾個簡單的實例

1. 匹配前面是數字123的字符

   >>> re.search(r'(?<=123)\w+','123asd,wer').group(0) 'asd'

   2.匹配前面是數字后面是下劃線的字符

   >>> re.search(r'(?<=123)\w+(?=_)','123asd_123wer').group(0)                
   'asd'

   3.匹配手機號碼

   >>> re.match(r'1[3,5,7,8]\d{9}|','13573528479').group()                
   '13573528479'

   4.匹配電話號碼

   >>> re.match(r'\d{3}-\d{8}|\d{4}-\d{7}','0531-82866666').group()                   
   '0531-8286666'

   5.匹配IP地址

   >>> re.match(r'\d+\.\d+\.\d+\.\d+','192.168.10.25').group()                    
   '192.168.10.25'

   6.匹配網易郵箱

>>> re.findall(r'\w+@163\.com|\w+@126\.com','wanger@163.com wanger@126.com')

['wanger@163.com', 'wanger@126.com']

7.匹配HTML文本

>>> re.match(r'<(\w*)><(\w*)>.*</\2></\1>','<body><h3>wahaha5354</h3></body>').group()
'<body><h3>wahaha5354</h3></body>'

歡迎各位關注本人微信公眾號“沒有故事的陳師傅”