python基础学习-6（正则）

正则表达式(RE)是一种小型的、高度专业化的编程语言，在python中，它内嵌在python中，并通过re模块实现。

字符匹配：

        普通字符，大多数字母和字符一般都会和自身匹配，比如正则表达式test会和字符串"test"完全匹配

        元字符， . ^ $ + ? {} [] \ | ()

               .,表任意字符

               *?, +?, ??  符合条件的情况下，匹配的尽可能少//限制*,+,?匹配的贪婪性

            [],常用来指定一个字符集：[abc]; [a-z];元字符在字符集中不起作用：[akm$];补集匹配不在区间范围内的字符：[^5]

            ^,匹配行首

            $,匹配行尾

#!/usr/bin/python
import re
s = r"abc"
re.findall(s,"abcsssssabcss")//返回['abc','abc']

            \,转义字符，用于取消所有的元字符

                /d  [0-9]
                   /D  非 /d，任何十进制数
                   /s  表示空白字符，[\t\n\r\f\v]
                   /S  非空白字符，[^\t\n\r\f\v]
                   /w  [a-zA-Z0-9_]，任何字母数字
                   /W  非 /w

            *，表示匹配0次或更多次

               +，表示匹配一次或更多次

               ?，表示匹配零次或一次，即可选

            {m,n}，m和n为十进制数，表示至少重复m次，至多重复n次。忽略m则下界为0，忽略上界为无穷大

{0,}等同*；{1,}等同+；{0,1}等同?。{m} 表示重复m次

dir(模块名) 列出该模块的方法和属性。再利用help(方法名或属性)查看具体含义。

一、RE的方法：

1)re.match

　　re.match 尝试从字符串的开始位置匹配一个模式，没有匹配到返回None，成功匹配返回一个MatchObject,使用group()方法将MathOject转换为匹配的字符串。如：下面的例子匹配第一个单词。 

#!/usr/bin/python
import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
m = re.match(r"(\w+)\s", text)
if m:
print m.group(0), '\n', m.group(1)
else:
print 'not match'

re.match的函数原型为：re.match(pattern, string, flags)

第一个参数是正则表达式，这里为"(\w+)\s"，如果匹配成功，则返回一个Match，否则返回一个None；

第二个参数表示要匹配的字符串；

第三个参数是标致位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

2)re.search

　　re.search函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回，如果字符串没有匹配，则返回None。

import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
m = re.search(r'\shan(ds)ome\s', text)
if m:
print m.group(0), m.group(1)
else:
print 'not search' 

re.search的函数原型为： re.search(pattern, string, flags)

每个参数的含意与re.match一样。 

re.match与re.search的区别：re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

3)re.sub

　　re.sub用于替换字符串中的匹配项。下面一个例子将字符串中的空格 ' ' 替换成 '-' :

import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
print re.sub(r'\s+', '-', text) 

 re.sub的函数原型为：re.sub(pattern, repl, string, count)

其中第二个函数是替换后的字符串；本例中为'-'

第四个参数指替换个数。默认为0，表示每个匹配项都替换。

re.sub还允许使用函数对匹配项的替换进行复杂的处理。如：re.sub(r'\s', lambda m: '[' + m.group(0) + ']', text, 0)；将字符串中的空格' '替换为'[ ]'。

4)re.split

　　可以使用re.split来分割字符串，如：re.split(r'\s+', text)；将字符串按空格分割成一个单词列表。

5)re.findall

　　re.findall可以获取字符串中所有匹配的字符串。如：re.findall(r'\w*oo\w*', text)；获取字符串中，包含'oo'的所有单词。

6)re.finditer    

re.finditer可以获取字符串中所有匹配的字符串，并将匹配结果

一个迭代器

作为返回。显示匹配使用iter.next()

7)re.

compile(pattern, [flags]) 

      可以把正则表达式编译成一个正则表达式对象。可以把那些经常使用的正则表达式编译成正则表达式对象，这样可以提高一定的效率。

根据正则表达式字符串 pattern 和可选的flags 生成正则表达式 对象,其中flags有下面的定义：

    I  表示大小写忽略
    L  使一些特殊字符集，依赖于当前环境         
    M  多行模式 使 ^ $ 匹配除了string开始结束外，还匹配一行的开始和结束
    S  “.“ 匹配包括‘/n’在内的任意字符，否则 . 不包括‘/n’  
    U  Make /w, /W, /b, /B, /d, /D, /s and /S dependent on the Unicode character properties database    
    X 这个主要是表示，为了写正则表达式，会忽略一些空格、\n和#后面的注释 

    

其中S比较常用， 应用形式如下：

    import re
    re.compile(……,re.S)

import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
regex = re.compile(r'\w*oo\w*')
print regex.findall(text)   #查找所有包含'oo'的单词
print regex.sub(lambda m: '[' + m.group(0) + ']', text) #将字符串中含有'oo'的单词用[]括起来。

二、正则表达式对象 （Regular Expression Objects ）
   
    产生方式：通过 re.compile(pattern，[flags])回
    
    match( string[, pos[, endpos]]) ；返回string[pos,endpos]匹配
    pattern的MatchObject（见三）
    
    split( string[, maxsplit = 0]) 
    findall( string[, pos[, endpos]])   
    sub( repl, string[, count = 0]) 
    这几个函数和re模块内的相同，只不过是调用形式有点差别
    
    re.几个函数和 正则表达式对象的几个函数，功能相同，但同一程序如果
    多次用的这些函数功能，正则表达式对象的几个函数效率高些
    
三、matchobject

    通过 re.match(……) 和 re.compile(……).match返回
    
    该对象有如下方法和属性：
    
    方法：
    group( [group1, ...]) 
    groups( [default]) 
    groupdict( [default]) 
    start( [group]) 
    end( [group]) 
    
    说明这几个函数的最好方法，就是举个例子
    

    matchObj = re.compile(r"(?P<int>/d+)/.(/d*)")
    m = matchObj.match('3.14sss')
    #m = re.match(r"(?P<int>/d+)/.(/d*)", '3.14sss')
    
    print m.group()
    print m.group(0)
    print m.group(1)
    print m.group(2)
    print m.group(1,2)
    
    print m.group(0,1,2)
    print m.groups()
    print m.groupdict()
    
    print m.start(2)    
    print m.string

  输出如下：    
    3.14               
    3.14               
    3                  
    14                 
    ('3', '14')        
    ('3.14', '3', '14')
    ('3', '14')        
    {'int': '3'}       
    2                  
    3.14sss
    
    所以group() 和group(0)返回，匹配的整个表达式的字符串。另外group(i)就是正则表达式中用第i个“（）” 括起来的匹配内容，('3.14', '3', '14')最能说明问题了。