爬虫之网络数据解析的三种方式---正则表达式、XPath数据解析库、BeautifulSoup数据解析库

最新推荐文章于 2024-09-22 20:27:22 发布
最新推荐文章于 2024-09-22 20:27:22 发布
阅读量2.5k 收藏 9
点赞数 2
分类专栏： 爬虫
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wangtuo1115/article/details/105741228
版权

1、正则表达式

爬虫的四个主要步骤：

  1. 明确目标（要知道你准备取哪个范围或者网站上取搜索）
  2. 爬（将所有网站的内容全部爬下来）
  3. 取（取掉对我们没用的数据）
  4. 处理数据（按照我们想要的方式存储和使用）

什么是正则表达式？

正则表达式(regular expression)，又称为规则表达式，描述了一种字符串匹配的模式（pattern），通常被用来检索、替换那些符合某个模式（规则）的文本。

正则表达式是由普通字符（例如字符a到z）+ 特殊字符（称为“元字符”）组成的文字模式。

正则表达式被广泛的集成到各种文本编辑器/文本处理工具当中

应用场景

  1. 验证： 表单提交时，进行用户名密码的验证
  2. 查找： 从大量信息中快速提取指定内容，在一批url中，查找指定的url，通常用于爬虫
  3. 替换： 将指定格式的文本进行正则匹配查找，找到之后进行特定替换

基本要素

  1. 字符串
  2. 数量限定符
  3. 位置限定符
  4. 预定义字符集
1、字符类
语法说明表达式实例完整匹配的字符串
一般字符匹配自身abcabc
.匹配任意除了换行符"\n"外的字符a.cabc
\转义字符，使后一个字符改变原来的意思a.ca.c
[…]匹配[ ]内任一字符。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，如[abc]或[a-c]。如果第一个字符是^则表示取反，如[^abc]表示不是abc的其他字符。a[bcd]eabe、ace、ade
-在[ ]内表示字符范围wo[a-c]ldwoald、wocld
2、数量限定符
字符含义举例匹配的字符串
*匹配前一个字符0次或者无限次abc*ab、abccccc
？匹配前一个字符0次或1次abc?ab、abc
+匹配前一个字符1次或者无限次abc+abc、abcccc
{m}匹配前一个字符m次ab{2}cabbc
{m,n}匹配前一个字符m至n次。m和n可以省略：若省略m，则匹配0至n次；若省略n，则至少匹配m次。ab{1,2}cabc、abbc
3、位置限定符

在这里插入图片描述

4、预定义字符集

在这里插入图片描述

5、逻辑、分组

在这里插入图片描述

re模块一般使用步骤

  1. 使用 compile() 函数将正则表达式的字符串形式编译为一个 Pattern 对象
  2. 通过 Pattern 对象对文本进行匹配查找，获得匹配结果，一个 Match 对象。
  3. 使用 Match 对象提供的属性和方法获得信息，根据需要进行其他的操作

在这里插入图片描述
正则表达式实现步骤：

# 1.使用compile()函数将正则表达式的字符串形式编译为一个Pattern对象
# 注意：re对特殊字符进行转义, 如果使用原始字符串,只需加一个r前缀
import re

text = "2020-12-12 2019-5-3 2020/10/10"

pattern = re.compile(r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})') # 命名分组
# 2.通过Pattern对象对文本进行匹配查找，获得匹配结果，一个Match对象
# search从给定的字符串中寻找一个符合规则的字符串，返回回来一个
result = re.search(pattern, text)

print(result)

# 3.使用Match对象提供的属性和方法获取信息，根据需要进行操作
print(result.group())  # 返回的是匹配到的文本信息  2020-12-12
print(result.groups()) # 返回的是位置分组信息  ('2020', '12', '12')
print(result.groupdict()) #返回的是关键字分组信息 {'year': '2020', 'month': '12', 'day': '12'}

Pattern对象

正则表达式编译成 Pattern 对象， 可以利用 pattern 的一系列方法对文本进行匹配查找了。
在这里插入图片描述

Pattern 对象的一些常用方法主要有：

  • match 方法：从起始位置开始查找，一次匹配
  • search 方法：从任何位置开始查找，一次匹配
  • findall 方法：全部匹配，返回列表
  • finditer 方法：全部匹配，返回迭代器
  • split 方法：分割字符串，返回列表
  • sub 方法：替换

match方法

match 方法用于查找字符串的头部（也可以指定起始位置），它是一次匹配，只要找到了一个匹配的结果就返回， 而不是查找所有匹配的结果。它的一般使用形式如下：
在这里插入图片描述

  • string 待匹配的字符串
  • pos 字符串的起始位置， 默认值是 0
  • endpos 字符串的终点位置， 默认值是 len (字符串长度)

re模块常量

