RE模块（正则）

RE模块和正则表达式

正则表达式

正则就是用来筛选字符串中的特定的内容的（只要是reg...一般情况下都是跟正则有关）

re模块与正则表达式之间的关系：
　　　　　　　正则表达式不是python独有的 它是一门独立的技术
　　　　　　　所有的编程语言都可以使用正则
　　　　　　　但是如果你想在python中使用,你就必须依赖于re模块

正则表达式的测试工具：http://tool.chinaz.com/regex/

#字符组 ： [字符组]
#在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示
#字符分为很多类，比如数字、字母、标点等等。一个字符串里面的表达式都是或的关系


#^   #匹配的是字符串的开头，例如：^a   就是匹配以a开头的
#[^]  # 除了[]写的字符，其它都要

#$   #匹配的是字符串的结尾，例如：b$    就是匹配以b结尾的

#^与$连用，会精准限制匹配的内容，两者中间些什么，匹配的字符串就必须是什么，多一个少一个都不行

#|   #例如a|b就是字符a或者字符b，需要注意一定要将长的放在前面

#.  #匹配除换行符以外的任意字符
#()  # 匹配括号内的表达式，也表示一个组

#w  #s  #d
#w匹配字母或数字或下划线
#s匹配任意的空白符
#d匹配数字

#W #S #D
#W匹配非字母或数字或下划线
#S匹配非数字
#D匹配非空白符
#ps:如果[wW]、[sS]、[dD]这样使用，可以匹配到全部

#
换行符
#	制表符
#单词以什么结尾

量词必须跟在正则符号的后面，量词只能能够限制紧挨着它的那一个正则符号

分组：针对多个正则表达式，想统一用量词修饰，可以用括号（）括起来。

贪婪匹配：在满足匹配时，匹配尽可能长的字符串，正则默认情况下，采用贪婪匹配

非贪婪匹配：可以在量词后面加上？取消默认的贪婪匹配

转义符:在正则表达式中，有很多有特殊意义的是元字符，比如 和s等，如果要在正则中匹配正常的" "而不是"换行符"就需要对""进行转义，变成'\'。

RE模块

#身份证号码是一个长度为15或18个字符的字符串，如果是15位则全部有数字组成，首位不能#为0；如果是18位，则前17位全部是数字，末位可能是数字或x，下面我们尝试用正则来表示：

import re
phone_number = input('please input your phone number : ')
if re.match('^[1-9]d{14}(d{2}[0-9x])?$',phone_number):
    print('是身份证号')
else:
    print('不是身份证号')
#正则表达式分析
^[1-9]d{14}(d{2}[0-9x])?$
#^[1-9]第一位是1-9中的数字
#d{14}第二到十四位匹配的是数字
#(d{2}[0-9x])?$后三位可能出现一次，也可能不出现，出现的时候，后三位的前两位是数字，第三位可以是0-9的数字也可以是x

#更清楚的写法
^([1-9]d{16}[0-9x]|[1-9]d{14})$
#第一位和之前相同
#后面通过|这个符号，也就是或，来进行两种情况的判断如果后面还有17位，则是有16位都是数字，最后一位可以是数字或者x,如果后面是14位，则14位都是数字

RE模块中的常用函数

import re

#findall
res = re.findall('a','eva egon jason')
# findall('正则表达式','带匹配的字符串')
print(res)
# 找出字符串中符合正则表达式全部内容 并且返回的是一个列表,列表中的元素就是正则匹配到的结果

import re

#search
res = re.search('a','eva egon jason')
print(res)  # search不会给你直接返回匹配到的结果，而是给你返回一个对象
print(res.group())  # 必须调用group才能看到匹配的结果
"""
注意:
    1.search只会依据正则查一次 只要查到了结果 就不会再往后查找
    2.当查找的结果不存在的情况下，返回的是一个None 调用group直接报错
"""

res1 = re.search('b','eva egon jason')
# search('正则表达式','带匹配的字符串')
if res1:
    print(res1.group())

import re
res = re.match('a','eva egon jason')
print(res)  # ('正则表达式','带匹配的字符串')
print(res.group())
"""
注意:
    1.match只会匹配字符串的开头部分
    2.当字符串的开头不符合匹配规则的情况下 返回的也是None 调用group也会报错
"""

import re

ret = re.split('[ab]','abcd')  # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)  # ['', '', 'cd'] 返回的还是列表

ret = re.sub('d','H','eva3egon4yuan4',1)  # 将数字替换成'H'，参数1表示只替换1个
print(ret)  # ('正则表达式','新的内容','待替换的字符串',n)
#先按照正则表达式查找所有符合该表达式的内容 统一替换成'新的内容'  还可以通过n来控制替换的个数

ret = re.subn('d', 'H', 'eva3egon4yuan4')  # 将数字替换成'H'，返回元组(替换的结果,替换了多少次)
ret1 = re.subn('d', 'H', 'eva3egon4yuan4',1)  # 将数字替换成'H'，返回元组(替换的结果,替换了多少次)
print(ret)  # 返回的是一个元组 元组的第二个元素代表的是替换的个数
print(ret1)

obj = re.compile('d{3}')  #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search('abc123eeee') #正则表达式对象调用search，参数为待匹配的字符串
res1 = obj.findall('347982734729349827384')
print(ret.group())  #结果 ： 123
print(res1)  #结果 ： ['347', '982', '734', '729', '349', '827', '384']

import re
ret = re.finditer('d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
print(next(ret).group())  # 等价于ret.__next__()  查看第一个结果
print(next(ret).group())  # 等价于ret.__next__()  查看第二个结果
print(next(ret).group())  # 等价于ret.__next__()
print(next(ret).group())  # 等价于ret.__next__()
print(next(ret).group())  # 等价于ret.__next__()   查出迭代取值的范围 直接报错
print([i.group() for i in ret])  #查看剩余的左右结果

import re
res = re.search('^[1-9](d{14})(d{2}[0-9x])?$','110105199812067023')
#还可以给某一个正则表达式起别名,起名的格式为 ？P<名字>
res = re.search('^[1-9](?P<password>d{14})(?P<username>d{2}[0-9x])?$','110105199812067023')
print(res.group())
print(res.group('password'))
print(res.group(1))
print(res.group('username'))
print(res.group(2))

#findall的优先级查询:
import re

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.split("d+","eva3egon4yuan")
print(ret) #结果 ： ['eva', 'egon', 'yuan']

ret=re.split("(d+)","eva3egon4yuan")
print(ret) #结果 ： ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上（）之后所切出的结果是不同的，
#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，
#这个在某些需要保留匹配部分的使用过程是非常重要的。