8.网络爬虫—正则表达式RE实战

Posted 2023-04-01 以山河作礼。

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了8.网络爬虫—正则表达式RE实战相关的知识，希望对你有一定的参考价值。

8.网络爬虫—正则表达式RE实战

前言：
🏘️🏘️个人简介：以山河作礼。
🎖️🎖️:Python领域新星创作者，CSDN实力新星认证
📝📝此专栏文章是专门针对网络爬虫基础，欢迎免费订阅！
📝📝第一篇文章《1.认识网络爬虫》获得全站热榜第一，python领域热榜第一，第四篇文章《4.网络爬虫—Post请求(实战演示)》全站热榜第八，欢迎阅读！
🎈🎈欢迎大家一起学习，一起成长！！
💕💕悲索之人烈焰加身，堕落者不可饶恕。永恒燃烧的羽翼，带我脱离凡间的沉沦。

正则表达式（Regular Expression）

正则表达式（Regular Expression）是一种用于匹配字符串的工具，它可以根据特定的规则来匹配字符串。正则表达式通常由一组字符和字符集合组成，其中字符集合定义了匹配的字符类型和位置。

re.I

🧾 🧾 语法： re.IGNORECASE 或简写为 re.I

🧾 🧾 含义： 进行忽略大小写匹配。

在Python中，可以使用re模块中的re.IGNORECASE标志来实现正则表达式的忽略大小写。例如，如果要匹配字符串apple，可以使用以下代码：

import re  
  
pattern = re.compile('apple', re.I)  
text = 'The apple is red'  
  
match = pattern.search(text)  
  
if match:  
    print(match.group())  
else:  
    print('未找到匹配的字符串')

运行结果：

在上面的代码中，re.I标志被用来匹配字符串apple，这意味着在匹配时忽略大小写。pattern.search(text) 函数返回一个Match对象，如果找到匹配的字符串，则match.group()方法将被调用并打印出来，否则打印出未找到匹配的字符串。

re.A

🧾 🧾 语法： re.ASCII 或简写为 re.A

🧾 🧾 作用： ASCII表示ASCII码的意思，让 \\w, \\W, \\b, \\B, \\d, \\D, \\s 和 \\S 只匹配ASCII，而不是Unicode。

当使用re模块进行正则表达式匹配时，可以使用re.ASCII或re.A标志来匹配ASCII字符集，而不是Unicode字符集。这意味着，\\w、\\W、\\b、\\B、\\d、\\D、\\s和\\S只会匹配ASCII字符，而不是Unicode字符。

以下是一个使用re.ASCII或re.A标志的简单示例：

import re

# 匹配ASCII字符集中的数字和字母
pattern = re.compile(r'\\w+', flags=re.ASCII)
text = 'Hello 世界 123'
match = pattern.findall(text)
print(match)

在上面的示例中，我们使用re.compile()函数创建了一个正则表达式对象，该对象使用了re.ASCII标志。然后，我们使用该对象的findall()方法在文本中查找匹配项。由于我们使用了re.ASCII标志，所以只有ASCII字符集中的数字和字母被匹配到，而中文字符被忽略。因此，输出结果为[‘Hello’,
‘123’]，而不包括’世界’这个中文字符。

re.S

🧾🧾 语法： re.DOTALL 或简写为 re.S

🧾🧾 作用： DOT表示.，ALL表示所有，连起来就是.匹配所有，包括换行符\\n。默认模式下.是不能匹配行符\\n的。

re.DOTALL或简写为re.S是re模块的一个标志，用于指定正则表达式匹配时，".“符号是否能够匹配换行符。当re.DOTALL或re.S标志被设置时，”.“符号将匹配任何字符，包括换行符。如果没有设置这个标志，”."符号将不匹配换行符。

以下是一个使用re.DOTALL标志的示例：

import re

text = 'hello\\nworld'
pattern = re.compile('.*', re.DOTALL)
match = pattern.match(text)
print(match.group(0))

运行结果：

'hello\\nworld'

可以看到，因为使用了re.DOTALL标志，"."符号匹配了换行符，所以整个文本都被匹配了。

需要注意的是，re.DOTALL标志只对"."符号起作用，其他的元字符和字符类仍然按照原来的规则匹配。
如果需要匹配包括换行符在内的所有字符，可以使用如下的正则表达式：

pattern = re.compile('.*', re.DOTALL | re.MULTILINE)

这里使用了re.MULTILINE标志，表示多行匹配，以便"."符号能够匹配换行符。

