python网页爬虫之re库及正则表达式(含实例)

最新推荐文章于 2024-06-20 14:19:39 发布

*Slime*

最新推荐文章于 2024-06-20 14:19:39 发布

阅读量3.9k

点赞数 3

分类专栏： python爬虫文章标签： re 正则表达式

本文链接：https://blog.csdn.net/qq_43333395/article/details/95769227

版权

python爬虫专栏收录该内容

2 篇文章 0 订阅

订阅专栏

python网页爬虫之re库及正则表达式

正则表达式

regular expression 简称“RE”
正则表达式是用来简洁表达一组字符串的表达式。

‘PY’
‘PYY’
‘PYYYYY…’
正则表达式：
PY+

‘PY’开头，后续存在不多于10个字符，后续字符不能是‘P’或‘Y’
‘PYABC’ √
‘PYKXYZ’ ×
正则表达式：
PY[^PY]{0,10}

正则表达式：

1）通用的字符串表达框架
2）简洁表达一组字符串的表达式
3）针对字符串表达“简洁”和“特征”思想的工具
4）判断某字符串的特征归属

正则表达式的语法

操作符	说明	实例
.	表示任何单个字符
[ ]	字符集，对单个字符给出取值范围	[abc]表示a、b、c，[a-z]表示a到z单个字符
[^]	非字符集，对单个字符给出排除范围	[^abc]表示非a或b或c的单个字符
*	前一个字符0次或无限次扩展	abc*表示ab、abc、abccc
+	前一个字符1次或无限次扩展	abc+表示abc、abcc、abccc
?	前一个字符0次或1次扩展	abc?表示ab、abc
\|	左右表达式任意一个	abc\|def 表示 abc、def
{m}	扩展前一个字符m次	ab{2}c表示abbc
{m,n}	扩展前一个字符m至n次（含n）	ab{1,2}c 表示abc、abbc
^	匹配字符串开头	^abc表示abc且在一个字符串的开头
$	匹配字符串结尾	abc$表示abc且在一个字符串的结尾
( )	分组标记，内部只能使用 \|操作运算符	(abc)表示abc,(abc\|def)表示abc、def
\d	数字，等价于\|0-9\|
\w	单词字符，等价于[A-Za-z0-9_]

举例：

P(Y|YT|YTH|YTHO)?N
‘PN’、‘PYN’、’ PYTN’、‘PYTHN’、‘PYTHON’

PY[TH]ON
‘PYTON’、‘PYHON’

PY[^TH]?ON
‘PYON’、‘PYaON’、‘PYbON’、‘PYcON’…

PY{:3}N
‘PN’、‘PYN’、‘PYYN’、‘PYYYN’

^[A-Za-z]+$
由26个字母组成的字符串

^[A-Za-z0-9]+$
由26个字母和数字组成的字符串

^-?\d+$
整数形式字符串

[\u4e00-\u9fa5]
匹配中文字符

重点：

匹配IP地址的正则表达式

IP地址字符串形式的正则表达式
(IP地址分4段，每段0-255)
\d+.\d+.\d+.\d+
\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}

精确写法

0-99 : [1-9]?\d
100-199 : 1\d{2}
200-249 : 2[0-4]\d
250 255: 25[0-5]
(([1-9]?\d|1\d{2}|2[0-4]\d|25[0-5]).){3}([1-9]?\d|1\d{2}|2[0-4]\d|25[0-5])

Re库的基本使用

Re库是Python标准库

re库采用raw string类型表示正则表达式，表示为：r’text’
raw string 是不包含转义符的字符串

函数	说明
re.search( )	在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
re.match( )	从一个字符串的开始位置起匹配正则表达式，返回match对象
re.findall( )	搜索字符串，以列表类型返回全部能匹配的字串
re.split( )	将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
re.finditer( )	搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
re.sub( )	在一个字符串中替换所有匹配正则表达式的字串，返回替换后的字符串

