正则表达式：re模块简介和深入

• 非正则表达式法
  # 给你一串字符串，判断是否是手机号码
  # （非正则表达式法）
  
  def judgephone(str):
      if len(str) != 11:
          return False
      elif str[0] != '1':
          return False
      elif str[1:3] != '39' and str[1:3] != '31':
          return False
      for i in range(3,11):
          if str[i] < '0' or str[i] > '9':
              return False
      return True
  
  print(judgephone('13912345678'))
  print(judgephone('1391234a5678'))
  print(judgephone('23912345678'))
  print(judgephone('19012345678')) 
  
  
  out:

  True
  False
  False
  False

• #  正则表达式法
  import re
  def judgephone(str):
      reg  = r'^1[3578]\d{9}$'  
      res = re.match(reg,str)   
      #print(res)
      return res
  # judgephone('13912345678')
  # judgephone('1391234a5678')
  # judgephone('23912345678')
  # judgephone('19012345678')
  print(judgephone('13912345678'))
  print(judgephone('1391234a5678'))
  print(judgephone('23912345678'))
  print(judgephone('19012345678')) 
  
  out:

  <re.Match object; span=(0, 11), match='13912345678'>
  None
  None
  None
• 正则表达式

# re.match函数
re.match函数，是re模块里的一个
原型：match(pattern,string,flags=0)
参数：
pattern:匹配的正则表达式
string: 要匹配的字符串，（在string中匹配pattern）
flags： （默认是0），标志位，用于控制正则表达式的匹配方式（如用于忽略字母的大小写来达到匹配目的），
flags的值如下
re.I:忽略大小写                        （常用）
re.L:做本地化识别
re.M:多行匹配，影响^和$这两个元字符    （常用）
re.S:使.匹配包括换行符在内的所有字符   （常用）
re.U:根据Unicode字符集解析字符，影响 \w \W \b \B
re.X:是我们以更灵活的格式理解正则表达式
功能：尝试从字符串的起始位置匹配一个模式，（注意只能是从起始位置开始），如果不是起始位置，就算匹配成功，也返回None

import re
print(re.match('www','www.baidu.com'))
print(re.match('www','www.baidu.com').span())
print(re.match('www','ww.baidu.com'))
print(re.match('www','.baidu.wwwcom'))
print(re.match('www','Www.baidu.com'))
print(re.match('www','Www.baidu.com',flags=re.I))
print(re.match('www','www.baiduwww.com'))

# 可以发现扫描整个字符串，返回从起始位置成功的匹配

out:

<re.Match object; span=(0, 3), match='www'>
(0, 3)
None
None
None
<re.Match object; span=(0, 3), match='Www'>
<re.Match object; span=(0, 3), match='www'>

re.search函数
原型：search(pattern,string,flags=0)
参数：同上re.match函数
功能：扫描整个字符串，并返回第一个成功的匹配，但不一定从头开始匹配了

print(re.search('Mia','I love Mia,Mia is my love'))

out:

<re.Match object; span=(7, 10), match='Mia'>

re.findall函数
原型：findall(pattern,string,flags=0)
参数：同上
功能：扫描整个字符串，并返回列表类型的结果

print(re.findall('Mia','I love Mia,Mia is my love'))
print(re.findall('Mia','I love mia,Mia is my love',flags=re.I))

out:

['Mia', 'Mia']
['mia', 'Mia']

# 字符串切割
import re
str = 'Mia      ###is a nice   girl'
print(str.split())
print(re.split(r' +',str))

out:

['Mia', '###is', 'a', 'nice', 'girl']
['Mia', '###is', 'a', 'nice', 'girl']

# re.finditer函数
原型：finditer(pattern,string,flags=0)
参数：
pattern:匹配的正则表达式
string: 要匹配的字符串，（在string中匹配pattern）
flags： （默认是0），标志位，用于控制正则表达式的匹配方式（如用于忽略字母的大小写来达到匹配目的），
flags的值如下
re.I:忽略大小写                        （常用）
re.L:做本地化识别
re.M:多行匹配，影响^和$这两个元字符    （常用）
re.S:使.匹配包括换行符在内的所有字符   （常用）
re.U:根据Unicode字符集解析字符，影响 \w \W \b \B
re.X:是我们以更灵活的格式理解正则表达式
功能：与findall类似，但finditer把结果返回成一个列表。扫描整个字符串，返回的是一个迭代器

