python正则表达式

判断一个字符串是否是合法的Email地址，虽然可以编程提取@前后的子串，再分别判断是否是单词和域名，但这样做不但麻烦，而且代码难以复用。

1、简单的匹配规则：

a.【\d】【\w】用\d可以匹配一个数字，\w可以匹配一个字母或数字
    例如：
    '00\d'可以匹配'007'，但无法匹配'00A'；
    '\d\d\d'可以匹配'010'；
    '\w\w\d'可以匹配'py3'；

b.【.】可以匹配任意字符
    'py.'可以匹配'pyc'、'pyo'、'py!'等等

c.匹配变长的字符
    【*】用*表示任意个字符（包括0个）
    【+】用+表示至少一个字符
    【?】用?表示0个或1个字符
    【{n}】用{n}表示n个字符
    【{n,m}】用{n,m}表示n-m个字符。
    例如：\d{3}\s+\d{3,8}
        \d{3}表示匹配3个数字，例如'010'；
        \s可以匹配一个空格（也包括Tab等空白符），所以\s+表示至少有一个空格，例如匹配' '，' '等；
        \d{3,8}表示3-8个数字，例如'1234567'。
        综合起来，上面的正则表达式可以匹配以任意个空格隔开的带区号的电话号码。

        注意：如果要匹配'010-12345'这样的号码呢？由于'-'是特殊字符，在正则表达式中，要用'\'转义，所以，上面的正则是\d{3}\-\d{3,8}。
            但是，仍然无法匹配'010 - 12345'，因为带有空格。所以我们需要更复杂的匹配方式。

d.匹配范围【[]】
    [0-9a-zA-Z\_]可以匹配一个数字、字母或者下划线；
    [0-9a-zA-Z\_]+可以匹配至少由一个数字、字母或者下划线组成的字符串，比如'a100'，'0_Z'，'Py3000'等等；
    [a-zA-Z\_][0-9a-zA-Z\_]*可以匹配由字母或下划线开头，后接任意个由一个数字、字母或者下划线组成的字符串，也就是Python合法的变量；
    [a-zA-Z\_][0-9a-zA-Z\_]{0, 19}更精确地限制了变量的长度是1-20个字符（前面1个字符+后面最多19个字符）。

e.选择匹配【|】
    A|B可以匹配A或B，所以(P|p)ython可以匹配'Python'或者'python'。

f.指定开头【^】
    ^表示行的开头
    例如：^\d表示必须以数字开头。

    特别注意：[^]这个是取非的含义
    例如：
        key = r"mat cat hat pat"
        p1 = r"[^p]at"#这代表除了p以外都匹配
        pattern1 = re.compile(p1)
        print pattern1.findall(key) # 结果 ['mat', 'cat', 'hat']


g.指定结束【$】
    $表示行的结束
    例如：\d$表示必须以数字结束。

2、re模块(regular expression)：

Python提供re模块，包含所有正则表达式的功能。
特别注意：由于Python的字符串本身也用\转义，在字符串中如果有\则会出错。
    例如：

        s = "abc\\def"
        print s #打印的结果是abc\def,这样字符串就变了

        解决方法，在字符串前面加r
        s = r"abc\\def"
        print s #打印的结果就是正常的abc\\def

a.match方法匹配结果

        #_*_coding:utf-8_*_
        import re

        if __name__ == "__main__":
            s = r"010-12345"
            pattern_1 = r"^\d{3}\-\d{3,8}$" # 匹配3个数字开头，中间-分隔，3-8个数字结束
            pattern_2 = r"^\d{2}\-\d{3,8}$" # 匹配2个数字开头，中间-分隔，3-8个数字结束
            result_1 = re.match(pattern_1,s)
            result_2 = re.match(pattern_2,s)

            print result_1 # 匹配上了，打印结果为 <_sre.SRE_Match object at 0x020069F8> 是一个match对象
            print result_2 # 没有匹配上，打印的结果 None

b.使用re分隔字符串：
    我们可以直接用split方法，通过指定的符号分隔字符串。但是有个问题。
    例如：

            s = 'a b   c'
            print s.split(' ') # 打印的结果：['a', 'b', '', '', 'c']，这个并不是我们想要的结果，我们不想list中有空格

        可以用re的split方法
            s = 'a b   c'
            pattern_1 = r"\s+"
            print re.split(pattern_1,s) # 打印的结果：['a', 'b', 'c']，结果是我们想要的

        如果字符串里面有其它字符也要分隔
            s =  'a,b, c    d'
            pattern_2 = r"[\s,]+" # 只要修改这个pattern就可以
            print re.split(pattern_2, s)  # 打印的结果：['a', 'b', 'c', 'd']

    备注：正则表达式来把不规范的输入转化成正确的数组。