常量即表示不可更改的变量，一般用于做标记。下图是常用的四个模块常量:
在这里插入图片描述

Match对象

  • group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；
  • start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
  • end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
  • span([group]) 方法返回 (start(group), end(group))。

search方法

search 方法用于查找字符串的任何位置，它也是一次匹配，只要找到了一个匹配的结果就返回，而不是查找所有 匹配的结果，它的一般使用形式如下：
在这里插入图片描述
当匹配成功时，返回一个 Match 对象，如果没有匹配上，则返回 None。

findall方法与finditer方法

findall 方法搜索整个字符串，获得所有匹配的结果。使用形式如下：

在这里插入图片描述
finditer 方法的行为跟 findall 的行为类似，也是搜索整个字符串，获得所有匹配的结果。但它返回一个顺序访问每 一个匹配结果（Match 对象）的迭代器。

split方法

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
在这里插入图片描述

  • maxsplit 指定最大分割次数，不指定将全部分割

sub方法

sub 方法用于替换。它的使用形式如下：

在这里插入图片描述

  • repl 可以是字符串也可以是一个函数：
       1). 如果 repl 是字符串，则会使用 repl 去替换字符串每一个匹配的子串，并返回替换后的字符串，另外，repl 还 可以使用 id 的形式来引用分组，但不能使用编号 0；
       2). 如果 repl 是函数，这个方法应当只接受一个参数（Match 对象），并返回一个字符串用于替换（返回的字符 串中不能再引用分组）。
  • count 用于指定最多替换次数，不指定时全部替换。

正则split和sub方法：

import re

text = "1+2-3*4-5/5"
# ************split**************
pattern = re.compile(r'\+|-|\*|/')
result = re.split(pattern, text)
print(result)

# *************sub**********
def repl_string(matchObj):
    items = matchObj.groups()
    print(items)
    return '-'.join(items)

text = '2010/10/10 2020/12/12 2010-5-3'
pattern = re.compile(r'(\d{4})/(\d{1,2})/(\d{1,2})')
result = re.sub(pattern,repl_string, text)
print(result)


['1', '2', '3', '4', '5', '5']
('2010', '10', '10')
('2020', '12', '12')
2010-10-10 2020-12-12 2010-5-3

贪婪模式和非贪婪模式

  1. 贪婪模式：在整个表达式匹配成功的前提下，尽可能多的匹配 ( * )；
    使用贪婪的数量词的正则表达式 ab* ，匹配结果： abbb。* 决定了尽可能多匹配 b，所以a后面所有的 b 都出现了。
  2. 非贪婪模式：在整个表达式匹配成功的前提下，尽可能少的匹配 ( ? )；
    使用非贪婪的数量词的正则表达式 ab*? ，匹配结果： a。
    即使前面有 * ，但是 ? 决定了尽可能少匹配 b，所以没有 b。
  3. Python里数量词默认是贪婪的。

基于requests和正则的猫眼电影TOP100定向爬虫：
项目介绍: 应用requests库和正则表达式来抓取猫眼电影TOP100的电影名称、时间、评分、图片等信息。

项目分析:
1. 需求分析，明确采集的网址。
https://maoyan.com/board
2. 爬, requests数据采集库
3. 取,正则表达式数据解析库
4. 存, json格式存储到文件

import codecs
import json
import re
import time
from urllib.error import HTTPError

import requests
from colorama import Fore
from fake_useragent import UserAgent


def down_page(url):
    try:
        ua = UserAgent()
        headers = {
            'User-Agent':ua.random,
            'Cookie':'__mta=49747353.1586608791319.1586618569026.1586618581654.11; uuid_n_v=v1; uuid=73354BA07BAE11EA81AF6B12644ABFB70CD0E584BFFF4456AE4AA96286336568; _csrf=1d3978fad0d68febffd13896596effb6fa9633349bd601af3678a1bcd78c47b9; Hm_lvt_703e94591e87be68cc8da0da7cbd0be2=1586608791,1586609306; Hm_lpvt_703e94591e87be68cc8da0da7cbd0be2=1586618649; _lxsdk_cuid=1716940dec2c8-018cbd125127c58-3e6e4647-100200-1716940dec2c8; _lxsdk=73354BA07BAE11EA81AF6B12644ABFB70CD0E584BFFF4456AE4AA96286336568; mojo-uuid=1a2bc23bad16f412c35c00f9b881946a; __mta=49747353.1586608791319.1586618086296.1586618566417.10; _lx_utm=utm_source%3DBaidu%26utm_medium%3Dorganic; _lxsdk_s=17169b3dce9-5ef-6b5-ccd%7C%7C28; mojo-trace-id=20; mojo-session-id={"id":"05adcf6f220fcf28a22a52d7640319db","time":1586616327477}',
            'Host':'maoyan.com',

        }
        response = requests.get(url, headers=headers)
    except HTTPError as e:
        print(Fore.RED + '[-] 爬取网页%s失败:%s' %(url, e.reason))
        return None
    else:
        return response.text

