python网络爬虫之三re正则表达式模块

"""
re正则表达式，正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的
一些特定字符，及这些特定字符的组合，组成一个"规则字符串",然后用这个"规则
字符串"去匹配过滤出我们想要的字符串。
"""
我们可以利用工具来测试或者生成我们想要的"规则字符串"。
正则表达式常见的匹配模式：
匹配模式           描述
^           匹配字符串的开头
$           匹配字符串的结尾
.           表示匹配任意一个字符，除了换行符，当re.DOTALL标记被指定时，则表示匹配包括
            换行符在内的任意字符。
*           表示匹配任意多个前面的表达式，通常.*用来表示任意的字符。
？            非贪婪匹配，通常用.*?表示非贪婪匹配。
a|b         表示匹配a或b
()          匹配括号内的一个表达式，也表示匹配一个组
\s          匹配任意空白字符，也通常用来表示空白换行符。
\w          表示可以匹配一个字符串，匹配字母数字及下划线，或者中文字符都可以。\w+可以表示匹配任意多个字符
\W          匹配非字母数字及下划线
\S          匹配任意非空字符
\d          匹配任意数字，等价与[0-9]，注：\为转移字符，d表示数字，而\d+可以表示任意的数字。
\D          匹配任意非数字
\A          匹配字符串开始
\n          匹配一个换行符
\t          匹配一个制表符

+           匹配一个或多个表达式

{n}         精确匹配前面的n个表达式
{n,m}       贪婪模式，匹配前面的n到m次前面的表达式

常用的正则表达式匹配标志位：
正则表达式的匹配标志位可以用来控制正则表达式的匹配模式，这个匹配标志位是可选的，多个正则表达式的
匹配标志位可以用OR或|来链接指定他们，如re.S|re.M
常用的正则表达式匹配标志位有：
re.DOTALL :用来表示.可以匹配包括换行符在内的任意字符，正常情况下.是不能匹配换行符的。
re.S      :同re.DOTALL一样，也用来表示.可以匹配包括换行符在内的任意字符，正常情况下.是不能匹配
           换行符的，用这两个哪个都可以。
re.M      :表示多行匹配，影响^和$
re.l      :表示匹配对大小写不敏感
re.U      :根据Unicode字符集解析字符，这个影响标志位\w,\W,\b,\B。
re.L      :做本地化识别匹配
re.X      :可以更改正则表达式的格式以便我们更方便理解查看

常用的匹配方法：re.match re.search re.findall re.sub re.compile re.finditer re.split

这些常用的匹配方法返回的结果分别是：
1. re.compile     re.compile() 是将正则表达封装并返回正则表达式对象，这样更方便我们理解阅读。
2. re.match       #返回一个字符串
3. re.search      #返回一个字符串
4. re.findall     #返回一个字符串
5. re.sub
6. re.finditer
7. re.split

一. re.compile
re.compile函数用来编译正则表达式，用来将正则表达式编译成一个正则表达式对象，供后面的几个
正则表达式匹配函数使用。
re.compile语法：
re.compile(pattern[,flags])
注：pattern表示一个字符串形式的正则表达式，flags表示正则表达式标志位，这个参数可选。
我们可以用re.compile返回的这个正则表达式对象去匹配我们想要的函数，这样的话我们就方便
了代码的复用和调用：
如下所示：
import re
content = "Hello 1234567 World_This
is a Regex Demo"
pattern = re.compile('Hello.*Demo',re.S)
result = re.match(pattern,content)
print(result)

二. re.match
re.match函数尝试从字符串的起始位置去匹配一个字符串，如果不是从起始位置匹配成功的话，
re.match函数就返回一个none。
re.match(patter,string,flags=0)

#1.最常规的匹配：
import re
content = "Hello 123 4567 World_This is a Regex Demo"
result = re.match('^Hello\s\d\d\d\s\d{4}\s\w{10}.*Demo$',content)
print(result)
print(result.group())
print(result.span())

#2.匹配目标，用()来指定我们的匹配目标：
import re
content = "Hello 1234567 World_This is a Regex Demo"
result = re.match('^Hello\s(\d+)\sWorld.*Demo$',content)
print(result)
print(result.group(1))
print(result.span())

#3.泛匹配，用.*表示所有的匹配字符：
import re
content = "Hello 123 4567 World_This is a Regex Demo"
result = re.match('^Hello.*Demo',content)
print(result)
print(result.group())
print(result.span())

