【python】正則表達式

參考資料：http://deerchao.net/tutorials/regex/regex.htm

1、正則表達式基礎

2、python 正則表達式

1、正則表達式基礎

元字符：

其他語法：

    （1）字符轉義

           如果你想查找元字符本身的話，比如你查找.,或者*,就出現了問題：你沒辦法指定它們，因為它們會被解釋成別的意思。這時你就得使用\來取消這些字符的特殊意義。因此，你應該使用\.和\*。當然，要查找\本身，你也得用\\.

例如C:\\Windows 匹配C:\Windows

   （2）分組——用小括號來指定子表達式(也叫做分組)

           例如：(\d{1,3}\.){3}\d{1,3}是一個簡單的IP地址匹配表達式，\d{1,3}匹配1到3位的數字，(\d{1,3}\.){3}匹配三位數字加上一個英文句號(這個整體也就是這個分組)重復3次，最后再加上一個一到三位的數字(\d{1,3})。不幸的是，它也將匹配256.300.888.999這種不可能存在的IP地址。選擇，字符類來描述一個正確的IP地址為：((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)。

    （3）貪婪與懶惰

            當正則表達式中包含能接受重復的限定符時，通常的行為是（在使整個表達式能得到匹配的前提下）匹配盡可能多的字符。以這個表達式為例：a.*b，它將會匹配最長的以a開始，以b結束的字符串。如果用它來搜索aabab的話，它會匹配整個字符串aabab。這被稱為貪婪匹配。

           有時，我們更需要懶惰匹配，也就是匹配盡可能少的字符。前面給出的限定符都可以被轉化為懶惰匹配模式，只要在它后面加上一個問號?。這樣.*?就意味着匹配任意數量的重復，但是在能使整個匹配成功的前提下使用最少的重復。現在看看懶惰版的例子吧：a.*?b匹配最短的，以a開始，以b結束的字符串。如果把它應用於aabab的話，它會匹配aab（第一到第三個字符）和ab（第四到第五個字符）。

2、python正則表達式

實例:1：（search和match與sub）

# encoding:utf-8
'''
Created on 2014-6-18

@author: Administrator
'''
import re

class Regex(object):
    def regex_match(self):
        pattern = "\w+@\w+.*(\w+)\.com"  # 匹配郵箱
        mt = re.match(pattern, "[e-mail]")
        if mt:
            print mt.group()
            print mt.groups()
        else:
            print "no match"
        
    def regex_search(self):
        mt = re.search(r"\Bl(.?){2}", "hello world!")
        if mt:
            print mt.group()
        else:
            print "no match"
            
    def regex_sub(self):
        ret = re.sub("X", "Mr Smith", "attention:X\n\nDear X,\n")
        print ret
        ret = re.subn("X", "Mr Smith", "attention:X\n\nDear X,\n")
        print ret
        
if __name__ == "__main__":
    regex = Regex()
    regex.regex_match()
    regex.regex_search()
    regex.regex_sub()

結果：

結論：

       match：從字符串開頭開始對模式進行匹配，成功返回匹配對象，否則返回None

       search：在字符串string中搜索正則表達式模式pattern第一次出現的字符串

       sub：把字符串中匹配正則表達式pattern的地方替換為新字符串

 

實例2：（split）

# encoding:utf-8
'''
Created on 2014-6-18

@author: Administrator
'''

import re
class RegexLs(object):
    """使用正則表達式解析Unix命令ls -al的結果"""
    
    def __init__(self, path):
        try:
            self.fl = open(path)
        except Exception :
            print "文件" + path + "打開出錯！"

    def analy_file(self):
        pattern = "\s+|\t"
        for line in self.fl:
            print re.split(pattern, line.strip())

    def __del__(self):
        self.fl.close()


if __name__ == "__main__":
    path = "ls.txt"
    regex_ls = RegexLs(path)
    regex_ls.analy_file()

其中Unix命令：ls –al    生成結果格式：

 

結論：

      split，根據正則表達式pattern中的分隔符把字符串string分隔為一個列表

 

實例3：（惰性匹配）

# encoding:utf-8
'''
Created on 2014-6-18

@author: Administrator
'''
from random import randint, choice
from sys import maxint
from time import ctime
from string import lowercase
import re

class RegexExample(object):
    def __init__(self):
        self.doms = ('com', 'edu', 'net', 'org', 'gov')
        self.format_list = []
        
    def get_string(self):
        for i in range(randint(5, 10)):
            dtint = randint(0, maxint - 1)
            dtstr = ctime(dtint)
            shorter = randint(4, 7)
            
            em = ""
            for j in range(shorter):
                em += choice(lowercase)
            
            longer = randint(shorter, 12)
            dn = ""
            for j in range(longer):
                dn += choice(lowercase)
            
            string = "%s::%s@%s.%s::%d-%d-%d" % (dtstr, em, dn, choice(self.doms), dtint, shorter, longer)
#             print string
            self.format_list.append(string)
            
    def get_last(self):
        pattern = ".+?(\d+-\d+-\d+)"
        for elem in self.format_list:
            print elem
            ps = re.search(pattern, elem)
            if ps:
                print ps.group(1)
            
if __name__ == "__main__":
    example = RegexExample()
    example.get_string()
    
    print "#"*40
    
    example.get_last()

 

執行結果：

 

結論：

      get_last()函數使用的pattern=”.*?（\d-\d-\d）”執行的是惰性匹配，其中（\d-\d-\d)為分組