re.M

🧾 🧾 语法： re.MULTILINE 或简写为 re.M

🧾 🧾 含义： 多行模式，当某字符串中有换行符\\n，默认模式下是不支持换行符特性的，比如：行开头和行结尾，而多行模式下是支持匹配行开头的。

在Python中，可以使用re模块中的re.MULTILINE标志来实现正则表达式的多行匹配。

例如，如果要匹配字符串apple，可以使用以下代码：


import re

pattern = re.compile('apple', re.MULTILINE)
text = 'The apple is red'

match = pattern.search(text)

if match:
    print(match.group())
else:
    print('未找到匹配的字符串')

运行结果：

在上面的代码中，re.MULTILINE标志被用来匹配字符串apple，这意味着可以在一行中匹配多个字符串。pattern.search(text)函数返回一个Match对象，如果找到匹配的字符串，则match.group()方法将被调用并打印出来，否则打印出未找到匹配的字符串。

注意：正则语法中^匹配行开头、\\A匹配字符串开头，单行模式下它两效果一致，多行模式下\\A不能识别\\n。

re.X

🧾 🧾 语法： re.VERBOSE 或简写为 re.X

🧾 🧾 作用： 详细模式，可以在正则表达式中加注解！

re.VERBOSE 或简写为 re.X 是 re.compile()函数中的一个可选参数，用于在正则表达式中添加注释。它允许在正则表达式中使用空格、换行符和注释，从而使正则表达式更易于阅读和理解。

例如：

import re

# 匹配电子邮件地址
pattern = re.compile(r'''
    ^                   # 匹配字符串开头
    [\\w\\.\\+\\-]+         # 用户名，可以包含字母、数字、点、加号和减号
    @                   # @ 符号
    [\\w\\.\\-]+           # 域名，可以包含字母、数字、点和减号
    \\.                  # . 符号
    [a-zA-Z]2,4       # 域名后缀，可以是 2 到 4 个字母
    $                   # 匹配字符串结尾
''', re.VERBOSE)

# 测试正则表达式
print(pattern.match('john.doe+test@example.com'))

输出：

<re.Match object; span=(0, 27), match='john.doe+test@example.com'>

re.L

🧾 🧾 语法： re.LOCALE 或简写为 re.L

🧾 🧾 作用： 由当前语言区域决定 \\w, \\W, \\b, \\B 和大小写敏感匹配，这个标记只能对byte样式有效，该标记官方已经不推荐使用，因为语言区域机制很不可靠，它一次只能处理一个 "习惯”，而且只对8位字节有效。

re.LOCALE 或简写为 re.L 是 re.compile()函数中的一个可选参数，用于启用本地化匹配。它会根据当前系统的本地化设置，对正则表达式中的某些字符类别（如\\w、\\W、\\b、\\B）进行本地化处理，从而匹配更广泛的字符集

使用 re.LOCALE 可能会影响正则表达式的行为，因为它取决于系统的本地化设置。因此，如果需要编写可移植的正则表达式，最好不要使用 re.LOCALE。

以下是一个使用 re.LOCALE 的示例：

import re

# 匹配非字母数字字符
pattern = re.compile(r'\\W+', re.LOCALE)

# 测试正则表达式
print(pattern.findall('Hello, 你好！'))

输出：

[',', '！']

re.U

🧾 🧾 语法： re.UNICODE 或简写为 re.U

🧾 🧾 作用： 与 ASCII常量类似，匹配unicode编码支持的字符，但是Python3默认字符串已经是Unicode，所以显得有点多余。

re.UNICODE 或简写为 re.U 是 re.compile() 函数中的一个可选参数，用于启用 Unicode
匹配模式。它会将正则表达式中的某些字符类别（如 \\w、\\W、\\b、\\B）扩展到 Unicode 字符集，从而匹配更广泛的字符集。

在 Python 3 中，默认情况下所有正则表达式都启用了 Unicode 匹配模式，所以在大多数情况下不需要使用 re.UNICODE。

以下是一个使用 re.UNICODE 的示例：

import re

# 匹配非字母数字字符
pattern = re.compile(r'\\W+', re.UNICODE)

# 测试正则表达式
print(pattern.findall('Hello, 你好！'))

输出：

[',', '！']

🧾 🧾 理论讲解完毕，结合之前学到的知识和新学到的知识来实战吧！🧾 🧾 ！

美某杰实战