#4.贪婪匹配：
import re
content = "Hello 1234567 World_This is a Regex Demo"
result = re.match('^Hello\s(\d+)\sWorld.*Demo$',content)
print(result)
print(result.group(1))
print(result.span())

#5.非贪婪匹配：
import re
content = "Hello 1234567 World_This is a Regex Demo"
result = re.match('^Hello\s(\d+)\sWorld.*Demo$',content)
print(result)
print(result.group(1))
print(result.span())

#6.匹配模式：
import re
content = "Hello 1234567 World_This
is a Regex Demo"
result = re.match('^He.*?(\d+).*?Demo$',content)
print(result)
print(result.group(1))
print(result.span())

#7.匹配转义字符：

总结：我们在使用re.match进行匹配字符串时，尽量使用泛匹配，即尽量多使用.*?来匹配，
尽量使用非贪婪模式匹配，有换行符就指定匹配模式re.$。
html = """ <div id="songs-list">
           <h2 class="title">经典老歌</h2>
           <p class="introduction">
            经典老歌列表
           </p>
           <ul id="list" class="list-group">
            <li data-view="2">一路上有你</li>
            <li data-view="7">
              <a href="/2.mp3" singer="任贤齐">沧海一声笑</a>
            </li>
            <li data-view="4" class="active">
                <a href="/3.mp3" singer="齐秦">往事随风</a>
            </li>
            <li data-view="6"><a href="/4.mp3" singer="beyond">光辉岁月</a></li>
            <li data-view="5"><a href="/5.mp3" singer="陈慧琳">记事本</a></li>
            <li data-view="5">
               <a href="/6.mp3" singer="邓丽君">但愿人长久</a>
            </li>
            </ul>
            </div> """

2. re.search
re.search扫描整个字符串并返回第一个成功的匹配

re.search与re.match的比较：
import re
content = "Extra strings Hello 1234567 World_This is a Regex Demo Extra strings"
result = re.match('Hello.*?(\d+).*?',content)
print(result)
此时返回结果为空。

import re
content = "Extra strings Hello 1234567 World_This is a Regex Demo Extra strings"
result = re.search('Hello.*?(\d+).*?',content)
print(result)
print(result.group(1))
输出为：
<_sre.SRE_Match object; span=(14, 27), match='Hello 1234567'>
1234567

总结，从上面的匹配结果可以看到，re.match必须从字符串的头部开始匹配，因此，为了匹配方便，
我们尽量能用re.search就不用re.match。

re.search匹配练习：
第一种：
import re
html = """ <div id="songs-list">
           <h2 class="title">经典老歌</h2>
           <p class="introduction">
            经典老歌列表
           </p>
           <ul id="list" class="list-group">
            <li data-view="2">一路上有你</li>
            <li data-view="7">
              <a href="/2.mp3" singer="任贤齐">沧海一声笑</a>
            </li>
            <li data-view="4" class="active">
                <a href="/3.mp3" singer="齐秦">往事随风</a>
            </li>
            <li data-view="6"><a href="/4.mp3" singer="beyond">光辉岁月</a></li>
            <li data-view="5"><a href="/5.mp3" singer="陈慧琳">记事本</a></li>
            <li data-view="5">
               <a href="/6.mp3" singer="邓丽君">但愿人长久</a>
            </li>
            </ul>
            </div> """
result = re.search('<li.*?active.*?singer="(.*?)">(.*?)</a>',html,re.S)
if result:
    print(result.group(1),result.group(2))

第二种：
import re
html = """ <div id="songs-list">
           <h2 class="title">经典老歌</h2>
           <p class="introduction">
            经典老歌列表
           </p>
           <ul id="list" class="list-group">
            <li data-view="2">一路上有你</li>
            <li data-view="7">
              <a href="/2.mp3" singer="任贤齐">沧海一声笑</a>
            </li>
            <li data-view="4" class="active">
                <a href="/3.mp3" singer="齐秦">往事随风</a>
            </li>
            <li data-view="6"><a href="/4.mp3" singer="beyond">光辉岁月</a></li>
            <li data-view="5"><a href="/5.mp3" singer="陈慧琳">记事本</a></li>
            <li data-view="5">
               <a href="/6.mp3" singer="邓丽君">但愿人长久</a>
            </li>
            </ul>
            </div> """