str = 'Mia is a good girl!Mia is a nice girl!Mia is a beautiful girl'
res =  re.finditer(r'(Mia)',str)
while True:
    try:
        lis = next(res)    # 转化为迭代器
        print(res)
    except StopIteration as error:
        break
# 利用迭代器防止得到的数据过多而占用内存，它是一条一条地处理的

out:
<callable_iterator object at 0x00000260EB0FC748>
<callable_iterator object at 0x00000260EB0FC748>
<callable_iterator object at 0x00000260EB0FC748>

# 字符串的替换与修改   re.sub()   re.subn()
sub(pattern,repl,string,count=0,flags=0)
subn(pattern,repl,string,count=0,flags=0)
pattern: 正则表达式（把什么什么替换掉的规则）
repl:    指定的用来替换的字符串
string:  目标字符串
count：  最多替换次数
功能：在目标字符串中，以正则表达式的规则匹配字符串，再把他们替换成指定的字符串。可以指定替换的次数，如果不指定，替换所有的匹配字符串
re.sub()与re.subnF()二者的区别：前者返回一个字符串，后者返回一个元素，且第一个元素是被替换的字符串，第二个元素表示被替换的次数。

str = 'Mia is a good good good girl'
print(re.sub(r'(good)','nice',str))
print(re.sub(r'(good)','nice',str,count=2))
print(type(re.sub(r'(good)','nice',str,count=2)))
print(re.subn(r'(good)','nice',str))
print(type(re.subn(r'(good)','nice',str,count=2)))

out:
Mia is a nice nice nice girl
Mia is a nice nice good girl
<class 'str'>
('Mia is a nice nice nice girl', 3)
<class 'tuple'>

## 分组
概念：除了简单的判断是否匹配之外，正则表达式还有提取子串的功能。用()表示的就是提取出来的分组。

str = '010-53247654'
res = re.match(r'(\d{3})-(\d{8})',str)
# 使用序号获取对应组的信息，group(0)则代表的是原始字符串str
print(res.group(0))
print(res.group(1))
print(res.group(2))
# 查看匹配的各组的情况
print(res.group())

out:
010-53247654
010
53247654
010-53247654

str = '010-53247654'
res = re.match(r'(?P<first>\d{3})-(?P<last>\d{8})',str) # 还可起名字，只是没多大意义
print(res.group('first'))

out:

010

# 编译
编译：当使用正则表达式时，re模块会做二件事--
1：编译正则表达式，（但我们没有这个过程），如果正则表达式本身不合法，会报错
2：用编译后的正则表达式去匹配对象，但我们目前没编译，而是直接使用，无法随时“拿来”使用
编译就是把正则表达式变为正则对象，以便随时对对象“拿来”使用
compile(pattern,flags=0)
pattern: 要编译的正则表达式

str = '13600000000'
pat = r'^1(([3578]\d)|(47))\d{8}$'
print(re.match(pat,str))

# 编译成正则对象
re_telephonne = re.compile(pat)
print(re_telephonne.match(str))

out:
<re.Match object; span=(0, 11), match='13600000000'>

# 将正则表达式编译成正则对象： 左是re模块调用   右是re对象调用
re.match(pattern,string,flags=0)  -->  re_etc.match(string)
re.search(pattern,string,flags=0)  -->  re_etc.search(string)
re.findall(pattern,string,flags=0)  -->  re_etc.findall(string)
re.finditer(pattern,string,flags=0)  -->  re_etc.finditer(string)
re.split(pattern,string,maxsplit=0,flags=0)  -->  re_etc.split(string,maxsplit)
re.sub(pattern,repl,string,count=0,flags=0)  -->  re_etc.sub(repl,string,count=0)
re.subn(pattern,repl,string,count=0,flags=0)  -->  re_etc.subn(repl,string,count=0)

# 例 QQ号 ：6-10位
re_QQ = re.compile(r'^[1-9]\d{5,9}')
print(re_QQ.search('1234567890'))
print(re_QQ.search('123456a890'))
print(re_QQ.search('234567890'))

out:
<re.Match object; span=(0, 10), match='1234567890'>
<re.Match object; span=(0, 6), match='123456'>
<re.Match object; span=(0, 9), match='234567890'>