正则表达式 和 re 模块

正则表达式究竟是什么？

在一些网站注册的时候需要输入手机号码，当你输入一个错误的手机号码的时候，会提示你输入的手机号码格式错误

那么他究竟是如何判断的呢？

我们用Python代码进行表示：

phone_number = input('please input your phone number ： ')

现在关键问题是如何判断我们输入的号码是否合法，

最后根据手机号码一共11位并且是只以13、14、15、17、18开头的数字这些特点，又用python写了如下代码：

while True:
    phone_number = input('please input your phone number ： ')
    if len(phone_number) == 11 \
            and phone_number.isdigit()\
            and (phone_number.startswith('') \
            or phone_number.startswith('') \
            or phone_number.startswith('') \
            or phone_number.startswith('') \
            or phone_number.startswith('')):
        print('是合法的手机号码')
    else:
        print('不是合法的手机号码')

那么有不有简单的判断方法呢？答案是肯定的，以下方法就是使用re模块的正则表达式来匹配手机的合法性的方法

import re
phone_number = input('please input your phone number ： ')
if re.match('^(13|14|15|17|18)[0-9]{9}$',phone_number):
        print('是合法的手机号码')
else:
        print('不是合法的手机号码')

正则表达式究竟是什么？首先谈到正则，就只和字符串相关了。

正则表达式本身和Python没有什么关系，其本身就是匹配字符串内容的一种规则。

官方定义：正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

一些正则表达式的实用工具：在线测试工具 http://tool.chinaz.com/regex/

正则表达式

字符组：

在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用 [] 表示

字符分为很多类，比如数字、字母、标点等等

例如现在要求一个位置只能出现一个数字，那么这个位置上的字符只能是0、1、2~9这10个数之一。

正则	待匹配字符	匹配 结果	说明
[0123456789]	8	True	在一个字符组里枚举合法的所有字符，字符组里的任意一个字符 和"待匹配字符"相同都视为可以匹配
[0123456789]	a	False	由于字符组中没有"a"字符，所以不能匹配
[0-9]	7	True	也可以用-表示范围,[0-9]就和[0123456789]是一个意思
[a-z]	s	True	同样的如果要匹配所有的小写字母，直接用[a-z]就可以表示
[A-Z]	B	True	[A-Z]就表示所有的大写字母
[0-9a-fA-F]	e	True	可以匹配数字，大小写形式的a～f，用来验证十六进制字符

字符：

元字符	匹配内容
.	匹配除换行符以外的任意字符
\w	匹配字母或数字或下划线
\d	匹配数字
\s	匹配任意的空白符
\n	匹配一个换行符
\t	匹配一个制表符
\b	匹配一个单词的结尾
^	匹配字符串的开始
$	匹配字符串的结尾
\W	匹配非字母或数字或下划线
\D	匹配非数字
\S	匹配非空白符
a|b	匹配字符a或字符b
()	匹配括号内的表达式，也表示一个组
[...]	匹配字符组中的字符
[^...]	非。匹配除了字符组中字符的所有字符

量词：

量词	用法说明
*	贪婪匹配：重复零次或更多次
+	重复一次或更多次
?	重复零次或一次
{n}	重复n次
{n,}	重复n次或更多次
{n,m}	重复n到m次

re 模块下的常用方法

findall

查找所有

 *当要从一个字符串中找到所有想要的结果时，使用 findall

import re

ret = re.findall('e', 'evenroot')  # 返回所有满足匹配条件的结果,放在列表里
print(ret) #结果 : ['e', 'e']

import re

ret = re.findall('[a-z]+', 'even root yuan')
    # 返回所有满足匹配条件的结果,放在列表里
print(ret)  #结果['even', 'root', 'yuan']

search

找第一个

 *当只需要从一个字符串中找到一个结果的时候，使用 search

import re

ret = re.search('x','eeevvadfae fsdf zzzzc c')
print(ret)
print(ret.group())
#从前往后，找到一个就返回，返回的变量需要调用group才能拿到结果
#如果没有找到，那么返回None，调用group会报错 

None
Traceback (most recent call last):
  File "D:/Python Road/re模块.py", line 31, in <module>
    print(ret.group())
AttributeError: 'NoneType' object has no attribute 'group'

显示结果

 因为 search 没有找到字符，就会返回 None。所以常用的方式，我们写成这样，防止找不到的时候的输入报错

import re

ret = re.search('x','eeevvadfae fsdf zzzzc c')
if ret:
    print(ret.group())

#显示结果:

match

从头开始找一个

 *当必须要求从最开头就能够匹配上的，使用 match

import re

ret = re.match('a', 'abc').group()  # 同search,不过尽在字符串开始处进行匹配
print(ret)
#结果 : a

# match是从头开始匹配，如果正则规则从头开始可以匹配上，就返回一个变量。
# 匹配的内容需要用group才能显示
# 如果没匹配上，就返回None，调用group会报错

 同样的，因为 match 没有找到字符，就会返回 None。所以常用的方式，我们写成这样，防止找不到的时候的输入报错