result = re.search('<li.*?singer="(.*?)">(.*?)</a>',html,re.S)
if result:
    print(result.group(1),result.group(2))

第三种：

三.re.sub
替换字符串中我们所指定的字符串，然后返回我们替换后的字符串
我们结合re.sub可以更方便的完成字符串的提取：
re.sub的格式如下：
re.sub('原字符串','要替换成的目标字符串',flags)
如下所示：
#1.替换为空，删除功能，使用这种方式我们可以用来删除指定的字符串，如一些常用的
#不需要的a标签，换行符等
import re
content = "Hello strings 1234567 World_This is a Regex Demo"
content = re.sub('\d+',"",content)
print(content)
此时我们可以看到，就把原来字符串中的数字删除掉了，或者可以认为把原来的数字
替换成了空字符串，并输出：
Hello strings  World_This is a Regex Demo

#2.替换成指定的字符串，如下所示：
import re
content = "Hello strings 1234567 World_This is a Regex Demo"
content = re.sub('\d+',"Replacement",content)
print(content)
此时我们可以看到，就把原来字符串中的数字替换成了字符串Replacement，并输出结果为：
Hello strings Replacement World_This is a Regex Demo

#3.在原来内容内追加，为了避免歧义，这种方式我们一般不常用，一般都是使用第2种方式直接替换。
import re
content = "Hello strings 1234567 World_This is a Regex Demo"
content = re.sub('(\d+)',r'\1 8910',content)
print(content)
此时我们可以看到，使用r可以保证原来1中的那个原生的字符，就把原来数字元组中的数字
替换成了1234567 8910，并输出结果为：
Hello strings 1234567 8910 World_This is a Regex Demo
#注:r表示原生字符串的意思。

四. re.findall
搜索字符串，并以列表的形式返回所有的匹配结果对象，而每一个结果对象都一个元组的形式存在的。
从这里我们可以看到，一般在python编程中，只要是一个对象，一般都是以元组的形式存在的。
#1.简单匹配，查找指定的字符串元组。
import re
html = """ <div id="songs-list">
           <h2 class="title">经典老歌</h2>
           <p class="introduction">
            经典老歌列表
           </p>
           <ul id="list" class="list-group">
            <li data-view="2">一路上有你</li>
            <li data-view="7">
              <a href="/2.mp3" singer="任贤齐">沧海一声笑</a>
            </li>
            <li data-view="4" class="active">
                <a href="/3.mp3" singer="齐秦">往事随风</a>
            </li>
            <li data-view="6"><a href="/4.mp3" singer="beyond">光辉岁月</a></li>
            <li data-view="5"><a href="/5.mp3" singer="陈慧琳">记事本</a></li>
            <li data-view="5">
               <a href="/6.mp3" singer="邓丽君">但愿人长久</a>
            </li>
            </ul>
            </div> """
results = re.findall('<li.*?href="(.*?)".*?singer="(.*?)">(.*?)</a>',html,re.S)
print(results)
print(type(results))           #此时我们可以看到，这是一个列表的形式，<class 'list'>
for result in results:
    print(result)              #此时可以看到，每一个结果都是元组的形式
    print(result[0],result[1],result[2])    #此时我们可以通过每一个元组的位置参数取出每一个元组中的值
#此时可以看到打印结果如下：
[('/2.mp3', '任贤齐', '沧海一声笑'), ('/3.mp3', '齐秦', '往事随风'), ('/4.mp3', 'beyond', '光辉岁月'),
 ('/5.mp3', '陈慧琳', '记事本'), ('/6.mp3', '邓丽君', '但愿人长久')]
<class 'list'>
('/2.mp3', '任贤齐', '沧海一声笑')
/2.mp3 任贤齐 沧海一声笑
('/3.mp3', '齐秦', '往事随风')
/3.mp3 齐秦 往事随风
('/4.mp3', 'beyond', '光辉岁月')
/4.mp3 beyond 光辉岁月
('/5.mp3', '陈慧琳', '记事本')
/5.mp3 陈慧琳 记事本
('/6.mp3', '邓丽君', '但愿人长久')
/6.mp3 邓丽君 但愿人长久