def parse_html(html):
    """通过正则表达式对html解析获取电影名称、时间、排行、图片等信息"""
    pattern = re.compile(
        '<dd>'
        + '.*?<i class="board-index.*?">(\d+)</i>' # <i class="board-index board-index-1">1</i>
        + '.*?<img data-src="(.*?)" alt="(.*?)"'# <img data-src="xxxxxx" alt="我和我的祖国" >
        + '.*?<p class="star">(.*?)</p>'         #<p class="star">主演：黄渤,张译,韩昊霖</p>
        + '.*?<p class="releasetime">(.*?)</p>' #<p class="releasetime">上映时间：2019-09-30</p>
        + '.*?</dd>',
        re.S
    )
    # finditer返回的是迭代器， findall返回的是列表
    items = re.finditer(pattern, html)
    for item in items:
        yield {
            'index':item.groups()[0],
            'image':item.groups()[1],
            'title':item.groups()[2],
            'star':item.groups()[3].strip().lstrip('主演：'),
            'releasetime':item.groups()[4].lstrip('上映时间：')
        }

def save_to_json(data, filename):
    """将爬取的数据写入json文件"""
    # with open(filename, 'ab') as f:
    #     f.write(json.dumps(data, ensure_ascii=False, indent=4).encode('utf-8'))
    #     print(Fore.GREEN + '[+] 保存电影 %s 的信息成功' %(data['title']))
    with codecs.open(filename, 'a', 'utf-8') as f:
        f.write(json.dumps(data, ensure_ascii=False, indent=4))
        print(Fore.GREEN + '[+] 保存电影 %s 的信息成功' % (data['title']))

def get_one_page(page=1):
    # url = 'https://maoyan.com/board/'
    url = 'https://maoyan.com/board/4?offset=%s' %((page-1)*10)
    html = down_page(url)
    # print(html)
    items = parse_html(html)
    # print(items)
    # item是字典
    for item in items:
        save_to_json(item, 'maoyanTop100.json')

def use_multi_thread():
    # 使用多线程实现
    from threading import Thread
    for page in range(1, 11):
        thread = Thread(target=get_one_page, args=(page,))
        thread.start()
        print(Fore.GREEN + '[+]采集第%s页数据成功' % (page))

def use_thread_pool():
    # 使用线程池
    from concurrent.futures import ThreadPoolExecutor
    # 实例化线程池并指定线程池的线程个数
    pool = ThreadPoolExecutor(100)
    pool.map(get_one_page, range(1, 11))
    print('采集结束')

if __name__ == '__main__':
    # for page in range(1,11):
    #     get_one_page(page)
    #     print(Fore.GREEN + '[+]采集第%s页数据成功' %(page))
    #     # 反爬虫策略:防止爬虫速度过快被限速,在采集数据的过程中,休眠一段时间
    #     time.sleep(0.5)

    # 使用多线程
    # use_multi_thread()

    # 使用线程池
    use_thread_pool()

2、XPath数据解析库

什么是XPath？

lxml是python的一个解析库，支持HTML和XML的解析，支持XPath解析方式，而且解析效率非常高。
XPath (XML Path Language) 是一门在 xml文档中查找信息的语言，可用来在 xml /html文档中对元素和属性进行遍历。

查询更多XPath的用法: https://www.w3school.com.cn/xpath/xpath_syntax.asp

XPath如何实现文档解析？

  1. etree库把HTML文档中的字符串解析为Element对象
from lxml import etree
html=etree.HTML(text)
result=etree.tostring(html)
  1. etree库把HTML文档解析为Element对象
html=etree.parse('xxx.html')
result=etree.tostring(html,pretty_print=True)

谓语（Predicates）

谓语用来查找某个特定的节点或者包含某个指定的值的节点，被嵌在方括号中。
在这里插入图片描述

常用规则汇总

在这里插入图片描述在这里插入图片描述

基于requests和XPath的猫眼电影TOP100定向爬虫：

项目介绍: 应用requests库和Xpath来抓取TIOBE编程语言的去年名次、今年名词、编程语言名词、评级和变化率等信息。
项目分析:
1. 需求分析，明确采集的网址。
https://www.tiobe.com/tiobe-index/
2. 爬, requests数据采集库
3. 取,Xpath数据解析库
4. 存, csv格式存储到文件

import codecs
import json
import re
import time
from urllib.error import HTTPError

import requests
from colorama import Fore
from fake_useragent import UserAgent
from lxml import etree