re.search(pattern,string,flags=0)
pattern:正则表达式的字符串或原生字符串表示
string:待匹配字符串
falgs:
re.I 忽略正则表达式的大小写
re.M 正则表达式中的^操作符能够将给定字符串的每行当作匹配开始
re.S 正则表达式中的.操作符能够匹配所有字符，默认匹配除换行符外的所有字符

import re
match = re.search(r'[1-9]\d{5}' , 'BIT 100081')
if match:
    print(match.group(0))
#输出100081

re.match(pattern,string,flags=0)
pattern:正则表达式的字符串或原生字符串表示
string:待匹配字符串

import re
match = re.match(r'[1-9]\d{5}' , '100081')
if match:
    print(match.group(0))
#输出100081

re.findall(pattern,string,flags=0)
pattern:正则表达式的字符串或原生字符串表示
string:待匹配字符串

import re
ls = re.findall(r'[1-9]\d{5}' , 'BIT100081 TSUI100086')
if ls:
    print(ls)
#输出['100081', '100086']

re.split(pattern,string,maxsplit=0,flags=0)
将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
pattern:正则表达式的字符串或原生字符串表示
string:待匹配字符串
maxsplit:最大分割数，剩余部分作为最后一个元素输出

import re
ls = re.split(r'[1-9]\d{5}' , 'BIT100081 TSUI100086')
if ls:
    print(ls)
#输出['BIT', ' TSUI', '']
import re
ls = re.split(r'[1-9]\d{5}' , 'BIT100081 TSUI100086',maxsplit=1)
if ls:
    print(ls)
#输出['BIT', ' TSUI100086']，只匹配第一个

re.finditer(pattern,string,flag=0)
搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象

import re
for m in re.finditer(r'[1-9]\d{5}','BIT100081 TSUI100086'):
    if m:
        print(m.group(0))
 #输出
#100081
#100086

re.sub(pattern,repl,string,count=0,flag=0)
在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串
repl:替换匹配字符串的字符串
count:匹配的最大交换次数

import re
ls = re.sub(r'[1-9]\d{5}',':zipcode','BIT100081 TSU100084')
print(ls)
#输出BIT:zipcode TSU:zipcode

面向对象用法：编译后多次操作

pat = re.compile(r'[1-9]\d{5}')
rst = pat.search('BIT 100081')

regex = re.compile(pattern,flags=0)
将正则表达式的字符串形式编译成正则表达式对象

Re库的match对象

Match对象的属性

.string 待匹配的文本
.re匹配时使用的pattern对象（正则表达式）
.pos 正则表达式搜索文本的开始位置
.endpos 正则表达式搜索文本的结束位置

Match对象的方法

.group(0) 获得匹配后的字符串
.start() 匹配字符串在原始字符串的开始位置
.end() 匹配字符串在原始字符串的结束位置
.span()返回(.start(),end())

import re
m = re.search(r'[1-9]\d{5}','BIT 100081')
print(m.string)
print(m.re)
print(m.pos)
print(m.endpos)
print(m.group(0))
print(m.start())
print(m.end())
#输出结果
#BIT 100081
#re.compile('[1-9]\\d{5}')
#0
#10
#100081
#4
#10

正则表达式的贪婪匹配和最小匹配

Re库默认采用贪婪匹配，即输出匹配最长的子串