1️⃣本次实战目的是使用正则表达式获取红色方框里面的内容并写到csv文档里面。

2️⃣首先我们应该先检查数据是否在链接里面，然后如果在，我们通过链接获取前三页的数据。

3️⃣确认数据在链接中，复制链接，开始敲代码！！！

import requests
headers = 
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (Khtml, like Gecko) Chrome/109.0.0.0 Safari/537.36',

for i in range(1, 4):
    url = f'https://www.meishij.net/chufang/diy/jiangchangcaipu/?&page=i'

    html = requests.get(url, headers=headers)


    print(html.text)

运行结果：

4️⃣ok，我们可以看见，我们的数据在代码里面，接下来，我们来使用正则表达式来提取数据！！如果还有不会的朋友，可以阅读我之前写的文章。《3.网络爬虫——Requests模块get请求与实战》

5️⃣通过观察元素，我们发现，我们需要的数据在这里面，我们开始找规律，好方便用正则表达式来把数据提取出来！

6️⃣我们来多看几组数据，好发现规律！

7️⃣ 通过观察我们发现，数据都在这里面，请看代码：


<div class="c1"><strong>蛤蜊酿虾滑</strong><span>0 评论  0 人气</span><em>朴朴超市</em></div>
						<div class="c2"><ul><li class="li1">4步 / 大概30分钟</li><li class="li2">蒸 / 咸鲜味</li></ul></div>	

<div class="c1"><strong>洋葱焖鸡</strong><span>0 评论  2 人气</span><em>东古美食厨房</em></div>
						<div class="c2"><ul><li class="li1">5步 / 大概15分钟</li><li class="li2">焖 / 家常味</li></ul></div>

<div class="c1"><strong>蒜蓉粉丝蒸鲍鱼</strong><span>0 评论  1 人气</span><em>靓杰</em></div>
						<div class="c2"><ul><li class="li1">11步 / 大概60分钟</li><li class="li2">蒸 / 家常味</li></ul></div>

8️⃣这个时候，我们发现代码有空格和换行怎么办？

9️⃣我们会用到之前讲的\\s*来让数据在一行，而不影响正则表达式的使用。

\\s*的作用是匹配零个或多个空格字符（包括空格、制表符、换行符等）。它常用于正则表达式中，用于匹配任意数量的空格字符。

🔟使用正则表达式来获取数据

'<div class="c1"><strong>(\\w+)</strong><span>(.*?)</span><em>(.*?)</em></div>\\s*<div class="c2"><ul><li class="li1">(.*?)</li><li class="li2">(.*?)</li></ul></div>',

\\w+ 的作用是匹配一个或多个字母、数字或下划线字符。其中，\\w 表示匹配任意一个字母、数字或下划线字符，+
表示匹配前面的元素一次或多次。该正则表达式通常用于匹配单词、变量名等含有字母、数字、下划线的字符串。

“.*?” 表示非贪心算法，表示要精确的配对。

作用是匹配任意数量的任意字符，但是会尽可能少地匹配，直到下一个匹配字符出现

“.*”表示贪心算法，表示要尽可能多的匹配

“.”表示匹配任意数量的任意字符，包括空格、制表符、换行符等，且是贪心算法，即尽可能多地匹配字符。这意味着它会匹配尽可能多的字符，直到无法匹配为止。
例如，对于字符串 “abc123def456”，使用正则表达式
“.\\d+”，会匹配整个字符串，因为它会尽可能多地匹配字符，直到遇到数字为止。

1️⃣1️⃣完整代码如下：

import re
import requests

headers = 
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36',



def main(index):
    url = f'https://www.meishij.net/chufang/diy/jiangchangcaipu/?&page=index'

    html = requests.get(url, headers=headers)

    data = re.findall(
        '<div class="c1"><strong>(\\w+)</strong><span>(.*?)</span><em>(.*?)</em></div>\\s*<div class="c2"><ul><li class="li1">(.*?)</li><li class="li2">(.*?)</li></ul></div>',
        html.text)

    for i in data:
        print(i)


for i in range(1, 4):
    main(i)

运行结果：

写入csv文件：

先导入：

f = open('data.csv', 'w+', encoding='gbk', newline='')
csv_f = csv.writer(f)
csv_f.writerow(['菜名', '信息', '作者', '大概步骤', '类型'])

