Python web服务器1:正则表达式

一、总体内容

• 1.1、正则表达式概述
• 1.2、re 模块
• 1.3、匹配单个字符
• 1.4、匹配多个字符
• 1.5、匹配开头与结尾
• 1.6、匹配分组
• 1.7、re模块的高级用法
• 1.8、python贪婪和非贪婪
• 1.9、r 的作用

二、正则表达式概述

• 2.1、 场景1：在一个文件中，查找出 like 开头的语句

  like hello python
  like c++
  itheima ios
  itheima php
  

• 2.2、 场景二：在一个文件中，找到含有like的语句，下面是测试文件

  hello like python
  can you like c++
  itheima ios
  itheima php
  

• 2.3、 场景三：在一个文件中，找到所有的图片链接

三、re 模块(match是从头匹配)
在Python中需要通过正则表达式对字符串进行匹配的时候，可以使用一个模块，名字为re

• re模块的使用过程

  # 导入re模块
  import re
  
  # 使用match方法进行匹配操作
  result = re.match(r"Hello","hello IronMan")
  
  # 如果上一步匹配到数据的话，可以使用group方法来提取数据
  if result:
      print("匹配到的内容是：%s"%result.group())
  else:
      print("没有匹配到内容")
  

  提示：re.match()能够匹配出以xxx开头的字符串，match()第一个参数是匹配的规则，第二个参数是要匹配的内容

四、匹配单个字符

字符	功能
.	匹配任意一个字符（除了\n）
[]	匹配[]中列举的字符
\d	匹配数字，即 0-9
\D	匹配非数字，即不是数字
\s	匹配空白，即空格 tab 键
\S	匹配非空白
\w	匹配单词字符，即 a-z、A-Z、0-9、_、汉字以及其他文字
\W	匹配非单词字符

• 示例：

  import re
  
  # 大小写h都可以的情况
  ret = re.match(r"[hH]","hello Python")
  print(ret.group())
  
  # 匹配0到9第一种写法
  ret = re.match(r"\dHello","6Hello Python")
  print(ret.group())
  
  # 匹配空白，即空格 tab 键
  ret = re.match(r"Hello\sP","Hello Python")
  print(ret.group())
  
  # 匹配单词字符，即 a-z、A-Z、0-9、_、汉字以及其他文字
  ret = re.match(r"\wHello","哈Hello Python")
  print(ret.group())
  

  打印结果是：

  h
  6Hello
  Hello P
  哈Hello
  

五、匹配多个字符

字符	功能
*	匹配前一个字符出现0次或者无限次，即可有可无
+	匹配前一个字符出现1次或者无限次，即至少有一次
?	匹配前一个字符出现1次或者0次，要么有一次，要么没有
{m}	匹配前一个字符出现 m 次
{m,n}	匹配前一个字符出现 m ~n 次

• 示例：

  import re
  
  # * 匹配前一个字符出现0次或者无限次，即可有可无
  result = re.match(r"\w*","Ilovebaby")
  print(result.group())
  
  # + 匹配前一个字符出现1次或者无限次，即至少有一次
  result = re.match(r"H+","Hlovebaby")
  print(result.group())
  
  # ? 匹配前一个字符出现1次或者0次，要么有一次，要么没有
  result = re.match(r"H?ello","Hello")
  print(result.group())
  
  # {m} 匹配前一个字符出现 m 次
  result = re.match(r"H{3}ello","HHHello")
  print(result.group())
  
  # {m,n} 匹配前一个字符出现 m ~n 次
  result = re.match("H{1,3}ello","HHello")
  print(result.group())
  

  实战：匹配出163的邮箱地址，且@符号之前有4到20位，例如hello@163.com

  import re
  
  # 匹配出163的邮箱地址，且@符号之前有4到20位，例如`hello@163.com`
  result = re.match(r"\w{4,20}@163\.com","2318162@163.com")
  
  print(result.group())
  

六、匹配开头结尾

字符	功能
^	匹配字符串开头
$	匹配字符串结尾

• 只要是”^”这个字符是在中括号”[]”中被使用的话就是表示字符类的否定，如果不是的话就是表示限定开头。我这里说的是直接在”[]”中使用，不包括嵌套使用。
  其实也就是说”[]”代表的是一个字符集，”^”只有在字符集中才是反向字符集的意思。