def down_page(url):
    try:
        ua = UserAgent()
        headers = {
            'User-Agent':ua.random,
            'Cookie':'__mta=49747353.1586608791319.1586618569026.1586618581654.11; uuid_n_v=v1; uuid=73354BA07BAE11EA81AF6B12644ABFB70CD0E584BFFF4456AE4AA96286336568; _csrf=1d3978fad0d68febffd13896596effb6fa9633349bd601af3678a1bcd78c47b9; Hm_lvt_703e94591e87be68cc8da0da7cbd0be2=1586608791,1586609306; Hm_lpvt_703e94591e87be68cc8da0da7cbd0be2=1586618649; _lxsdk_cuid=1716940dec2c8-018cbd125127c58-3e6e4647-100200-1716940dec2c8; _lxsdk=73354BA07BAE11EA81AF6B12644ABFB70CD0E584BFFF4456AE4AA96286336568; mojo-uuid=1a2bc23bad16f412c35c00f9b881946a; __mta=49747353.1586608791319.1586618086296.1586618566417.10; _lx_utm=utm_source%3DBaidu%26utm_medium%3Dorganic; _lxsdk_s=17169b3dce9-5ef-6b5-ccd%7C%7C28; mojo-trace-id=20; mojo-session-id={"id":"05adcf6f220fcf28a22a52d7640319db","time":1586616327477}',
            'Host':'maoyan.com',

        }
        response = requests.get(url, headers=headers)
    except HTTPError as e:
        print(Fore.RED + '[-] 爬取网页%s失败:%s' %(url, e.reason))
        return None
    else:
        return response.text

def parse_html(html):
    """通过Xpath对html解析获取电影名称、时间、排行、图片等信息"""
    # 1.将传入的文档内容通过lxml解析器进行解析
    html = etree.HTML(html)
    # 2. 通过Xpath语法获取电影的信息
    movies = html.xpath('//dl[@class="board-wrapper"]/dd')

    for movie in movies:
        index = movie.xpath('./i/text()')[0],
        image = movie.xpath('.//img[@class="board-img"]/@data-src')[0]
        title = movie.xpath('.//img[@class="board-img"]/@alt')[0]
        star  = movie.xpath('.//p[@class="star"]/text()')[0]
        releasetime = movie.xpath('.//p[@class="releasetime"]/text()')[0]

        yield {
            'index': index,
            'image': image,
            'title': title,
            'star': star.strip().lstrip('主演：'),
            'releasetime': releasetime.lstrip('上映时间：')
        }


def save_to_json(data, filename):
    """将爬取的数据写入json文件"""
    # with open(filename, 'ab') as f:
    #     f.write(json.dumps(data, ensure_ascii=False, indent=4).encode('utf-8'))
    #     print(Fore.GREEN + '[+] 保存电影 %s 的信息成功' %(data['title']))
    with codecs.open(filename, 'a', 'utf-8') as f:
        f.write(json.dumps(data, ensure_ascii=False, indent=4))
        print(Fore.GREEN + '[+] 保存电影 %s 的信息成功' % (data['title']))

def get_one_page(page=1):
    # url = 'https://maoyan.com/board/'
    url = 'https://maoyan.com/board/4?offset=%s' %((page-1)*10)
    html = down_page(url)
    # print(html)
    items = parse_html(html)
    # print(items)
    # item是字典
    for item in items:
        save_to_json(item, 'maoyanTop100.json')

if __name__ == '__main__':
    for page in range(1,11):
        get_one_page(page)
        print(Fore.GREEN + '[+]采集第%s页数据成功' %(page))
        # 反爬虫策略:防止爬虫速度过快被限速,在采集数据的过程中,休眠一段时间
        time.sleep(0.5)

基于requests和Xpath的TIOBE编程语言排行榜定向爬虫：

import csv
import json
import os
import re
import time
from urllib.error import HTTPError

import requests
from colorama import Fore
from fake_useragent import UserAgent
from lxml import etree


def down_page(url):
    try:
        ua = UserAgent()
        headers = {
            'User-Agent':ua.random,

        }
        response = requests.get(url, headers=headers)
    except HTTPError as e:
        print(Fore.RED + '[-] 爬取网页%s失败:%s' %(url, e.reason))
        return None
    else:
        return response.text

def parse_html(html):
    """通过Xpath对html解析获取编程语言的去年名次,今年名次,编程语言名称,评级Rating和变化率Change等信息"""
    # 1.将传入的文档内容通过lxml解析器进行解析,返回Element信息
    html = etree.HTML(html)
    # 2. 通过Xpath语法获取编程语言相关的信息
    languages = html.xpath('//table[@id="top20"]/tbody/tr')

    for language in languages:
        now_rank = language.xpath('./td[1]/text()')[0]
        last_rank = language.xpath('./td[2]/text()')[0]
        name = language.xpath('./td[4]/text()')[0]
        rating = language.xpath('./td[5]/text()')[0]
        change = language.xpath('./td[6]/text()')[0]

        yield {
            'now_rank': now_rank,
            'last_rank': last_rank,
            'name': name,
            'rating': rating,
            'change': change
        }