作用是打开一个名为 data.csv 的文件（如果不存在则创建），并使用 gbk 编码方式进行读写操作，同时设置换行符为
‘\\n’。然后创建一个 csv.writer 对象 csv_f，用于将数据写入到文件中。接下来，使用 csv_f.writerow()
方法将包含列名的一行写入到文件中，该行包含了菜名、信息、作者、大概步骤和类型这五个列的名称。这样，文件 data.csv
就具有了一个表格的结构，可以用于存储和处理数据。

然后把这个代码写进去，就得到一个完整的代码：

import csv
import re
import requests

headers = 
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36',


f = open('data.csv', 'w+', encoding='gbk', newline='')
csv_f = csv.writer(f)
csv_f.writerow(['菜名', '信息', '作者', '大概步骤', '类型'])


def main(index):
    url = f'https://www.meishij.net/chufang/diy/jiangchangcaipu/?&page=index'

    html = requests.get(url, headers=headers)
    # print(html.text)

    data = re.findall(
        '<div class="c1"><strong>(\\w+)</strong><span>(.*?)</span><em>(.*?)</em></div>\\s*<div class="c2"><ul><li class="li1">(.*?)</li><li class="li2">(.*?)</li></ul></div>',
        html.text)
    # print(data)
    for i in data:
        csv_f.writerow(i)
        print(i)


for i in range(1, 4):
    main(i)

f.close()

我们来查看一下csv文件：

🍁 🍁今日学习笔记到此结束，是不是很简单。再次感谢你的阅读，如有疑问或者问题欢迎私信，我会帮忙解决，如果没有回，那我就是在教室上课，抱歉。
🍂🍂🍂🍂

7.网络爬虫—正则表达式详讲

7.网络爬虫—正则表达式详讲与实战

Python 正则表达式

前言： 📝📝此专栏文章是专门针对网络爬虫基础，欢迎免费订阅！
📝📝第一篇文章《1.认识网络爬虫》获得全站热榜第一，python领域热榜第一，第四篇文章《4.网络爬虫—Post请求(实战演示)》全站热榜第八，欢迎阅读！
🎈🎈欢迎大家一起学习，一起成长！！
💕💕悲索之人烈焰加身，堕落者不可饶恕。永恒燃烧的羽翼，带我脱离凡间的沉沦。

Python 正则表达式

Python 正则表达式是一种用于匹配、搜索、替换文本中模式的工具。它使用特定的语法来描述一些规则，这些规则可以用于匹配文本中的某些模式。通过使用正则表达式，可以快速地搜索和处理大量的文本数据，从而节省时间和精力。

在 Python 中，正则表达式可以通过 re 模块进行操作。

Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。

re 模块使 Python 语言拥有全部的正则表达式功能。
compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。
re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。

re.match() 函数

re.match() 函数是 Python中用于匹配字符串开头的函数。该函数尝试从字符串的开头开始匹配一个正则表达式模式，如果匹配成功，则返回一个匹配对象，否则返回 None。

re.match(pattern, string, flags=0)

参数说明：

pattern：正则表达式模式。
string：要匹配的字符串。
flags：可选参数，用于控制正则表达式的匹配方式。
匹配成功 re.match 方法返回一个匹配的对象，否则返回 None。

示例代码：

import re

# 匹配一个以 hello 开头的字符串
pattern = r'hello'
string = 'hello world'
match_obj = re.match(pattern, string)
if match_obj:
    print('匹配成功')
else:
    print('匹配失败')

输出结果为：

我们可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式。

参数说明：

span() 起始位置

group()返回获取参数。

代码展示：

import re
print(re.match('www', 'www.baidu.com').span())  # 在起始位置匹配  (0, 3)
print(re.match('com', 'www.baidu.com'))         # 不在起始位置匹配  None

运行结果：

re.search方法

re.search方法是Python中re模块的一个函数，用于在字符串中搜索匹配正则表达式的第一个位置，并返回一个包含匹配信息的Match对象。如果没有匹配到，则返回None。
该方法的语法如下：

re.search(pattern, string, flags=0)

其中，pattern为正则表达式，string为要搜索的字符串，flags为可选的标志，用于控制正则表达式的行为。

以下是一个简单的示例，演示如何使用re.search方法：

import re

# 定义一个正则表达式
pattern = r'hello'

# 定义一个字符串
string = 'hello, world!'

# 在字符串中搜索匹配项
match_obj = re.search(pattern, string)

if match_obj:
    print('匹配成功！')
else:
    print('匹配失败！')

输出结果为：

匹配成功！

