regular expression 正则表达式 import re

   简单的regexp

     p = re.compile("abc") if p.match("abc") : print "match"

     上例中首先生成一个pattern(模式),如果和某个字符串匹配，就返回一个match object

     除某些特殊字符metacharacter元字符，大多数字符都和自身匹配。

     这些特殊字符是 。^ $ * + ? { [ ] \ | ( )

   字符集合(用[]表示)

     列出字符,如[abc]表示匹配a或b或c,大多数metacharacter在[]中只表示和本身匹配。例：

       a = ".^$*+?{\\|()"  大多数metachar在[]中都和本身匹配，但"^[]\"不同

       p = re.compile("["+a+"]")

       for i in a:

           if p.match(i):

               print "[%s] is match" %i

           else:

               print "[%s] is not match" %i

       在[]中包含[]本身，表示"["或者"]"匹配.用\[和\]表示.

       ^出现在[]的开头,表示取反.[^abc]表示除了a,b,c之外的所有字符。^没有出现在开头，即于身身匹配。

       -可表示范围.[a-zA-Z]匹配任何一个英文字母。[0-9]匹配任何数字。

       \在[]中的妙用。

         \d [0-9]

         \D [^0-9]

         \s [ \t\n\r\f\v]

         \S [^ \t\n\r\f\v]

         \w [a-zA-Z0-9_]

         \W [^a-zA-Z0-9_]

         \t 表示和tab匹配, 其他的都和字符串的表示法一致

         \x20 表示和十六进制ascii 0x20匹配

         有了\，可以在[]中表示任何字符。注：单独的一个"."如果没有出现[]中，表示出了换行\n以外的匹配任何字符,类似[^\n].

     regexp的重复          

       {m,n}表示出现m个以上(含m个),n个以下(含n个).  如ab{1,3}c和abc,abbc,abbbc匹配，不会与ac,abbbc匹配。

       m是下界，n是上界。m省略表下界是0,n省略，表上界无限大。

       *表示{,} +表示{1,} ?表示{0,1}

       最大匹配和最小匹配 python都是最大匹配，如果要最小匹配，在*,+,?,{m,n}后面加一个?.

       match object的end可以得到匹配的最后一个字符的位置。

         re.compile("a*").match(‘aaaa‘).end()     4  最大匹配

         re.compile("a*?").match(‘aaaa‘).end()    0  最小匹配

     使用原始字符串

       字符串表示方法中用\\表示字符\.大量使用影响可读性。

       解决方法：在字符串前面加一个r表示raw格式。

       a = r"\a" print a 结果是\a

       a = r"\"a" print a 结果是\"a

     使用re模块

       先用re.compile得到一个RegexObject 表示一个regexp

       后用pattern的match,search的方法,得到MatchObject

       再用match object得到匹配的位置,匹配的字符串等信息

       RegxObject常用函数:

         >>> re.compile("a").match("abab") 如果abab的开头和re.compile("a")匹配，得到MatchObject

         <_sre.SRE_Match object at 0x81d43c8>

         >>> print re.compile("a").match("bbab")

         None 注：从str的开头开始匹配          

         >>> re.compile("a").search("abab") 在abab中搜索第一个和re_obj匹配的部分

         <_sre.SRE_Match object at 0x81d43c8>

         >>> print re.compile("a").search("bbab")

         <_sre.SRE_Match object at 0x8184e18> 和match()不同,不必从开头匹配          

         re_obj.findall(str) 返回str中搜索所有和re_obj匹配的部分.

           返回一个tuple,其中元素是匹配的字符串.

       MatchObject的常用函数

         m.start() 返回起始位置,m.end()返回结束位置(不包含该位置的字符).

         m.span() 返回一个tuple表示(m.start(), m.end())

         m.pos(), m.endpos(), m.re(), m.string()

           m.re().search(m.string(), m.pos(), m.endpos()) 会得到m本身

         m.finditer()可以返回一个iterator,用来遍历所有找到的MatchObject.

           for m in re.compile("[ab]").finditer("tatbxaxb"):

           print m.span()

     高级regexp

       | 表示联合多个regexp. A B两个regexp，A|B表示和A匹配或者跟B匹配.

       ^ 表示只匹配一行的开始行首,^只有在开头才有此特殊意义。

       $ 表示只匹配一行的结尾

       \A 表示只匹配第一行字符串的开头 ^匹配每一行的行首

       \Z 表示只匹配行一行字符串的结尾 $匹配第一行的行尾

       \b 只匹配词的边界 例：\binfo\b 只会匹配"info" 不会匹配information

       \B 表示匹配非单词边界

       示例如下：

         >>> print re.compile(r"\binfo\b").match("info ") #使用raw格式 \b表示单词边界

         <_sre.SRE_Match object at 0x817aa98>

         >>> print re.compile("\binfo\b").match("info ") #没有使用raw \b表示退格符号

         None

         >>> print re.compile("\binfo\b").match("\binfo\b ")

         <_sre.SRE_Match object at 0x8174948>

     分组(Group) 示例：re.compile("(a(b)c)d").match("abcd").groups()   (‘abc‘, ‘b‘)        

       #!/usr/local/bin/python        

       import re        

       x = """

       name: Charles

       Address: BUPT

       name: Ann

       Address: BUPT

       """        

       #p = re.compile(r"^name:(.*)\n^Address:(.*)\n", re.M)

       p = re.compile(r"^name:(?P<name>.*)\n^Address:(?P<address>.*)\n", re.M)

       for m in p.finditer(x):

               print m.span()

               print "here is your friends list"

               print "%s, %s"%m.groups()

     Compile Flag

       用re.compile得到RegxObject时，可以有一些flag用来调整RegxObject的详细特征.

         DOTALL, S 让.匹配任意字符,包括换行符\n

         IGNORECASE, I 忽略大小写

         LOCALES, L 让\w \W \b \B和当前的locale一致

         MULTILINE, M 多行模式，只影响^和$(参见上例)

         VERBOSE, X verbose模式