def save_to_csv(data, filename):
    """将爬取的数据写入csv文件"""
    # 1). data是yield返回的字典对象
    # 2). 以追加的方式打开文件并写入
    # 3). 文件的编码格式是utf-8
    # 4). 默认csv文件会写入空行, 解决：newkine:''
    with open(filename, 'a', encoding='utf-8', newline='') as f:
        csv_write = csv.DictWriter(f, ['now_rank', 'last_rank', 'name', 'rating', 'change'])
        # 写入csv文件的表头
        # csv_write.writeheader()
        csv_write.writerow(data)

def get_one_page(page=1):
    url = 'https://www.tiobe.com/tiobe-index/'
    html = down_page(url)
    # print(html)
    filename = 'tiobe.csv'
    # print(os.path.dirname(filename))
    items = parse_html(html)
    # print(items)
    # item是字典
    for item in items:
        save_to_csv(item, filename)
    print(Fore.GREEN + '[+] 写入文件%s成功' %(filename))

if __name__ == '__main__':
    get_one_page()

3、BeautifulSoup（BS4）数据解析库

Beautiful Soup就是Python的一个HTML或XML的解析库，可以用它来方便地从网页中提取数据。Beautiful Soup在解析时实际上依赖解析器， 可以选择的解析器如下表所示：

在这里插入图片描述

基本用法

from bs4 import BeautifulSoup
# BeaufulSoup对象的初始化, 并指定html解析器是lxml
soup = BeautifulSoup(html, 'lxml')
# 把要解析的字符串以标准的缩进格式输出
soup.prettify()

# 1. 从bs4模块中导入BeautifulSoup
from bs4 import BeautifulSoup

# 2. 实例化BeautifulSoup对象,并通过指定的解析器解析html字符串的内容
html = """
<h1> BS4 </h1>
"""

soup = BeautifulSoup(html, 'lxml')

# 3. 将要解析的字符串以标准的缩进形式输出
print(soup.prettify())

BeautifulSoup选择器

1、节点选择器

直接调用节点的名称就可以选择节点元素，再调用string属性就可以得到节点内的文本了，这种选择方式速度非常快。如果单个节点结构层次非常清晰，可以选用这种方式来解析。

  1. 选择元素: soup.title, soup.head, soup.p, soup.h1, soup.a.img
  2. 提取信息: soup.title.string, soup.title.class, soup.title.attrs, soup.title.attrs[‘id’]

在这里插入图片描述

html = """
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title class="mytitle">beautifulsoup</title>
</head>
<body>
    <table class="table" id="userinfo">
        <tr>
            <td>姓名</td>
            <td>年龄</td>
        </tr>
        <tr>
            <td>张三</td>
            <td>20</td>
        </tr>
        <tr>
            <td>李四</td>
            <td>22</td>
        </tr>
    </table>
    
    <div>
        <img src="test.html" title="image title" alt="image alt">
    </div>
</body>
</html>
"""

# 1. 从bs4模块中导入BeautifulSoup
from bs4 import BeautifulSoup

# 2. 实例化BeautifulSoup对象,并通过指定的解析器解析html字符串的内容
soup = BeautifulSoup(html, 'lxml')

# 3. 节点选择器
# 3-1. 元素选择：只返回在html里面查询符合条件的第一个标签内容
# print(soup.title)
# print(soup.img)
# print(soup.tr)

# 3-2. 嵌套选择器
# print(soup.body.table.tr.td)
# print(soup.body.table.tr)

# 3-3. 属性选择
# 3-3-1. 获取标签的名称：当爬虫过程中, 标签对象赋值给一个变量传递进函数时,想获取变量对应的标签,name属性就很有用
# print(soup.img.name)

# 3-3-2. 获取标签的属性
# print(soup.table.attrs)
# print(soup.table.attrs['class'])
# print(soup.table['class'])
# print(soup.table['id'])

# 3-3-3. 获取文本内容
# print(soup.title.string)
# print(soup.title.get_text())

# 3-4.  关联选择
# 3-4-1. 父节点和祖父节点
first_tr_tags = soup.table.tr
# print(first_tr_tags.parent) # 父节点
# print(first_tr_tags.parents) # 祖父节点
# parents = first_tr_tags.parents
# for parent in parents:
#     print('*********************')
#     print(parent)

# 3-4-2. 子节点和子孙节点
# table_tags = soup.table
# for children  in table_tags.children:
#     print('*****')
#     print(children)