在这个示例中，我们定义了一个正则表达式模式"hello"，然后在字符串"hello,world!“中搜索匹配项。由于该字符串包含"hello”，因此re.search方法返回了一个匹配对象。最后，我们检查匹配对象是否存在，以确定匹配是否成功。

re.match与re.search的区别

re.match和re.search都是Python中re模块中的函数，它们的主要区别在于匹配的位置不同。

re.match只会从字符串的开头开始匹配，如果在开头没有匹配到，则返回None。而re.search则会搜索整个字符串，只要找到第一个匹配项，就会返回一个匹配对象。

以下是一个简单的示例，演示re.match和re.search的区别：

import re

# 定义一个正则表达式
pattern = r'hello'

# 定义一个字符串
string = 'hello, world!'

# 使用re.match进行匹配
match_obj = re.match(pattern, string)

if match_obj:
    print('re.match匹配成功！')
else:
    print('re.match匹配失败！')

# 使用re.search进行匹配
match_obj = re.search(pattern, string)

if match_obj:
    print('re.search匹配成功！')
else:
    print('re.search匹配失败！')

输出结果为：

re.match匹配成功！
re.search匹配成功！

在这个示例中，我们定义了一个正则表达式模式"hello"，然后在字符串"hello,
world!“中使用re.match和re.search进行匹配。由于"hello"出现在字符串的开头，因此re.match和re.search都返回了一个匹配对象，表示匹配成功。但是，如果我们将字符串改为"world,
hello!”，则re.match将返回None，因为"hello"不在字符串的开头。

re.compile 函数

在Python中，re.compile()函数是用于将正则表达式编译成一个正则表达式对象的函数。编译后的正则表达式对象可以被多次使用，可以提高程序的效率。

re.compile()函数的语法如下：

re.compile(pattern, flags=0)

参数说明：

pattern：要编译的正则表达式
flags：可选参数，用于指定匹配模式，具体参数参考re模块的文档

示例代码：

import re

# 编译正则表达式
pattern = re.compile(r'\\d+')
str = 'hello 123 world 456'

# 使用正则表达式对象进行匹配
result = pattern.findall(str)
print(result)

输出结果：

['123', '456']

上面的代码中，我们先使用re.compile()函数将正则表达式编译成一个正则表达式对象，然后使用该对象的findall()方法进行匹配。这样可以提高程序的效率，特别是在需要多次使用同一个正则表达式时。

检索和替换

Python中可以使用re模块来进行正则表达式的检索和替换。

re.sub(pattern, repl, string, count=0, flags=0)

参数：

pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

检索：

使用re.search()函数可以在字符串中查找匹配某个正则表达式的子串，返回一个match对象。

示例代码：

import re

str = "The quick brown fox jumps over the lazy dog."
match = re.search(r'fox', str)

if match:
  print("找到了：", match.group())
else:
  print("没找到")

输出结果：

找到了： fox

替换：

使用re.sub()函数可以将字符串中匹配某个正则表达式的子串替换成指定的字符串。

示例代码：

import re

str = "The quick brown fox jumps over the lazy dog."
new_str = re.sub(r'fox', 'cat', str)

print("替换前：", str)
print("替换后：", new_str)

输出结果：

替换前： The quick brown fox jumps over the lazy dog.
替换后： The quick brown cat jumps over the lazy dog.

findall

findall 是 Python 中 re 模块提供的一个函数，用于在字符串中找到所有匹配正则表达式的子串，并返回一个列表。

它的语法如下：

re.findall(pattern, string, flags=0)

其中，pattern 是正则表达式，string 是要匹配的字符串，flags 是可选的标志参数。
findall 函数返回一个包含所有匹配子串的列表，如果没有匹配到任何子串，则返回一个空列表。

示例代码：

import re

pattern = re.compile(r'(\\d+) (\\d+)')  # 查找数字 有助于一个表达式在不同的情况下测试
result1 = pattern.findall('123 abc 456')
result2 = pattern.findall('123 456   abc  456 789')
print(result1)
print(result2)

输出结果：

re.finditer

re.finditer 是 Python 中 re 模块提供的一个函数，用于在字符串中找到所有匹配正则表达式的子串，并返回一个迭代器。

它的语法如下：

re.finditer(pattern, string, flags=0)

其中，pattern 是正则表达式，string 是要匹配的字符串，flags 是可选的标志参数。
finditer 函数返回一个迭代器，可以迭代得到所有匹配子串的 MatchObject
对象。如果没有匹配到任何子串，则返回一个空迭代器。
与 findall 不同的是，finditer
返回的是迭代器，可以逐个获取匹配的结果，而不是一次性获取全部结果。这在匹配大量文本时可以节省内存。

