python模块--re模块

一、

就本质而言，正则表达式（或re）是一种小型的、高度专业化的编程语言，（在python中）它内嵌在python中，并通过re模块实现。正则表达式模式被编译成一系列得字节码，然后由用c语言编写的匹配引擎执行。
字符匹配（普通字符，元字符）：
1 普通字符：大多数字符和字母都会和自身匹配
         re.findall('alvin','wangzhaoqian')
         ['alvin']
        
2元字符：.  ^  $  *  +  ?  {}  []  |   ()          共11个

  “ . " 代表通配符，指除了" "以外所有的都能匹配

   "^" 代表以。。。开头的意思

  "$" 代表以。。。结尾

 关于重复功能的有四个： *   +  ?  {}

 " * " 代表0到无穷次  即[0,+oo]

 " + " 代表1到无穷次，即[1,+oo]

 " ? " 代表0次或1次，即[0,1]

 "{}" 代表自己定次数，例如

        {0,} 等价于* ；{1,}等价于 + ；{0,1} 等价于 ？ ； {6} 只能重复6次 ； {1,6} 指重复1到6之间的哪一次都行。

 注意：前面的 *  +  ?都是贪恋匹配，也就是尽可能的匹配，但是，后面加？号后使其变成惰性匹配

                                                               元字符之： ^  $  *  +  ?  {}                                                                                                                                      

import re
ret = re.findall('a..in','helloalvin')
print(ret)    #['alvin']

ret = re.findall('^a...n','alvinhelloworld')
print(ret)  #['alvin']

ret = re.findall('a...n$','alvinhellowoarldn')
print(ret)#  ['arldn']

ret = re.findall('abc','abcccc')
print(ret)  #['abc']

ret = re.findall('abc*','abcccc')  #贪婪匹配[0,+oo]
print(ret)  #['abcccc']

ret = re.findall('abc+','abcccc')  #贪婪匹配 [1,+oo]
print(ret)  #['abcccc']

ret = re.findall('abc?','abcccc') #[0,1]匹配一次或0次
print(ret)  #['abc']

ret = re.findall('abc{1,4}','abccc') #匹配1次到4次之间出现的任意一次
print(ret)    #贪婪匹配

##----> 注意：前面的 *  +  ?都是贪恋匹配，也就是尽可能的匹配，但是，后面加？号后
              # 使其变成惰性匹配

ret = re.findall('abc*?','abccccc')
print(ret)  #['ab']

                                                                              元字符之字集 [ ]:                                                                                    

import re
ret = re.findall('a[bc]d','acd')
print(ret)   #['acd']

ret = re.findall('[a-z]','acd')  #"-"  代表a到z的的所有字母
print(ret)   #['a', 'c', 'd']

ret = re.findall('[.*+]','a.cd+')
print(ret)

##在字符集里有功能的符号只有： -  ^   
## "-" :在[]字符集中，指范围的意思
## " ^ " :在[]的字符集中，是”非“ 的意思
## "  " : 在[]的字符集中，是转义字符
## 在[]里面没有特殊符号，而且里面试”或“的关系，不过，只有上述三个除外

ret = re.findall('[1-9]','45dank8')
print(ret)  #['4', '5', '8']

ret = re.findall('[^ab]','45danbk8')
print(ret)  # ['4', '5', 'd', 'n', 'k', '8']

ret = re.findall('[d]','45danbk8')
print(ret)  #['4', '5', '8']

ret = re.findall('([^()])','12+(34*6+2-5*(2-1))')
print(ret)   # []

ret = re.findall('([^()]*)','12+(34*6+2-5*(2-1))')
print(ret) #['(2-1)']

                                                                                   元字符之转义符                                                                                                                              

 反斜杠后边去除特殊功能，比如.
 反斜杠后边跟普通字符实现特殊功能，比如d

d 批评日任何十进制数；它相当于类[0-9]]
D匹配任何非数字字符；它相当于类[^0-9]
s 匹配任何空白字符；它相当于类[ fv]
S匹配任何非空白字符；它下该党于类[^ fv]
w匹配任何字母数字字符；它相当于类[a-zA-Z0-9]
W匹配任何非字母数字字符；它相当于类[^a-zA-Z0-9]
匹配一个特殊字符边界，比如空格，&，#等                                                                                                                                                                                          

import re
ret = re.findall('I','I am LIST')
print(ret)#[]

ret = re.findall(r'I','I am LIST')
print(ret)  #['I']

先看看关于“ ” 的例子

import re
ret = re.findall('c l','abcle')
print(ret)   #[]

ret = re.findall('c\ l','abcle')
print(ret)  #[]

ret = re.findall('c\\l','abcle')
print(ret)  # ['c\l']

ret = re.findall(r'c\l','abcle')
print(ret)  #['c\l']