# 3-4-3. 兄弟节点
# tr_tag = soup.table.tr
# # print(tr_tag)
# print(tr_tag.next_sibling.next_sibling)

2、方法选择器

节点选择器速度非常快，但面对复杂的选择不够灵活。Beautiful Soup提供的查询方法，比如find_all()和find()等实现灵活查询。

  • find_all方法，查询所有符合条件的元素。
        find_all(name , attrs , recursive , text , **kwargs)
        soup.find_all(name=‘ul’)， soup.find_all(attrs={‘id’: ‘list-1’})，
      soup.find_all(class_=‘element’)，
      soup.find_all(text=re.compile(‘link’))
  • find()方法，返回第一个匹配的元素

在这里插入图片描述

import re

from bs4 import BeautifulSoup

html = """
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title class="mytitle">beautifulsoup</title>
</head>
<body>
    <table class="table" id="userinfo">
        <tr class="item-1">
            <td>姓名</td>
            <td>年龄</td>
        </tr>
        <tr class="item-2">
            <td>张三</td>
            <td>20</td>
        </tr>
        <tr class="item-3">
            <td>李四</td>
            <td>22</td>
        </tr>
    </table>

    <div>
        <img src="test.html" title="image title" alt="image alt">
    </div>
</body>
</html>
"""

soup = BeautifulSoup(html, 'lxml')

# print(soup.find_all(name='table'))

# print(soup.find_all('table',attrs={'id':'userinfo'}))
# print(soup.find_all('table', attrs={'class':'table'}))

# print(soup.find_all('table', id='userinfo'))
# print(soup.find_all('table', class_='table'))

# print(soup.find_all('td', text=re.compile('\d{1,2}'), limit=1))
print(soup.find_all('tr', class_=re.compile('item-\d+'), limit=2))

3、CSS选择器

import re

from bs4 import BeautifulSoup

html = """
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<table class="table" id="userinfo">
    <tr class="item-1">
        <td>姓名</td>
        <td>年龄</td>
    </tr>
    <tr class="item-2">
        <td>张三</td>
        <td>10</td>
    </tr>
    <tr class="item-3">
        <td>李四</td>
        <td>20</td>
    </tr>
</table>
<div>
    <img src="download_images" title="image" alt="image alt">
</div>
</body>
</html>
"""
soup = BeautifulSoup(html,'lxml')

# css选择器
print(soup.select('.item-3'))
#
print(soup.select('#userinfo'))

print(soup.select('table tr td'))

项目案例：基于requests和BS4的三国演义名著定向爬虫

  • 爬取的网站：http://www.shicimingju.com/book/
    项目分析：
    1、根据网址http://www.shicimingju.com/book/sanguoyanyi.html获取三国演义主页的章节信息.
    2、分析章节信息的特点， 提取章节的详情页链接和章节的名称。
    <div class=“book-mulu”><ul><li>，li的详情信息如下:
    <li><a href="/book/sanguoyanyi/1.html">第一回·宴桃园豪杰三结义 斩黄巾英雄首立功</a></li>
    3、根据章节的详情页链接访问章节内容

    4、提取到的章节内容包含特殊的标签, eg: <br/> ==> ‘\n’<p>,\ => ‘’
    5、将章节信息存储到文件中 
import os
from requests import HTTPError

import requests
from bs4 import BeautifulSoup
from colorama import Fore
from fake_useragent import UserAgent


def download_page(url, parmas=None):
    """
    根据url地址下载html页面
    :param url:
    :param parmas:
    :return: str
    """
    try:
        ua = UserAgent()
        headers = {
            'User-Agent': ua.random,
        }
        # 请求https协议的时候， 回遇到报错: SSLError
        # verify=Flase不验证证书
        response = requests.get(url, params=parmas, headers=headers)
    except  HTTPError as e:
        print(Fore.RED + '[-] 爬取网站%s失败: %s' % (url, str(e)))
        return None
    else:
        # content返回的是bytes类型, text返回字符串类型
        return response.text

def parse_html(html):
    # 实例化BeautifulSoup对象,并通过指定的解析器解析html字符串的内容
    soup = BeautifulSoup(html, 'lxml')
    # 根据bs4的选择器获取章节的详情页链接和章节名称
    book = soup.find('div', class_='book-mulu') # 获取该书籍对象
    chapters = book.find_all('li')  # 获取该数据所有的章节对应的li标签,返回的是列表
    # 依次遍历每一个章节
    for chapter in chapters:
        detail_url = chapter.a['href']
        # print(detail_url)
        chapter_name = chapter.a.string
        # print(chapter_name)
        yield {
            'detail_url':detail_url,
            'chapter_name':chapter_name
        }