c.分组【()】
    我们在a里面演示了，如果匹配上了就返回一个Match对象。
    除了简单地判断是否匹配之外，正则表达式还有提取子串的强大功能。用()表示的就是要提取的分组
    例如：

            s = r"010-12345"
            pattern_group = r"^(\d{3})-(\d{3,8})$"
            m = re.match(pattern_group,s)
            print m.groups() # 打印结果：('010', '12345')
            print m.group(0) # 打印结果：010-12345 原始字符串
            print m.group(1) # 打印结果：010 第一个group
            print m.group(2) # 打印结果：12345 第二个group

        注意：这个和apattern不同的地方在于，我们加了()分组，便于后续提取

    再看一个例子，识别合法的时间

            t = '19:05:30'
            m = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', t)
            print m.groups() # 打印结果 ('19', '05', '30')

    再看一个分组的例子

            a = 'hello alex alex adn acd'
            print re.findall('(a\w+)',a) # ['alex', 'alex', 'adn', 'acd']
            print re.findall('(a)(\w+)',a) # [('a', 'lex'), ('a', 'lex'), ('a', 'dn'), ('a', 'cd')]；分了2组，每个list元素是一个元组

d.贪婪匹配
    需要特别指出的是，正则匹配默认是贪婪匹配，也就是匹配尽可能多的字符。
    例如：匹配出数字后面的0：

            s = "10023000"
            pattern = r"^(\d+)(0*)$" # 分组匹配，以数字开头，以0结束
            print re.match(pattern,s).groups() # 打印的结果：('10023000', '')
            # 由于\d+采用贪婪匹配，直接把后面的0全部匹配了，结果0*只能匹配空字符串了。
            #并不是我们需要的，我们想把数字后面的多个0匹配出来，这就需要使用非贪婪匹配了

            pattern_1 =  r"^(\d+?)(0*)$" # 加个 ? ，使用非贪婪匹配
            print re.match(pattern_1,s).groups() # 打印的结果：('10023', '000')，这样就匹配出来了

e.编译
    当我们在Python中使用正则表达式时，re模块内部会干两件事情：
        编译正则表达式，如果正则表达式的字符串本身不合法，会报错；
        用编译后的正则表达式去匹配字符串。
    如果一个正则表达式要重复使用几千次，出于效率的考虑，我们可以预编译该正则表达式
    例如：

            s = "010-12345"
            pattern = r"^(\d{3})\-(\d{3,8})$"
            comp = re.compile(pattern) # 编译
            print comp #打印结果：<_sre.SRE_Pattern object at 0x026C3420>
            print comp.match(s).groups() # 打印结果：('010', '12345')

            # 直接用以编译的pattern来匹配字符串
            p = comp.match("1231-1115")
            if p!= None:
                print p.groups()
            else:
                print "未匹配上"

3、re模块的常用函数介绍：

a.match
    上面我们已经使用过了match这个函数。
    使用指定正则去待操作字符串中寻找可以匹配的子串, 返回匹配上的第一个字串，并且不再继续找。
    例如：

            s = '''first line
            second line
            third line'''

            regex = re.compile("\w+")
            m = regex.match(s)
            print m # <_sre.SRE_Match object at 0x0000000002BCA8B8>
            print m.group() # first

            # s 的开头是 "f", 但正则中限制了开始为 i 所以找不到
            regex = re.compile("^i\w+")
            print regex.match(s) # None

b.findall
    函数作用为在待操作字符串中寻找所有匹配正则表达式的字串，返回一个列表，如果没有匹配到任何子串，返回一个空列表。
    例如：

            s = '''first line
            second line
            third line'''
            regex = re.compile("\w+")
            print regex.findall(s) # 返回的是一个list ['first', 'line', 'second', 'line', 'third', 'line']

            # 不使用 compile 直接使用 findall
            print re.findall("\w+", s) # 返回的是一个list ['first', 'line', 'second', 'line', 'third', 'line']

c.search
    search是从字符串做任意匹配
    例如：

            ret_match= re.match("c","abcde")
            print ret_match # None，开头没有匹配到就结束了

            ret_search = re.search("c", "abcde")
            print ret_search.group() # c
        注意：match开头没有匹配到就结束了

match和findall最简单的区别就是：match从开头匹配，匹配到了就结束；findall会匹配所有能匹配的字符串。

4、一些不太常用的表达式语法：

【?= … 】：表达式’…’之前的字符串，特殊构建不作为分组
    例如：
    在字符串’ pythonretest ’中 (?=test) 会匹配’ pythonre ’

【?<= … 】：跟在表达式’…’之后的字符串符合括号之后的正则表达式，特殊构建不作为分组
    例如：
    正则表达式’ (?<=abc)def ’会在’ abcdef ’中匹配’ def 

【\1】：匹配重复的元素
    例如：

            s='1113446777'
            m = re.findall(r'(\d)\1',s) # \1表示重复的元素
            print m # ['1', '4', '7']

            如果把不重复的也提取出来可以：
            s='1113446777'
            m = re.findall(r'(\d)\1*',s) # \1表示重复的元素，在后面加个*，就可以把不重复也匹配出来了
            print m # ['1', '3', '4', '6', '7']

5、实际应用的例子：
a.验证邮箱的正确性

        text = raw_input("Please input your Email address：\n")
        # 以字母数字下划线开头，限定@前字符个数0-19个
        # @后面的数字限定1-13个
        # 以[com,cn,net]其中的一个结束，{2,3}表示.后面的结束字符个数在2-3之间；例如输入test@qq.c就非法，因为结束只有1个字符
        r = re.match(r'^[0-9a-zA-Z_]{0,19}@[0-9a-zA-Z]{1,13}\.[com,cn,net,c]{2,3}$',text)
        if r:
            print('right!')
        else:
            print('error!')