之所以选择是因为在ASCII表中是有意义的

m = re.findall('blow','blow')
print(m)   #[]

m = re.findall(r'blow','blow')
print(m)  #['blow']

                                                                        元字符之分组                                                                                                   

import re
ret = re.findall('(?:abc)+','abcabcabcabc')
print(ret)  #['abcabcabcabc']
ret = re.findall('(?:abc)','abcabcabcabc')
print(ret)  #['abc', 'abc', 'abc', 'abc']

import re
m = re.findall(r'ad+','add')
print(m)  #['add']
m = re.findall( '(ad)+','adadadad')  #?????
print(m)  #['ad']

ret = re.findall('(?P<id>d{2})/(?P<name>w{3})','23/com')
print(ret)  #[('23', 'com')]

ret = re.search('(?P<id>d{2})/(?P<name>w{3})','23/com')
print(ret.group())   #23/com

#search匹配成功则返回，匹配不成功，不返回。而且search只会找满足第一个的元素

ret = re.search('(?P<id>[a-z]+)','alex23hah89beijing66')
print(ret)    #<_sre.SRE_Match object; span=(0, 4), match='alex'>
print(ret.group())  #alex
ret = re.search('([a-z]+)','alex23hah89beijing66')
print(ret)
print(ret.group())
#对比可知，?P<>没什么作用，它只是起个名字，放便用的时候取出来

ret = re.search('(?P<id>[a-z]+)d+','alex23hah89beijing66').group()
print(ret)   #alex23
ret = re.search('(?P<name>[a-z]+)d+','alex23hah89beijing66').group('name')
print(ret)  #alex


ret = re.search('(?P<name>[a-z]+)(?P<age>d+)','alex23hah89beijing66')
print(ret.group('name'))  #alex
print(ret.group('age'))  #23

ret = re.search('((?P<name>[a-z]+)(?P<age>d+))+','alex23hah89beijing66')
print(ret.group('name'),ret.group('age'))      #?P<>只是给取了名字，以后做大数据是，方便调用
print(ret.group())  #alex23hah89beijing66

                                                                                元字符之管道符 |                                                                                                                                                                管道符：是“或”的意思

  

import re
ret =re.search('(ab|d)','rabhdg8sd')
print(ret)  # <_sre.SRE_Match object; span=(1, 3), match='ab'>
print(ret.group())  #ab

ret = re.findall(r'ka|b','sdjkbsf')
print(ret)  #['b']


ret = re.findall(r'ka|b','sdjkasf')
print(ret)  #['ka']

ret = re.findall(r'ka|b','sdjka|bsf')
print(ret)  #['ka', 'b']

                                                          re模块的常用方法                                                                                                                                                                                

###--------------re模块的常用方法------------------------------------------
import re
#1
re.findall('a','alvin yuan')  #返回所有满足匹配条件的结果，放在列表例
#2
re.search('a','alvin yuan').group() #函数会在字符串那日查找模式匹配，直到找到第一个匹配返回一个包
                                #通过调用group（）方法得到匹配的字符串，如果字符串没有匹配，则返回空
#3
re.match('a','abc').group()    #同search，不过仅在字符串开始处进行匹配
#4
ret  = re.split('[ab]','abcd')  #先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割
print(ret)   #['', '', 'cd']
#5
ret = re.sub('d','abc','al8vin5yu4an7',2)  #可以备注匹配几次
print(ret)  #alabcvinabcyu4an7

ret = re.sub('d','abc','al8vin5yu4an7',4)  #从后面匹配的内容换成'abc',也就是置换
print(ret)  #alabcvinabcyuabcanabc

ret = re.subn('d','abc','alvin5yuan7')
print(ret)    #('alvinabcyuanabc', 2)  返回匹配的次数
#6
obb= re.compile('d{3}')  #将规则封装成了一个对象，下面用的时候直接调用对象就好了，方便简单
ret=obb.search('abc123eeedd')
print(ret.group())   #123

###-----------finfiter的用法-----------------------------
ret = re.finditer('d','ds3sy4584as')
print(ret)  #<callable_iterator object at 0x000001E82CDDCF98>
print(next(ret).group())  #3
print(next(ret).group())  # 4
##返回的对象ret是一个可迭代对象，不用打印出来，用的时候打印一个，用next（）方法

##------------------注意--------”?:“的用法-----------------------------------------------

ret = re.findall('www.(baidu|oldboy).com','www.oldboy.com')
print(ret)  #['oldboy']   这是因为findall会游戏那把匹配结果的组里内容返回，如果想要匹配结果，取消权限即可
ret = re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')
print(ret)   #['www.oldboy.com']    #通过  ?:  这两个字符，就取消的分组的优先级

ret = re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')
print(ret)  #['www.oldboy.com']  看来加不加   ，这里没关系