def parse_detail_html(html):
    # 实例化BeautifulSoup对象,并通过指定的解析器解析html字符串的内容
    soup = BeautifulSoup(html, 'lxml')
    # chapter_content = soup.find('div', class_='chapter_content')
    # 根据章节的详情页链接访问章节内容,string只拿出当前标签的文本信息,get_text()返回当前标签和子孙标签的所有文本信息
    chapter_content = soup.find('div', class_='chapter_content').get_text()
    # print(chapter_content)
    return chapter_content.replace(' ', '')



def get_one_page():
    base_url = 'http://www.shicimingju.com'
    url = 'http://www.shicimingju.com/book/sanguoyanyi.html'
    dirname = '三国演义'
    if not os.path.exists(dirname):
        os.mkdir(dirname)
        print(Fore.GREEN + "创建书籍目录%s成功" %(dirname))

    html = download_page(url)
    items = parse_html(html)
    for item in items:
        # 访问详情页链接
        detail_url = base_url + item['detail_url']
        # 生成文件存储路径
        chapter_name = os.path.join(dirname, item["chapter_name"] + '.txt')
        chapter_html = download_page(detail_url)
        chapter_content = parse_detail_html(chapter_html)

        # 写入文件
        with open(chapter_name, 'w', encoding='utf-8') as f:
            f.write(chapter_content)
            print(Fore.GREEN + '写入文件%s成功' %(chapter_name))



if __name__ == '__main__':
    get_one_page()