#注：通过上面的方式，我们可以看到，第一首歌因为它的歌名的超链接不存在，因此整个信息都没匹配出来，
#因此我们需要寻找一种方式，而这种方式既能匹配有的结果，又能匹配没有的结果，即表示，有没有都能匹
#配出来，此时我们可以用()?来表示，匹配的元组数据，？表示前面的数据有没有都可以，如果是单独的字符
#的话，可以指定单独的字符，比如a?,或者是a*?,()?,()*?,都可以,如果是空格或者是换行符的话可以
#使用\s*?来表示。
#2.查找所有的歌名信息，复杂模式的匹配:
import re
html = """ <div id="songs-list">
           <h2 class="title">经典老歌</h2>
           <p class="introduction">
            经典老歌列表
           </p>
           <ul id="list" class="list-group">
            <li data-view="2">一路上有你</li>
            <li data-view="7">
              <a href="/2.mp3" singer="任贤齐">沧海一声笑</a>
            </li>
            <li data-view="4" class="active">
                <a href="/3.mp3" singer="齐秦">往事随风</a>
            </li>
            <li data-view="6"><a href="/4.mp3" singer="beyond">光辉岁月</a></li>
            <li data-view="5"><a href="/5.mp3" singer="陈慧琳">记事本</a></li>
            <li data-view="5">
               <a href="/6.mp3" singer="邓丽君">但愿人长久</a>
            </li>
            </ul>
            </div> """
results = re.findall('<li.*?>\s*?(<a.*?>)?(\w+)?(</a>)?\s*?</li>',html,re.S)
#注：换行可以用\s表示，*表示一个或多个之前的元素，？可以表示有还是没有，()内的内容可以表示为有或者没有，

print(results)
print(type(results))           #此时我们可以看到，这是一个列表的形式，<class 'list'>
for result in results:
    print(result)              #此时可以看到，每一个结果都是元组的形式
    print(result[1])           #此时我们可以通过每一个元组的位置参数取出元组中的第二个位置中的歌名的信息。
#此时可以看到打印结果如下：
[('', '一路上有你', ''), ('<a href="/2.mp3" singer="任贤齐">', '沧海一声笑', '</a>'),
('<a href="/3.mp3" singer="齐秦">', '往事随风', '</a>'),
('<a href="/4.mp3" singer="beyond">', '光辉岁月', '</a>'),
('<a href="/5.mp3" singer="陈慧琳">', '记事本', '</a>'),
('<a href="/6.mp3" singer="邓丽君">', '但愿人长久', '</a>')]
<class 'list'>
一路上有你
沧海一声笑
往事随风
光辉岁月
记事本
但愿人长久

#3.我们可以使用re.sub结合re.findall结合使用：
import re
html = """ <div id="songs-list">
           <h2 class="title">经典老歌</h2>
           <p class="introduction">
            经典老歌列表
           </p>
           <ul id="list" class="list-group">
            <li data-view="2">一路上有你</li>
            <li data-view="7">
              <a href="/2.mp3" singer="任贤齐">沧海一声笑</a>
            </li>
            <li data-view="4" class="active">
                <a href="/3.mp3" singer="齐秦">往事随风</a>
            </li>
            <li data-view="6"><a href="/4.mp3" singer="beyond">光辉岁月</a></li>
            <li data-view="5"><a href="/5.mp3" singer="陈慧琳">记事本</a></li>
            <li data-view="5">
               <a href="/6.mp3" singer="邓丽君">但愿人长久</a>
            </li>
            </ul>
            </div> """

#此时我们可以先用re.sub将原来的a标签删除替换掉：
html = re.sub('<a.*?>|</a>',"",html)
print(html)
#注：这个地方a标签中间的|表示与，表示两者内容都替换，然后再用re.findall来提取歌名即可。
results = re.findall('<li.*?>(.*?)</li>',html,re.S)
print(results)
print(type(results))
for result in results:
    print(result.strip())          #因为列表中含有换行字符，使用strip()方法，去除换行字符即可。
#此时打印输出，即可得到我们想要的结果：
['一路上有你', '\n              沧海一声笑\n            ',
' \n                往事随风 \n            ', '光辉岁月',
'记事本', ' \n               但愿人长久 \n            ']
<class 'list'>
一路上有你
沧海一声笑
往事随风
光辉岁月
记事本
但愿人长久

#此时我们就通过了re.sub(),和re.findall()方法实现了歌名的爬取。