>>>match = re.search(r'PY'.*N','PYANBNCNDN')
>>>match.group(0)
'PYANBNCNDN'

最小匹配

>>>match = re.search(r'PY'.*?N','PYANBNCNDN')
>>>match.group(0)
'PYAN'

最小匹配操作符

*？	前一个字符0次或无限次扩展，最小匹配
+？	前一个字符1次或无限次扩展，最小匹配
??	前一个字符0次或1次扩展，最小匹配
{m,n}?	扩展前一个字符m至n次（含n），最小匹配

实例：淘宝商品比价定向爬虫

淘宝搜索页面：https://www.taobao.com/
目标：获取淘宝搜索页面的信息，提取其中的商品名称和价格。

理解：
淘宝的搜索接口
翻页处理

技术路线：requests-re

步骤1：提交商品搜索请求，循环获取页面
步骤2：对于每个页面，提取商品名称和价格信息
步骤3：将信息输出到屏幕上

例如，搜索“书包”

起始页：https://s.taobao.com/search?q=书包&js=1&stats_click=search_radio_all%
3A1&initiative_id=staobaoz_20170105&ie=utf8

第2页：https://s.taobao.com/search?q=书包&js=1&stats_click=search_radio_all%
3A1&initiative_id=staobaoz_20170105&ie=utf8&bcoffset=0&ntoffset=0&p4pp
ushleft=1%2C48&s=44

第3页：https://s.taobao.com/search?q=书包&js=1&stats_click=search_radio_all%
3A1&initiative_id=staobaoz_20170105&ie=utf8&bcoffset=‐3&ntoffset=‐
3&p4ppushleft=1%2C48&s=88

每页44个商品
通过对例子的分析，我们得到了搜索接口和翻页的URL对应属性
定向爬虫的可行性
https://s.taobao.com/robots.txt
User‐agent: *
Disallow: /
所以淘宝的搜索页面是不允许爬虫对它进行爬取的
请注意：这个例子仅探讨技术实现，请不要不加限制的爬取该网站

import re
import requests

def getHTMLText(url):
    try:
        r = requests.get(url, timeout = 30)
        r.raise_for_status()
        r.encoding = r.apparent_encoding
        return r.text
    except:
        print("获取失败")

def parsePage(ilt,html):
    try:
        plt = re.findall(r'\"view_price\"\:\"[\d\.]*\"', html)
        tlt = re.findall(r'\"raw_title\"\:\".*?\"',html)
        for i in range(len(plt)):
            price = eval(plt[i].split(":")[1])
            title = eval(tlt[i].split(":")[1])
            ilt.append([price,title])
    except:
        print("")

def printGoodsList(ilt):
    tplt = "{:4}\t{:8}\t{:16}"
    print(tplt.format("序号","价格","商品名称"))
    count = 0
    for g in ilt:
        count = count + 1
        print(tplt.format(count,g[0],g[1]))

def main():
    goods = "书包"
    depth = 2
    start_url = 'https://s.taobao.com/search?q=' + goods
    infoList = []
    for i in range(depth):
        try:
            url = start_url + '&s=' + str(44*i)
            html = getHTMLText(url)
            parsePage(infoList , html )
        except:
            continue
    printGoodsList(infoList)

main()

因为淘宝重构的原因，此代码不再具备爬取功能。

实例二：“股票数据定向爬虫”实例介绍

目标：获取上交和深交所有股票的名称和交易信息
输出：保存到文件中
技术路线：requests-bs4-re

候选数据网站的选择：
新浪股票：http://finance.sina.com.cn/stock/
百度股票：https://gupiao.baidu.com/stock/

候选数据网站的选择

选取原则：股票信息静态存在于HTML页面中，非js代码生成，没有Robots协议限制。
选取方法：浏览器F12，源代码查看等。

步骤1：从东方财富网获取股票列表
步骤2：根据股票列表逐个到百度股票获取个股信息
步骤3：将结果存储到文件

数据网站的确定

获取股票列表：
东方财富网：http://quote.eastmoney.com/stocklist.html

获取个股信息：
百度股票：https://gupiao.baidu.com/stock/
单个股票：https://gupiao.baidu.com/stock/sz002439.html

查看东方财富网的源代码，可以发现个股链接在标签 <a><a> 中，并且链接都是在东方财富网的链接后面加上 sh(上海) 或者 sz(深圳) 再加上 6 个数字加 “.html”。

我们在东方财富网上获得个股链接（获得 sh/sz+6个数字）即可，然后在百度股票上查看信息。将在东方财富网上的信息加在百度股票后面即可得到单个股票的链接。（见上面举例）

在这里插入图片描述

以上面的单个股票为例 (https://gupiao.baidu.com/stock/sz002439.html), 查看其源代码，可以看出，股票所有信息都在 class 属性为 “stock-info” 的标签中。查看其基本信息，股票名字在 class 属性为 “bets-name” 的标签中，而成交量等信息在标签 <dt><dt> 和 <dd><dd> 中。

在这里插入图片描述

import re
import requests
from bs4 import BeautifulSoup
import bs4
# 股票代码编号信息获取
def getHTMLText(url1):
    try:
        kv = {'user-agent': 'Mozilla/4.0'}
        r=requests.get(url1,headers=kv)
        # 设置浏览器的类型，进行迷惑
        r.raise_for_status()
        # 事先获得编码，提高爬虫速度
        r.encoding='utf-8'
        # 避免r.text错误的情况发生
        if r.text=='':
            getHTMLText(url1)
        else:
            return r.text
    except:
        getHTMLText(url1)
# 爬取所有股票的编号列表
def getStockList(demo):
    soup = BeautifulSoup(demo, 'html.parser')
    a = soup('a')
    for i in a:
        try:
            href= i.attrs['href']
            # 通过正则表达式来获得需要的部分
            str1=re.findall(r'[s][hz]\d{6}',href)
            # 排除不合格的href
            if str1!=[]:
                fllist.append(re.findall(r'[s][hz]\d{6}',href))
            else:
                continue
        except:
            continue
    return fllist
# 爬取单个股票的信息
def getStockInfo(demo2,output_file,stock):
    infolist = {}
    try:
        soup = BeautifulSoup(demo2, 'html.parser')
        stocklist=soup.find("div",class_="stock-bets")
        # 获取股票名称
        name=stocklist.find(class_='bets-name')
        infolist.update({'股票名称':name.text.split()[0]})
        # 获取股票其他信息
        for dl in stocklist.descendants:
            if isinstance(dl,bs4.element.Tag):
                key=dl.find('dt')
                value=dl.find('dd')
                # 排除当key为空值
                if key!=None:
                    infolist[key.string]=value.string
        # 将股票信息放入文件中
        with open(output_file,'a',encoding='utf-8') as f:
            f.write(str(infolist) + '\n')
    except:
        # 将爬取出错的股票信息打印放入到no_do列表中
        no_do.append(stock)
# 主函数
if __name__ == '__main__':
    count=1
    no_do=[]
    fllist=[]
    # 股票列表url
    stock_list_url='http://quote.eastmoney.com/stocklist.html'
    # 文件存放地址
    output_file = 'C:/Users/13156/Desktop/爬虫/Result_stock.txt'
    # 获取到股票列表 fllist
    demo=getHTMLText(stock_list_url)
    fllist=getStockList(demo)
    #对所有的股票进行迭代
    for i in range(len(fllist)):
        count+=1
        # 百度个股信息url
        stock_info_url = "https://gupiao.baidu.com/stock/{}.html".format(str(fllist[i])[2:-2])
        demo2=getHTMLText(stock_info_url)
        # 处理和打印个股信息
        getStockInfo(demo2,output_file,fllist[i])
        # 打印出进度条
        print('\r当前进度：{:.2f}%'.format(count*100 / len(fllist)),end='')
    # 打印出异常的信息
    print(no_do)

结果:
在这里插入图片描述

【参考】北京理工大学网络公开课：http://www.icourse163.org/course/BIT-1001870001

*Slime*

关注

3
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
python网页爬虫之re库及正则表达式(含实例)

python网页爬虫之re库及正则表达式正则表达式regular expression 简称“RE”正则表达式是用来简洁表达一组字符串的表达式。‘PY’‘PYY’‘PYYYYY…’正则表达式：PY+‘PY’开头，后续存在不多于10个字符，后续字符不能是‘P’或‘Y’‘PYABC’ √‘PYKXYZ’ ×正则表达式：PY[^PY]{0,10}正则表达式：1）通用的字符串...
复制链接

扫一扫

专栏目录