CodingAndCoCoding
关注
专栏目录
Python爬虫数据解析：正则表达式解析；xpath解析数据；BeautifulSoup（bs4）解析
02-16 1062
爬虫爬取到的数据一般要进行解析，常用解析数据的方法一般有以下几种： 正则表达式解析 xpath解析 BeautifulSoup解析 其它不常用的不再介绍 1、正则表达式解析 2、xpath解析 3、BeautifulSoup解析 ...
python爬虫-----网络数据分析_正则表达式，xpath库，BeautifulSoup库
weixin_44568633的博客
04-23 1388
文章目录python爬虫-----网络数据分析一、正则表达式1.为什么要学正则表达式2.什么是正则表达式3.re 模块一般使用步骤Pattern 对象正则表达式实现步骤4.正则split和sub5.常用的正则常量项目案例：基于requests和正则 的猫眼电影TOP100定向爬虫报错二、xpath库1.XPath如何实现文档解析?2.xpath用法项目案例：基于requerts和Xpath的猫眼电...
爬虫数据解析的三方式
蜗牛在奔跑的博客
04-02 1096
2、爬虫数据解析的三方式 一.正则表达式解析 常用正则表达式回顾： 单字符： . : 除换行以外所有字符 [] ：[aoe] [a-w] 匹配集合中任意一个字符 \d ：数字 [0-9] \D : 非数字 \w ：数字、字母、下划线、中文 \W : 非\w \s ：所有的空白字符包,括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。 \S : 非空白
Xpath详解
最新发布
weixin_51231433的博客
09-22 1022
XPath 的选择功能十分强大，它提供了非常简洁明了的路径选择表达式。另外，它还提供超过 100 个内置函数，用于字符串、数值、时间的匹配以及节点、序列的处理等，几乎所有想要定位的节点都可以用 XPath 来选取。。
爬虫中的xpath解析
weixin_59285003的博客
02-07 184
xpath解析 from lxml import etree xpath解析原理 实例化一个etree对象，且需要将被解析的页面源码数据加载到该对象中 调用etree对象中的xpath方法结合xpath表达式实现标签定位和内容的捕获 与BeautifulSoup极为相像 环境的安装 pip install lxml 如何实例化一个etree对象 将本地的html文档中的源码数据加载到etree对象中： etree.parse(filePath) 可
一起来学习XPATH，来看看除了正则表达式我们还能怎么抓取数据
weixin_30538029的博客
08-27 157
参考学习的网站链接http://www.w3school.com.cn/xpath/xpath_intro.asp 首先理清楚一些常识 以此为例 <?xml version="1.0" encoding="ISO-8859-1"?> <bookstore> <book> <title lang="en">Harry Potte...
数据解析之正则表达式
Xi_You_Zi的博客
01-31 528
目录数据解析数据解析分类数据解析原理正则解析实战练习 数据解析 数据解析分类 正则表达式 bs4 xpath 数据解析原理 想要获取的局部的内容存储在标签之间或这标签对应的属性中：1、进行标签定位；2、对标签之间或标签属性中存储的数据值进行提取 正则解析 正则表达式概念 在线测试工具：regex101.com / regexr-cn.com 正则练习：codejiaomang.com 1、限定符 ？ 前面的字符出现0次或1次 * ≥0次 + ≥1次 {m} 出现m次 {m,} ≥m次 {m,n} 出现
03爬虫基础知识-数据解析
10-24
1. BeautifulSoup：提供了一种直观的方式来导航、搜索和修改解析树，适用于初学者。 2. PyQuery：其API设计模仿了jQuery，对于熟悉前端开发的人来说，学习曲线较平缓。 三、XML解析 XML（Extensible Markup ...
爬虫技术-Xpath解析数据.pptx
01-01
在解析内容时，有多种方式可以选择，如正则表达式、DOM解析、BeautifulSoup等。但Xpath因其简洁和强大的功能，成为了常用的选择。Xpath允许我们通过路径表达式来选取文档中的节点或节点集合，类似于文件系统中的路径...
爬虫常用数据提取方式:正则、xpath、beautifulsoup
weixin_41391619的博客
12-19 1096
爬虫常用数据提取方式:正则、xpath、beautifulsoup
爬虫之网页解析——正则表达式、BeautifulSoup、xpath
l_u_h_a_i的博客
06-21 904
解析内容 得到的内容可能是HTML,可以用正则表达式，页面解析库进行解析，可能是Json,可以直接转换为Json对象解析，可能是二进制数据，可以做保存或者进一步的处理。 正则表达式处理 def get_zhushi_info(url): #urls='https://so.gushiwen.org/shiwen2017/ajaxshiwencont.aspx?id=45c396367...
Python爬虫实战（三种数据解析方式及对比总结）
阿柯柯的博客
03-27 2325
爬取网页指定页码的图片 import requests import re import os url = 'https://www.qiushibaike.com/pic/%s/' headers={ 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Ge...
爬虫基础（笔记）——2.正则表达式、Xpath与BeautifulSoup
xuepydexiaocaiji的博客
05-28 903
#爬取51job求职网 保存到数据库 import urllib.request from bs4 import BeautifulSoup import time import pymysql # 根据url生成请求对象 def handle_request(url): headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Geck.
Python爬虫的三种数据解析方式
人生苦短， 还不用Python？
07-06 1795
数据解析方式　　 　　- 正则 　　- xpath 　　- bs4 数据解析的原理： 标签的定位 提取标签中存储的文本数据或者标签属性中存储的数据 正则 # 正则表达式 单字符： . : 除换行以外所有字符 [] ：[aoe] [a-w] 匹配集合中任意一个字符 \d ：数字 [0-9] \D : 非数字 ...
爬虫实操1-静态网页-3个解析方式比较
qq_43165880的博客
05-16 7542
以天涯论坛的简单网页爬取为例子，BeautifulSoup、PyQuery以及Xpath都使用一下。 1. 网页访问 使用requests库访问 import requests url='http://bbs.tianya.cn/hotArticle.jsp?pn=1' #天涯论坛 req=requests.get(url) req 输出：<Response [200]> 表示能够成功访问 展示下网页源代码： print(req.text) 2. 确定想要抓取的内容 打开开发者工具，
爬虫学习-数据解析三种方式：正则、bs4、xpath，以及一些实例操作
qq_61897309的博客
12-21 949
【代码】爬虫学习-数据解析三种方式：正则、bs4、xpath，以及一些实例操作。
正则表达式
LGQHH的博客
03-11 263
用于定义一些字符串的规则，极端及可以根据正则表达式，来检查一个字符串是否符合规则，获取将字符串中符合规则的内容提取出来 创建正则表达式的对象 1.使用构建函数来创建正则表达式 var 变量 = new RegExp("正则表达式","匹配模式"); -在构造函数中可以传递一个匹配模式作为第二个参数（也可以不传） ...
python 爬虫：正则表达式 re 与网页解析包 Beautifulsoup
天天向上的专栏
08-12 913
断断续续接触 python 爬虫一年多，确实挺有趣的。对于很多常规的网页抓取，发现技术难度也不是特别高。准备将一些使用心得，总结写一下，供以后自己查阅以及知识传播。 由于网页（html）类似于 txt 一样的文本文档，因此爬虫其实就是从网页里找到想要的文本信息，爬虫的实质就是解析网页。 解析网页一般有三种方式： 利用 python 的一些字符串处理函数，例如：split， partition 等 利用正则表达式 利用 Beautifulsoup 包 ...
Xpath解析
09-06 230
import requests from lxml import etree url = 'https://www.huawei.com/cn/?ic_medium=direct&ic_source=surlent' response = requests.get(url = url) ht = response.text tree = etree.HTML(ht) #也可以解...
爬虫BeautifulSoup 正则表达式 xpath 新手推荐哪个
05-30
对于新手来说，建议先从BeautifulSoup入手，因为它的语法简单易学，支持CSS选择器和正则表达式等多种方式提取数据，能够处理不规范的HTML代码，适合初学者进行HTML解析和数据提取。 正则表达式是一种灵活和强大的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值