• 如：([^/]+(/[^ ]*) ： 意思是 :[^/]:除了/以外，+：至少一个字符，/[^ ]*：表示除了空格，也就是到空格就不匹配了，*：表示匹配前一个字符出现0次或者无限次，即可有可无
• ^:参考博客

• 6.1、在五里面判断邮箱是不完善的，我们看如下

  import re
  
  email_list = ["xiaoWang@163.com", "xiaoWang@163.comheihei", ".com.xiaowang@qq.com"]
  
  for email in email_list:
        ret = re.match(r"[\w]{4,20}@163\.com", email)
        if ret:
             print("%s 是符合规定的邮件地址,匹配后的结果是:%s" % (email, ret.group()))
        else:
             print("%s 不符合要求" % email)
  

  结果如下(我们可以看到xiaoWang@163.comheihei是不符合邮箱规则的)

  xiaoWang@163.com 是符合规定的邮件地址,匹配后的结果是:xiaoWang@163.com
  xiaoWang@163.comheihei 是符合规定的邮件地址,匹配后的结果是:xiaoWang@163.com
  .com.xiaowang@qq.com 不符合要求
  

• 6.2、对 6.1 的完善后

  import re
  
  email_list = ["xiaoWang@163.com", "xiaoWang@163.comheihei", ".com.xiaowang@qq.com"]
  
  for email in email_list:
        ret = re.match(r"[\w]{4,20}@163\.com$", email)
        if ret:
             print("%s 是符合规定的邮件地址,匹配后的结果是:%s" % (email, ret.group()))
        else:
             print("%s 不符合要求" % email)
  

  打印结果是：

  xiaoWang@163.com 是符合规定的邮件地址,匹配后的结果是:xiaoWang@163.com
  xiaoWang@163.comheihei 不符合要求
  .com.xiaowang@qq.com 不符合要求
  

  提示： re.match()是默认开头的，结尾要自己这是，$是以塔之前的字符结尾，开头大家也可以设置 ^,平时很少用是因为：re.match()是默认开头的

  • 遇到 普通的 ?与.以及* 要用进行转义字符 \ ，如上面的 163.com中的我们要对 . 进行转义，如:163\.com

七、匹配分组

字符	功能
|	匹配左右任意一个表达式
(ab)	将括号中字符作为一个分组
\num	引用分组num匹配到的字符串
(?P<name>)	分组起别名
(?P=name)	引用别名为name分组匹配到的字符串

• 7.1、示例 1，我们以匹配 163或者qq邮箱为例

  import re
  
  email_list = ["xiaoWang@163.com", "xiaoWang@163.comheihei", "xiaowang@qq.com"]
  
  for email in email_list:
     ret = re.match(r"[\w]{4,20}@(163|qq)\.com$", email)
     if ret:
         print("%s 是符合规定的邮件地址,匹配后的结果是:%s" % (email, ret.group()))
     else:
         print("%s 不符合要求" % email)
  

  打印结果是：

  xiaoWang@163.com 是符合规定的邮件地址,匹配后的结果是:xiaoWang@163.com
  xiaoWang@163.comheihei 不符合要求
  xiaowang@qq.com 是符合规定的邮件地址,匹配后的结果是:xiaowang@qq.com
  

  分析：我们可以看到 re.match("[\w]{4,20}@(163|qq)\.com$", email),其中(163|qq)代表可以匹配163或者qq,如果想取出来用的匹配出来的是qq还是163我们可以使用 group(num),其中 num 代表第几个括号，在正则里面你可能用很多个括号，如下

  print("%s 是符合规定的邮件地址,匹配后的结果是:%s 具体匹配的是：%s" % (email, ret.group(),ret.group(1)))
  

  打印结果是：

  xiaoWang@163.com 是符合规定的邮件地址,匹配后的结果是:xiaoWang@163.com 具体匹配的是：163
  xiaoWang@163.comheihei 不符合要求
  xiaowang@qq.com 是符合规定的邮件地址,匹配后的结果是:xiaowang@qq.com 具体匹配的是：qq
  

  提示：如果你还想匹配其他的邮箱：如126等等，可以(163|162|qq)

• 7.2、不是以5、9结尾的手机号码(11位)

  import re
  
  result = re.match(r"1\d{9}[0-46-8]]","13462902659")
  
  if result:
       print("手机号：%s 符合规则"%result.group())
  else:
       print("不符合规则的手机号")
  

• 7.3、提取区号和电话号码

  import re
  
  result = re.match(r"(\d{3,4})-(\d{7,8})$","010-12345678")
  
  if result:
  
      print("符合规则：%s 区号是：%s 电话号码是：%s"%(result.group(),result.group(1),result.group(2)))
  else:
      print("不是符合规则的号码")
  

  打印结果是：

  符合规则：010-12345678 区号是：010 电话号码是：12345678
  

• 7.4、匹配出<body><html>hh</html></body>

  import re
  
  result = re.match(r"<(body)><(html)>\w*</\2></\1>","<body><html>你是标签吗</html></body>")
  
  if result:
       print("可以匹配出结果：%s"%result.group())
  else:
       print("不符合匹配的规则")
  

  结果是：

  可以匹配出结果：<body><html>你是标签吗</html></body>
  

• 7.5、(?P<name>)与(?P=name)的使用：我们还用7.4的例子，用分组起别名来写''

  import re
  
  result = re.match(r"<(?P<p1>body)><(?P<p2>html)>\w*</(?P=p2)></(?P=p1)>","<body><html>你是标签吗</html></body>")
  
  if result:
        print("可以匹配出结果：%s"%result.group())
  else:
        print("不符合匹配的规则")
  

  注意：注意：(?P<name>)和(?P=name)中的字母P大写

八、re 模块的高级用法

• 8.1、search
  需求：匹配出文章阅读的次数

  import re
  
  result = re.search(r"\d+","这篇作文有 299 人读过")
  
  if result:
        print(result.group())
  else:
        print("无法匹配")
  

• 8.2、findall : 找出所有匹配的内容，以 列表 的形式返回

  需求：统计出字符串中出现 love 的次数，代码如下：

  import re
  
  result = re.findall(r"love","I love you baby! Can you love me ? ")
  
  print(result)
  

  打印结果是：

  ['love', 'love']
  

• 8.3、sub 将匹配到的数据进行替换: 返回的是替换过的字符串

  • 需求1：将8.2匹配到的 love 替换为 like

    import re
    
    result = re.sub(r"love","like","I love you baby! Can you love me ? ")
    
    print(result)
    

    结果是：

    I like you baby! Can you like me ?
    

  • 需求2：将 8.1 中匹配出文章阅读的次数 +1 处理

    import re
    
    def add(temp):
    
       # 取出匹配的次数
       read_num_str =  temp.group()
       # 进行+1 操作
       num = int(read_num_str) + 1
       # 返回操作后的结果
       return str(num)
    
    result = re.sub(r"\d+",add,"这篇作文有 299 人读过")
    print(result)
    

    结果是：(上面的add是一个函数名字，自己可以随便写)

    这篇作文有 300 人读过
    

    提示：sub(匹配规则，参数2，要匹配的内容)

    • 参数2 (字符串)：如果你写为字符串，那么将匹配到的内容将被字符串参数2替换掉，如上：需求1
    • 参数2 (函数名)：如果你写为函数名，那么将匹配到的内容将会去调用函数，在函数里面处理过的内容返回，返回的内容将替换掉原来匹配到到的内容，如上：需求2

• 8.4、split 根据匹配进行切割字符串，并返回一个列表

  需求：切割字符串 “ I,love you”

  import re
  
  ret = re.split(r",| ","I,love you")
  print(ret)
  

  打印结果是：

  ['I', 'love', 'you']
  

九、python贪婪和非贪婪

• 9.1、Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；
  非贪婪则相反，总是尝试匹配尽可能少的字符。
  在 "*"、"?"、"+"、"{m,n}"后面加上 ？，使 贪婪 变成 非贪婪。

  >>> s="This is a number 234-235-22-423"
  >>> r=re.match(".+(\d+-\d+-\d+-\d+)",s)
  >>> r.group(1)
  '4-235-22-423'
  >>> r=re.match(".+?(\d+-\d+-\d+-\d+)",s)
  >>> r.group(1)
  '234-235-22-423'
  >>>
  

• 9.2、正则表达式模式中使用到 通配字，那它在从左到右的顺序求值时，会尽量“抓取”满足匹配最长字符串，在我们上面的例子里面，“.+”会从字符串的启始处抓取满足模式的最长字符，其中包括我们想得到的第一个整型字段的中的大部分，“\d+”只需一位字符就可以匹配，所以它匹配了数字“4”，而“.+”则匹配了从字符串起始到这个第一位数字4之前的所有字符。
  解决方式：非贪婪操作符“？”，这个操作符可以用在"*","+","?"的后面，要求正则匹配的越少越好。

  >>> re.match(r"aa(\d+)","aa2343ddd").group(1)
  '2343'
  >>> re.match(r"aa(\d+?)","aa2343ddd").group(1)
  '2'
  >>> re.match(r"aa(\d+)ddd","aa2343ddd").group(1) 
  '2343'
  >>> re.match(r"aa(\d+?)ddd","aa2343ddd").group(1)
  '2343'
  >>>
  

• 9.3、练习：提取url地址

  <img data-original="https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973_201611131917_small.jpg" src="https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973_201611131917_small.jpg" style="display: inline;">
  

  正则为：hhtps://.*?\.jpg

十、r 的作用

>>> mm = "c:\\a\\b\\c"
>>> mm
'c:\\a\\b\\c'
>>> print(mm)
c:\a\b\c
>>> re.match("c:\\\\",mm).group()
'c:\\'
>>> ret = re.match("c:\\\\",mm).group()
>>> print(ret)
c:\
>>> ret = re.match("c:\\\\a",mm).group()
>>> print(ret)
c:\a
>>> ret = re.match(r"c:\\a",mm).group()
>>> print(ret)
c:\a
>>> ret = re.match(r"c:\a",mm).group()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
>>>

说明: Python中字符串前面加上 r 表示原生字符串，与大多数编程语言相同，正则表达式里使用""作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符""，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。

• Python里的原生字符串很好地解决了这个问题，有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

 >>> mm = "c:\\a\\b\\c"
 >>> ret = re.match(r"c:\\a",mm).group()
 >>> print(ret)
 c:\a

解释：如果上面你不用 r,那么正则你需要写为：c:\\\\a,也就是转义，有了r,你就可以省掉了，r可以帮你自己动添加