import re

ret = re.match('v','eeevvadfae fsdf zzzzc c')
if ret:
    print(ret.group())

split

分割

 *当需要分割一个字符串的时候，使用 split

import re
ret = re.split('[ab]','abcd')
print(ret)
#先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割

sub

替换

 *当需要替换一个字符串的时候，使用 sub

import re
ret = re.sub('\d','H','even3root4time5',1)  #将数字替换成'H'，参数1表示只替换一个
print(ret)

#显示结果：evenHroot4time5

subn

替换，次数，并返回元组

import re
ret = re.subn('\d','H','even3root4time5')   #将数字替换成'H'，返回元组（替换的结果，替换了多少次）
print(ret)

#显示结果：('evenHrootHtimeH', 3)

compile

编译

 *当一条正则规则需要反复使用，且该正则规则长度很长的时候使用 compile

import re

obj = re.compile('\d{3}')
#将正则表达式编译成为一个正则表达式对象，规则是匹配三个数字

ret = obj.search('abc123root')    #正则表达式调用search
print(ret.group())
ret = obj.search('456abc123')
print(ret.group())

#显示结果：
#
#456    

finditer

迭代

 *节省内存，当需要找的东西特别多，又无法全部放进内存的时候，使用 finditer

import re

ret = re.finditer('\d','ds3sy7895a')    #finditer返回一个存放匹配结果的迭代器，返回的变量需要调用group才能拿到结果
print(ret)
print(next(ret).group())    #查看第一个结果
print(next(ret).group())    #查看第二个结果
print([i.group()for i in ret])  #查看剩余的结果

group 分组 和 分组优先机制

正则分组：去已经提取到的数据中再提取数据

group 是 Python 的 group 机制

分组就是把正则式已经匹配到的结果，再去做一次匹配

在 search 中的示例：

import re

ret = re.search('^[1-9](\d{14})(\d{2}[0-9xX])?$','50010119990111000X')
print(ret.group())
print(ret.group(1))
print(ret.group(2))

#显示结果：
#50010119990111000X
#
#00X

search钟的group分组机制示例

在 findall 当中的取消分组优先机制，?:

import re

ret = re.findall('www.(baidu|even).com','www.even.com')      #因为findall会优先把匹配结果组里的内容返回，如果想要匹配结果，就要进行取消分组优先
print(ret)        

ret = re.findall('www.(?:baidu|even).com','www.even.com')    #取消分组优先之后
print(ret)

#显示结果：
#['even']
#['www.even.com']

finadall中的取消分组优先机制?:

在 split 中的示例：

import re

ret = re.split("\d+",'even3root4hello')
print(ret)

ret = re.split("(\d+)",'even3root4hello')    #在匹配部分加上()之后切割出的结果是不一样的
print(ret) 

#即没有()的不保留所匹配的项，有()的能够保留匹配的项
#因为某些情况下需要保留匹配项

#显示结果：
#['even', 'root', 'hello']
#['even', '3', 'root', '4', 'hello']

split中的分组示例

group()  groups()  和  groupdict()

group()        #获取匹配到的所有结果
groups()      #获取模型中匹配到的分组结果
groupdict()  #获取模型中匹配到的分组结果(自定义key名称)

import re
origin = "has abcedroot2003"
r = re.match("h\w+",origin)

print(r.group())
print(r.groups())
print(r.groupdict())

#输出结果
#has
#()
#{}

import re
origin = "has abcedroot2003"
r = re.match("h(\w+)",origin)

print(r.group())
print(r.groups())
print(r.groupdict())

#输出结果
#has
#('as',)
#{}

import re
origin = "has abcedroot2003"
r = re.match("h(?P<name>\w+)",origin)    #自定义key名称，匹配得到字典

print(r.group())
print(r.groups())
print(r.groupdict())

#输出结果
#has
#('as',)
#{'name': 'as'}

爬虫示例

import re
import json
from urllib.request import urlopen

def getPage(url):
    response = urlopen(url)
    return response.read().decode('utf-8')

def parsePage(s):
    com = re.compile(
        '<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?<span class="title">(?P<title>.*?)</span>'
        '.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)评价</span>', re.S)

    ret = com.finditer(s)
    for i in ret:
        yield {
            "id": i.group("id"),
            "title": i.group("title"),
            "rating_num": i.group("rating_num"),
            "comment_num": i.group("comment_num"),
        }

def main(num):
    url = 'https://movie.douban.com/top250?start=%s&filter=' % num
    response_html = getPage(url)
    ret = parsePage(response_html)
    print(ret)
    f = open("move_info7", "a", encoding="utf8")

    for obj in ret:
        print(obj)
        data = str(obj)
        f.write(data + "\n")

count = 0
for i in range(10):
    main(count)
    count += 25

利用正则原理的爬虫示例