re.split

re.split 是 Python 中 re 模块提供的一个函数，用于按照正则表达式指定的模式分割字符串，并返回一个列表。

它的语法如下：

re.split(pattern, string, maxsplit=0, flags=0)

其中，pattern 是正则表达式，string 是要分割的字符串，maxsplit 是指定最大分割次数，flags
是可选的标志参数。
split 函数返回一个列表，包含所有分割后的子串。如果没有匹配到任何子串，则返回一个包含原字符串的列表。
与 Python 内置的 split 函数不同的是，re.split
可以按照正则表达式指定的模式进行分割，例如按照空格、逗号、分号等进行分割，而不仅仅是按照固定的字符进行分割。同时，re.split还支持指定最大分割次数，以控制分割的结果。

正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式：

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
多数字母和数字前加一个反斜杠时会拥有不同的含义。
标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
反斜杠本身需要使用反斜杠转义。
由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r’\\t’，等价于 ‘\\t’)匹配相应的特殊字符。
下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。

常见的字符类正则模式

字符类正则模式用于匹配一组特定的字符。以下是常见的字符类正则模式：

1. [abc]：匹配字符 a、b 或 c 中的任意一个。
2. [^abc]：匹配除了字符 a、b 和 c 以外的任意字符。
3. [a-z]：匹配任意小写字母。
4. [A-Z]：匹配任意大写字母。
5. [0-9]：匹配任意数字。
6. [a-zA-Z]：匹配任意字母。
7. [a-zA-Z0-9]：匹配任意字母或数字。
8. [\\s]：匹配任意空白字符，包括空格、制表符、换行符等。
9. [\\S]：匹配任意非空白字符。
10. [\\d]：匹配任意数字，等同于 [0-9]。
11. [\\D]：匹配任意非数字字符。
12. [\\w]：匹配任意字母、数字或下划线字符。
13. [\\W]：匹配任意非字母、数字或下划线字符。

正则表达式模式量词

正则表达式模式量词用于表示匹配次数，常用的量词包括：

1. *：匹配前面的模式零次或多次，等效于0,；
2. +：匹配前面的模式一次或多次，等效于1,；
3. ?：匹配前面的模式零次或一次，等效于0,1；
4. n：匹配前面的模式恰好n次；
5. n,：匹配前面的模式至少n次；
6. n,m：匹配前面的模式至少n次，但不超过m次。

例如，正则表达式模式\\d3,5表示匹配3到5个数字，正则表达式模式a+b*表示匹配一个或多个a，后面跟零个或多个b。

正则表达式举例

1. 匹配邮箱地址的模式：^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$
2. 匹配手机号码的模式：^1[3456789]\\d9$
3. 匹配身份证号码的模式：^\\d17[\\dXx]|\\d15$
4. 匹配IP地址的模式：^((\\d1,2|1\\d2|2[0-4]\\d|25[0-5])\\.)3(\\d1,2|1\\d2|2[0-4]\\d|25[0-5])$
5. 匹配URL地址的模式：^[a-zA-Z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$
6. 匹配汉字的模式：^[\\u4e00-\\u9fa5]0,$
7. 匹配中文和英文的模式：^[\\u4e00-\\u9fa5a-zA-Z]+$
8. 匹配邮政编码的模式：^[1-9]\\d5$
9. 匹配日期的模式：^\\d4-\\d1,2-\\d1,2$
10. 匹配时间的模式：^(0?\\d|1\\d|2[0-3]):[0-5]\\d(:[0-5]\\d)?$

🍁 🍁今日学习笔记到此结束，感谢你的阅读，如有疑问或者问题欢迎私信，我会帮忙解决，如果没有回，那我就是在教室上课，抱歉。
🍂🍂🍂🍂

以上是关于8.网络爬虫—正则表达式RE实战的主要内容，如果未能解决你的问题，请参考以下文章

网络爬虫-课程大纲

python网络爬虫与信息提取——6.Re（正则表达式）库入门

网络爬虫 | 正则表达式

常用正则表达式最强汇总（含Python代码举例讲解+爬虫实战）

Python3 爬虫09_正则表达式（re.math()re.search()re.sub()全局匹配函数）

〖Python网络爬虫实战⑨〗- 正则表达式基本原理