# 📚 正则表达式：爬虫内容提取利器

---

# 目录

1. [先导知识：为什么需要正则表达式？](#1-先导知识为什么需要正则表达式)
2. [正则表达式快速入门](#2-正则表达式快速入门)
3. [Python re 模块详解](#3-python-re-模块详解)
4. [贪婪 vs 非贪婪匹配](#4-贪婪-vs-非贪婪匹配)
5. [分组与捕获](#5-分组与捕获)
6. [实战：爬虫中的正则表达式](#6-实战爬虫中的正则表达式)
7. [BeautifulSoup + 正则表达式：黄金组合](#7-beautifulsoup--正则表达式黄金组合)
8. [正则表达式 vs XPath：两种提取方式对比](#8-正则表达式-vs-xpath两种提取方式对比)
9. [常见问题与解决方案](#9-常见问题与解决方案)
10. [动手练习](#10-动手练习)

---

# 1. 先导知识：为什么需要正则表达式？

## 1.1 回顾：BeautifulSoup 的局限

上节课我们学习了 BeautifulSoup，它可以方便地通过 CSS 选择器提取 HTML 内容。但它有一个前提：**网页内容必须是标准的 HTML 结构**。

```python
# BeautifulSoup 适合这种结构清晰的 HTML
<div class="movie">
    <span class="title">流浪地球</span>
    <span class="score">8.5</span>
</div>

soup.select('.movie .title')  # ✅ 完美提取
```

**但是**，有时候我们需要的内容并不在标准的 HTML 标签里：

```html
<!-- 电影评分在属性值里 -->
<a href="/movie/1" data-title="流浪地球" data-score="8.5">流浪地球</a>

<!-- 或者是这种混在一起的文本 -->
<script>
    window.__INITIAL_STATE__ = {"title":"流浪地球","score":8.5}
</script>

<!-- 或者是邮件、电话、身份证号等 -->
联系我们：010-12345678，邮箱：help@example.com
```

这时候，**正则表达式**就能大显身手！

## 1.2 什么是正则表达式？

**正则表达式**（Regular Expression，简称 regex）是一种强大的**文本模式匹配**工具。

- 它不是 Python 独有的，而是一种通用的文本处理技术
- 它使用特殊的语法描述文本的规律
- 可以精确地从杂乱文本中提取我们需要的内容

> 💡 **打个比方**
> 
> 如果把 BeautifulSoup 比作"用筷子夹菜"（适合有规则的 HTML 结构），那正则表达式就是"用筛子筛豆子"（适合从任意文本中精准提取目标内容）。

---

# 2. 正则表达式快速入门

## 2.1 字符字面量：精确匹配

最简单的正则表达式就是直接匹配我们看到的字符：

```python
import re

pattern = r'python'      # 匹配字母 "python"
text = 'I love python programming'

result = re.findall(pattern, text)
print(result)  # ['python']
```

**注意**：`r'python'` 中的 `r` 表示 **raw string（原始字符串）**，Python 不会处理其中的转义字符。

```python
# 没有 r：\n 被解释为换行符
print('<span class="title">\n</span>')

# 有 r：\n 就是两个字符
print(r'<span class="title">\n</span>')
```

## 2.2 元字符：特殊意义的字符

正则表达式中有一些字符有特殊含义：

| 元字符 | 含义 | 示例 |
|--------|------|------|
| `.` | 匹配**任意**单个字符（换行符除外） | `r't.m'` 匹配 'tom'、'tam' |
| `\d` | 匹配任意数字 | `r'\d'` 匹配 '0'-'9' |
| `\D` | 匹配任意非数字 | `r'\D'` 匹配非数字字符 |
| `\w` | 匹配字母、数字、下划线 | `r'\w'` 匹配 a-z, A-Z, 0-9, _ |
| `\W` | 匹配非单词字符 | `r'\W'` 匹配空格、标点等 |
| `\s` | 匹配空白字符 | `r'\s'` 匹配空格、\t、\n |
| `\S` | 匹配非空白字符 | `r'\S'` 匹配非空白字符 |

```python
import re

# 示例：匹配电话号码（假设格式为 138-1234-5678）
phone_text = '张三的电话是138-1234-5678，李四是139-5678-1234'
pattern = r'\d{3}-\d{4}-\d{4}'
phones = re.findall(pattern, phone_text)
print(phones)  # ['138-1234-5678', '139-5678-1234']
```

## 2.3 量词：指定匹配次数

| 量词 | 含义 | 示例 |
|------|------|------|
| `*` | 匹配0次或多次 | `r'ab*'` 匹配 'a'、'ab'、'abbb' |
| `+` | 匹配1次或多次 | `r'ab+'` 匹配 'ab'、'abbb'（不匹配 'a'） |
| `?` | 匹配0次或1次 | `r'ab?'` 匹配 'a' 或 'ab' |
| `{n}` | 匹配恰好n次 | `r'\d{4}'` 匹配4位数字 |
| `{n,}` | 匹配至少n次 | `r'\d{4,}'` 匹配4位及以上数字 |
| `{n,m}` | 匹配n到m次 | `r'\d{4,6}'` 匹配4到6位数字 |

```python
import re

text = '我有 2 个苹果，她有 10 个橘子，他有 100 个香蕉'

# 匹配一个或多个数字
numbers = re.findall(r'\d+', text)
print(numbers)  # ['2', '10', '100']

# 匹配4位数字（年份）
year_text = '北京奥运会是2008年，上海世博会2010年'
years = re.findall(r'\d{4}', year_text)
print(years)  # ['2008', '2010']
```

## 2.4 字符类：`[]`

用方括号 `[]` 定义一个字符集合，匹配其中**任意一个**字符：

```python
import re

# 匹配所有颜色名称
colors = re.findall(r'red|green|blue', 'red apple green leaf blue sky')
print(colors)  # ['red', 'green', 'blue']

# 匹配数字或字母
alphanum = re.findall(r'[A-Za-z0-9]', 'Hello123!')
print(alphanum)  # ['H', 'e', 'l', 'l', 'o', '1', '2', '3']

# 使用范围
letters = re.findall(r'[a-z]', 'Hello123')
print(letters)  # ['e', 'l', 'l', 'o']

# 排除：[^...] 表示"不是..."
non_digit = re.findall(r'[^0-9]', 'abc123')
print(non_digit)  # ['a', 'b', 'c']
```

**常用字符类简写：**

| 字符类 | 等价 | 含义 |
|--------|------|------|
| `[0-9]` | `\d` | 数字 |
| `[a-zA-Z]` | - | 字母 |
| `[a-zA-Z0-9]` | `\w` | 字母或数字 |

## 2.5 边界匹配

| 边界 | 含义 | 示例 |
|------|------|------|
| `^` | 匹配字符串**开头** | `r'^Hello'` 匹配开头是 Hello 的字符串 |
| `$` | 匹配字符串**结尾** | `r'World$'` 匹配结尾是 World 的字符串 |
| `\b` | 匹配单词边界 | `r'\bword\b'` 精确匹配 "word" |

```python
import re

# 匹配以 138 开头的手机号
phones = ['138-1234-5678', '139-5678-1234', '100-1234-5678']
for phone in phones:
    if re.match(r'^138', phone):
        print(f'{phone} 是移动号码')

# 匹配 .com 结尾的域名
domains = ['example.com', 'test.org', 'hello.com.cn', 'site.com']
for d in domains:
    if re.search(r'\.com$', d):
        print(f'{d} 是商业网站')
```

## 2.6 转义字符 `\`

如果我们要匹配元字符本身（如 `.`、`*`、`?`），需要用 `\` 转义：

```python
import re

# 匹配 IP 地址（注意要转义点号）
ip_text = '服务器IP: 192.168.1.1，子控IP: 10.0.0.1'
pattern = r'\d+\.\d+\.\d+\.\d+'
ips = re.findall(pattern, ip_text)
print(ips)  # ['192.168.1.1', '10.0.0.1']

# 匹配邮箱（@ 本身不需要转义）
email_text = '联系邮箱: user@example.com，备用: admin@test.org'
pattern = r'[a-zA-Z0-9_]+@[a-zA-Z0-9]+\.[a-zA-Z]+'
emails = re.findall(pattern, email_text)
print(emails)  # ['user@example.com', 'admin@test.org']
```

---

# 3. Python re 模块详解

## 3.1 `re.findall()` - 查找所有匹配

**最常用**：返回所有匹配项的列表。

```python
import re

text = '我的邮箱是 user@python.com，另一个是 admin@java.com'

# 提取所有邮箱
pattern = r'[a-zA-Z0-9_]+@[a-zA-Z0-9]+\.[a-zA-Z]+'
emails = re.findall(pattern, text)
print(emails)  # ['user@python.com', 'admin@java.com']
```

## 3.2 `re.search()` - 查找第一个匹配

返回第一个匹配的对象（Match Object），如果没找到返回 `None`。

```python
import re

text = '电话号码：138-1234-5678 或 139-5678-1234'

# 找第一个电话号码
result = re.search(r'\d{3}-\d{4}-\d{4}', text)
if result:
    print(f'找到: {result.group()}')  # 138-1234-5678
    print(f'位置: {result.start()}-{result.end()}')  # 6-18
```

## 3.3 `re.match()` - 从字符串开头匹配

只在字符串**开头**匹配，匹配成功返回 Match 对象，失败返回 `None`。

```python
import re

# 检查是否是以 "http" 开头的 URL
urls = ['http://example.com', 'https://test.org', 'ftp://files.net']

for url in urls:
    result = re.match(r'http', url)
    print(f'{url}: {"匹配" if result else "不匹配"}')
# http://example.com: 匹配
# https://test.org: 不匹配（因为是 https，不是 http）
```

## 3.4 `re.finditer()` - 返回迭代器

适合大规模匹配，节省内存：

```python
import re

text = '3.14是圆周率，1.414是根号2，9.8是重力加速度'

# 找出所有小数
for match in re.finditer(r'\d+\.\d+', text):
    print(f'找到: {match.group()}, 位置: {match.start()}-{match.end()}')

# 输出:
# 找到: 3.14, 位置: 0-4
# 找到: 1.414, 位置: 8-13
# 找到: 9.8, 位置: 20-23
```

## 3.5 Match 对象的方法

```python
import re

text = '时间：2024-03-15 地点：北京'
result = re.search(r'(\d{4})-(\d{2})-(\d{2})', text)

print(result.group())       # 2024-03-15（完整匹配）
print(result.group(1))      # 2024（第一个分组）
print(result.group(2))      # 03（第二个分组）
print(result.group(3))      # 15（第三个分组）
print(result.groups())     # ('2024', '03', '15')
print(result.span())        # (3, 13)
```

## 3.6 `re.sub()` - 替换

```python
import re

text = '我的手机号是138-1234-5678，请记住！'

# 把手机号中间四位用 * 替换（脱敏）
pattern = r'(\d{3})-(\d{4})-(\d{4})'
result = re.sub(pattern, r'\1-****-\3', text)
print(result)  # 我的手机号是138-****-5678，请记住！
```

---

# 4. 贪婪 vs 非贪婪匹配

## 4.1 什么是贪婪匹配？

正则表达式的量词（`*`、`+`、`{n,}`）默认是**贪婪**的——它们会尽可能多地匹配字符。

```python
import re

html = '<div class="title">流浪地球</div><div class="title">你好，李焕英</div>'

# 用 .* 贪婪匹配
pattern = r'<div class="title">.*</div>'
result = re.findall(pattern, html)
print('贪婪匹配结果:')
print(result)
# 输出: ['<div class="title">流浪地球</div><div class="title">你好，李焕英</div>']
# ⚠️ 错误！它把两个 div 合并成一个了！
```

**原因**：`.*` 会一直匹配到**最后一个** `</div>`，而不是第一个。

## 4.2 什么是非贪婪匹配？

在量词后面加一个 `?`，变成**非贪婪**（也叫**最小匹配**）：

```python
import re

html = '<div class="title">流浪地球</div><div class="title">你好，李焕英</div>'

# 用 .*? 非贪婪匹配
pattern = r'<div class="title">.*?</div>'
result = re.findall(pattern, html)
print('非贪婪匹配结果:')
print(result)
# 输出: ['<div class="title">流浪地球</div>', '<div class="title">你好，李焕英</div>']
# ✅ 正确！每个 div 单独匹配
```

## 4.3 贪婪 vs 非贪婪对比

| 量词 | 贪婪 | 非贪婪 |
|------|------|--------|
| `*` | `*` | `*?` |
| `+` | `+` | `+?` |
| `{n,}` | `{n,}` | `{n,}?` |

```python
import re

text = 'abc123def456'

# 贪婪：匹配尽可能多
print(re.findall(r'\d+', text))      # ['123456'] - 匹配所有数字

# 非贪婪：匹配尽可能少
print(re.findall(r'\d+?', text))     # ['1', '2', '3', '4', '5', '6'] - 每个数字单独匹配
```

## 4.4 `[^<]+` 技巧

在爬虫中，有一个经典技巧：用 `[^<]+` 代替 `.+?`

```python
import re

html = '<span class="title">流浪地球</span><span class="title">你好，李焕英</span>'

# 方法1：.*? 非贪婪
pattern1 = r'<span class="title">.*?</span>'
print(re.findall(pattern1, html))

# 方法2：[^<]+ 更好！
pattern2 = r'<span class="title">([^<]+)</span>'
titles = re.findall(pattern2, html)
print(titles)  # ['流浪地球', '你好，李焕英']
```

**为什么 `[^<]+` 更好？**
- `.` 需要考虑换行符，默认不匹配 `\n`（除非用 `re.DOTALL` 模式）
- `[^<]` 明确排除了 `<`，性能更好，也更直观

---

# 5. 分组与捕获

## 5.1 捕获分组 `()`

用圆括号 `()` 创建分组，匹配到的内容会被**捕获**，可以通过 `groups()` 获取。

```python
import re

text = '2024-03-15'

pattern = r'(\d{4})-(\d{2})-(\d{2})'
result = re.findall(pattern, text)
print(result)  # [('2024', '03', '15')]

# 如果只想要捕获的内容，用 findall 会直接返回分组列表
```

## 5.2 命名分组 `(?P<name>...)`

给分组起个名字，更清晰：

```python
import re

text = '2024-03-15'

pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
result = re.search(pattern, text)

if result:
    print(result.group('year'))   # 2024
    print(result.group('month'))  # 03
    print(result.group('day'))     # 15
```

## 5.3 非捕获分组 `(?:...)`

有时候分组但不想要捕获，用 `(?:...)` 可以避免创建分组编号：

```python
import re

# 捕获分组：会创建 group(1)
result1 = re.search(r'(\d{4})-(\d{2})', '2024-03')
print(result1.groups())  # ('2024', '03')

# 非捕获分组：不创建额外 group
result2 = re.search(r'(?:\d{4})-(\d{2})', '2024-03')
print(result2.groups())  # ('03',) - 只有 group(1)
```

## 5.4 分组在替换中的应用

```python
import re

text = '2024-03-15'

# 交换年月日的顺序
pattern = r'(\d{4})-(\d{2})-(\d{2})'
result = re.sub(pattern, r'\2/\3/\1', text)
print(result)  # 03/15/2024
```

---

# 6. 实战：爬虫中的正则表达式

## 6.1 提取电影信息

```python
import re

# 模拟从某电影网站抓取的 HTML
html = '''
<div class="movie-item">
    <div class="title">流浪地球</div>
    <div class="score">8.5</div>
    <div class="info">导演：郭帆 | 2024 | 科幻</div>
</div>
<div class="movie-item">
    <div class="title">你好，李焕英</div>
    <div class="score">7.9</div>
    <div class="info">导演：贾玲 | 2024 | 喜剧</div>
</div>
'''

# 提取电影名
title_pattern = r'<div class="title">([^<]+)</div>'
titles = re.findall(title_pattern, html)
print('电影名:', titles)

# 提取评分
score_pattern = r'<div class="score">([^<]+)</div>'
scores = re.findall(score_pattern, html)
print('评分:', scores)

# 提取导演
director_pattern = r'导演：([^|]+)'
directors = re.findall(director_pattern, html)
print('导演:', [d.strip() for d in directors])
```

**输出：**
```
电影名: ['流浪地球', '你好，李焕英']
评分: ['8.5', '7.9']
导演: ['郭帆', '贾玲']
```

## 6.2 豆瓣电影 Top250：逐行代码详解

> 💡 **本节说明**
>
> 上节课同学们已经用过这几段代码来抓取豆瓣电影 Top250。很多同学对正则表达式的细节还有疑问，这节我们逐行讲解，逐一拆解每个 pattern 是怎么工作的。

### 6.2.1 提取电影标题（含英文名过滤）

```python
import requests
import re

url = 'https://www.douban.com/doulist/3936288/'
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
response = requests.get(url, headers=headers)
html = response.text

# 匹配 <span class="title">电影名</span>
title_pattern = r'<span class="title">([^<]+)</span>'
titles = re.findall(title_pattern, html)

# 过滤掉英文名（以 / 开头）
chinese_titles = [t for t in titles if not t.startswith('/')]

print('电影名称（前10部）：')
for i, title in enumerate(chinese_titles[:10], 1):
    print(f'{i}. {title}')
```

**逐行解析：**

| 代码行 | 含义 |
|--------|------|
| `html = response.text` | 把服务器返回的 HTML 页面内容转换成字符串 |
| `title_pattern = r'<span class="title">([^<]+)</span>'` | 定义正则表达式 |
| `re.findall(title_pattern, html)` | 在整个 HTML 页面中找出所有匹配的部分 |

**正则表达式拆解：** `r'<span class="title">([^<]+)</span>'`

```
<span class="title">   →  匹配HTML标签，字面意思，一个字符一个字符地匹配
(                   →  开始捕获分组——把匹配到的内容"抓"出来
[^<]+               →  核心！一个或多个"不是<"的字符
)                   →  结束捕获分组
</span>             →  匹配闭合标签，字面意思
```

`[^<]+` 是关键：
- `[^...]` 是字符集，表示"不是括号里任意一个字符"
- `[^<]` = 不是 `<` 的任意字符
- `+` = 出现一次或多次
- 所以 `[^<]+` 的意思是：**一直匹配，直到遇到 `<` 为止**

为什么要这样？来看豆瓣的 HTML 真实结构：

```html
<span class="title">肖申克的救赎</span>
<span class="title">/The Shawshank Redemption</span>
<span class="title">千与千寻</span>
```

每部电影有两个 `<span class="title">`：
1. **第一个**：中文名，如 `肖申克的救赎`
2. **第二个**：英文名，以 `/` 开头，如 `/The Shawshank Redemption`

所以后面需要过滤：

```python
chinese_titles = [t for t in titles if not t.startswith('/')]
```

这就是列表推导式，等价于：

```python
chinese_titles = []
for t in titles:
    if not t.startswith('/'):
        chinese_titles.append(t)
```

**想一想：** 如果不用 `[^<]+`，而是用 `.+` 代替，会发生什么？

```python
# 贪婪匹配版
bad_pattern = r'<span class="title">.+</span>'
# .+ 会尽可能多地匹配，从第一个 <span class="title"> 一直匹配到...
# 整个HTML里最后一个 </span>！把所有标题合并成了一大段文本！
```

---

### 6.2.2 提取电影评分

```python
rating_pattern = r'<span class="rating_num"[^>]*>(\d+\.\d)</span>'
ratings = re.findall(rating_pattern, html)

print('评分（前10部）：')
for i, rating in enumerate(ratings[:10], 1):
    print(f'{i}. 评分: {rating}')
```

**正则表达式拆解：** `r'<span class="rating_num"[^>]*>(\d+\.\d)</span>'`

```
<span class="rating_num"   →  匹配开始标签的字面部分
[^>]*                         →  [^>] = 不是">"的字符，* = 出现0次或多次
                                  含义：标签内可能有其他属性（id、style等），全部跳过
>                            →  匹配到标签结束符号 >
(\d+\.\d)                    →  捕获评分数字
                                  \d+ = 一个或多个数字
                                  \. = 小数点（点号需要转义！）
                                  \d = 一个小数位
</span>                       →  匹配闭合标签
```

**为什么要用 `[^>]*`？**

豆瓣的真实评分 HTML 可能长这样：

```html
<!-- 简单情况 -->
<span class="rating_num">9.7</span>

<!-- 有额外属性的情况 -->
<span class="rating_num" id="rating_1" style="color:red">9.7</span>
```

`[^>]*` 可以灵活处理这两种情况——不管标签里有多少属性（甚至没有属性），都能正常匹配。

**为什么要转义 `\.`？**

在正则表达式里，`.` 是元字符，代表"任意字符"。但我们需要匹配**小数点本身**，而不是"任意字符"，所以要写成 `\.`。

```python
# 错误：\d+. 会把小数点也匹配掉
r'(\d+.\d)'     # . 匹配任意字符，危险！

# 正确：\d+\.\d 小数点用 \. 转义
r'(\d+\.\d)'    # 只有小数点才能被匹配
```

---

### 6.2.3 提取经典台词（引言）

```python
quote_pattern = r'<span class="inq">([^<]+)</span>'
quotes = re.findall(quote_pattern, html)

print('经典台词：')
for i, quote in enumerate(quotes, 1):
    print(f'{i}. "{quote}"')
```

**正则表达式拆解：** `r'<span class="inq">([^<]+)</span>'`

这个 pattern 和标题的非常像，结构完全一样，只是 class 名不同：

```
<span class="inq">   →  匹配开始标签
([^<]+)              →  捕获标签内的文字（不能有<）
</span>               →  匹配闭合标签
```

**豆瓣的真实引言 HTML：**

```html
<span class="inq">希望让人自由。</span>
<span class="inq">暗恋一个人，是最安静的秘密。</span>
```

每句引言都被一个 `<span class="inq">` 包裹，正则直接按标签匹配即可。

**注意：** 并不是每部电影都有引言，所以 `quotes` 列表的长度可能小于电影数量，这是正常的。

---

### 6.2.4 三段代码完整版

```python
import requests
import re

url = 'https://www.douban.com/doulist/3936288/'
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
response = requests.get(url, headers=headers)
response.encoding = 'utf-8'
html = response.text

# 1. 提取电影名
title_pattern = r'<span class="title">([^<]+)</span>'
titles = re.findall(title_pattern, html)
chinese_titles = [t for t in titles if not t.startswith('/')]

# 2. 提取评分
rating_pattern = r'<span class="rating_num"[^>]*>(\d+\.\d)</span>'
ratings = re.findall(rating_pattern, html)

# 3. 提取经典台词
quote_pattern = r'<span class="inq">([^<]+)</span>'
quotes = re.findall(quote_pattern, html)

# 合并打印（前10部）
print(f'{"排名":<4} {"电影名":<20} {"评分":<6} {"引言"}')
print('-' * 70)
for i in range(min(10, len(chinese_titles))):
    title = chinese_titles[i]
    rating = ratings[i] if i < len(ratings) else '无'
    quote = f'"{quotes[i]}"' if i < len(quotes) else '无'
    print(f'{i+1:<4} {title:<20} {rating:<6} {quote}')
```

**输出示例：**
```
排名  电影名                评分   引言
----------------------------------------------------------------------
1    肖申克的救赎         9.7    "希望让人自由。"
2    霸王别姬             9.6    无
3    阿甘正传             9.5    "生活就像一盒巧克力..."
4    泰坦尼克号           9.4    无
5    千与千寻             9.3    "我只能送你到这里了..."
...
```

---

### 6.2.5 调试技巧：先打印原始匹配

如果匹配不到内容，先不要急着改 pattern，先打印原始匹配看看：

```python
# ❌ 找不到就放弃了
titles = re.findall(title_pattern, html)
print(titles)  # []

# ✅ 调试：打印原始匹配结果
raw_matches = re.findall(title_pattern, html)
print(f'原始匹配数: {len(raw_matches)}')
print(f'前3个: {raw_matches[:3]}')
# 输出: 原始匹配数: 250
# 前3个: ['肖申克的救赎', '/The Shawshank Redemption', '霸王别姬']
```

调试思路：
1. 先确认原始匹配数量是否合理（豆瓣 Top250，理论上应该有 500 个匹配，因为每部电影有中英文两个 title）
2. 再看内容是否符合预期
3. 最后再过滤/处理

---

## 6.3 提取 JSON 数据中的字段

有时候网页中嵌入了 JSON 数据，正则表达式可以快速提取：

```python
import re
import json

# 模拟嵌入页面的 JSON
page_html = '''
<script>
    window.__INIT_DATA__ = {
        "user": {
            "name": "张三",
            "age": 20,
            "email": "zhangsan@example.com"
        },
        "token": "abc123xyz"
    };
</script>
'''

# 提取 JSON 字符串
json_pattern = r'window\.__INIT_DATA__\s*=\s*({.*?});'
match = re.search(json_pattern, page_html, re.DOTALL)

if match:
    json_str = match.group(1)
    data = json.loads(json_str)
    print(f"用户名: {data['user']['name']}")
    print(f"邮箱: {data['user']['email']}")
```

## 6.4 提取手机号、邮箱、URL

```python
import re

text = '''
张三的手机号：138-1234-5678，邮箱：zhangsan@python.com
李四的手机号：139-5678-1234，邮箱：lisi@java.com
他们的网站：http://example.com 和 https://test.org
地址：北京市海淀区中关村1号
'''

# 手机号：3位-4位-4位
phones = re.findall(r'\d{3}-\d{4}-\d{4}', text)
print('手机号:', phones)

# 邮箱
emails = re.findall(r'[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+', text)
print('邮箱:', emails)

# URL（http 或 https）
urls = re.findall(r'https?://[a-zA-Z0-9./-]+', text)
print('网址:', urls)
```

## 6.5 提取视频/音频链接

```python
import re

html = '''
<video src="https://cdn.example.com/video1.mp4"></video>
<video src="https://cdn.example.com/video2.mp4"></video>
<audio src="https://cdn.example.com/music.mp3"></audio>
'''

# 提取 MP4 视频链接
video_pattern = r'<video src="([^"]+\.mp4)">'
videos = re.findall(video_pattern, html)
print('视频:', videos)

# 提取所有媒体链接
media_pattern = r'<(?P<tag>video|audio) src="(?P<url>[^"]+)">'
for match in re.finditer(media_pattern, html):
    print(f"{match.group('tag')}: {match.group('url')}")
```

---

# 7. BeautifulSoup + 正则表达式：黄金组合

## 7.1 为什么需要组合？

BeautifulSoup 擅长处理 HTML 结构，但面对不规则的文本就力不从心。

**最佳实践：**
1. 用 BeautifulSoup 定位到包含目标内容的**区域**
2. 在这个区域内用正则表达式**精确提取**

```python
import requests
from bs4 import BeautifulSoup
import re

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}

url = 'https://movie.douban.com/subject/35267208/'

try:
    response = requests.get(url, headers=headers, timeout=10)
    soup = BeautifulSoup(response.text, 'lxml')
    
    # 1. 用 BeautifulSoup 找到包含评分的区域
    score_section = soup.select_one('#interest_sect_level')
    
    if score_section:
        # 2. 在这个区域内用正则提取数字
        score_text = score_section.text
        rating = re.search(r'(\d+\.\d)', score_text)
        if rating:
            print(f'评分: {rating.group(1)}')
            
except Exception as e:
    print(f'请求失败: {e}')
```

## 7.2 用 `re.find_all` 结合 BeautifulSoup

```python
import requests
from bs4 import BeautifulSoup
import re

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}

# 豆瓣电影页面
url = 'https://movie.douban.com/subject/35267208/'

response = requests.get(url, headers=headers)
soup = BeautifulSoup(response.text, 'lxml')

# 提取页面标题（通常在 title 标签里）
title_tag = soup.find('title')
if title_tag:
    title = re.search(r'^(.+?)\s*\(豆瓣\)', title_tag.text)
    print(f'片名: {title.group(1) if title else title_tag.text}')

# 提取年份（4位数字）
info_text = soup.select_one('#info').text
year = re.search(r'\d{4}', info_text)
print(f'年份: {year.group() if year else "未知"}')

# 提取评分
rating = soup.select_one('.rating_num')
if rating:
    print(f'豆瓣评分: {rating.text}')

# 提取评价人数
comments = re.search(r'(\d+)\s*人评价', info_text)
if comments:
    print(f'评价人数: {comments.group(1)}')
```

## 7.3 提取所有链接的特定格式

```python
import requests
from bs4 import BeautifulSoup
import re

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}

url = 'https://www.example.com'
response = requests.get(url, headers=headers)
soup = BeautifulSoup(response.text, 'lxml')

# 找到所有链接
all_links = soup.find_all('a', href=True)

# 筛选出所有指向 .pdf 文件的链接
pdf_links = [link['href'] for link in all_links 
             if re.search(r'\.pdf$', link['href'])]

# 筛选出所有图片链接
img_links = [link['href'] for link in all_links 
             if re.search(r'\.(jpg|jpeg|png|gif)$', link['href'], re.I)]

print(f'PDF文件 ({len(pdf_links)}个):')
for link in pdf_links:
    print(f'  {link}')

print(f'\n图片文件 ({len(img_links)}个):')
for link in img_links[:5]:  # 只显示前5个
    print(f'  {link}')
```

---

# 8. 正则表达式 vs XPath：两种提取方式对比

> 💡 **本节说明**
>
> 课本上主要介绍了 XPath 作为网页内容提取的工具，但实际上正则表达式同样强大。这节课我们用同一个案例（豆瓣电影 Top250）来对比两种方法，帮助大家理解各自的优势与局限。

## 8.1 案例回顾：豆瓣电影 Top250

先回顾上节课我们用 BeautifulSoup + CSS 选择器提取豆瓣电影的方法：

```python
import requests
from bs4 import BeautifulSoup

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}

url = 'https://www.douban.com/doulist/3936288/'
response = requests.get(url, headers=headers)
response.encoding = 'utf-8'
soup = BeautifulSoup(response.text, 'lxml')

# 找到所有电影条目
movies = soup.select('.doulist-item')

count = 0
for movie in movies:
    title_link = movie.select_one('a[href*="/subject/"]')
    if title_link:
        title = title_link.get_text(strip=True)
        rating = movie.select_one('.rating_nums')
        rating_text = rating.text.strip() if rating else '无评分'
        print(f'{count + 1}. {title} - 评分: {rating_text}')
        count += 1
    if count >= 10:
        break
```

**输出示例：**
```
1. 肖申克的救赎 - 评分: 9.7
2. 霸王别姬 - 评分: 9.6
3. 阿甘正传 - 评分: 9.5
4. 泰坦尼克号 - 评分: 9.4
5. 千与千寻 - 评分: 9.3
...
```

## 8.2 方法二：使用正则表达式提取

如果我们直接观察豆瓣页面的 HTML 源码，会发现每部电影的信息结构大致如下：

```html
<div class="doulist-item">
    ...
    <div class="title">
        <a href="/subject/1292055/">肖申克的救赎</a>
    </div>
    <span class="rating_nums">9.7</span>
    ...
</div>
```

**用正则表达式来提取：**

```python
import requests
import re

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}

url = 'https://www.douban.com/doulist/3936288/'
response = requests.get(url, headers=headers)
response.encoding = 'utf-8'
html = response.text

# 提取电影名（捕获 a 标签内、/subject/ 链接后的中文内容）
title_pattern = r'<a href="/subject/\d+/">([^<]+)</a>'
titles = re.findall(title_pattern, html)

# 提取评分
rating_pattern = r'class="rating_nums">([\d.]+)</span>'
ratings = re.findall(rating_pattern, html)

# 合并输出
for i, title in enumerate(titles[:10]):
    rating = ratings[i] if i < len(ratings) else '无评分'
    print(f'{i+1}. {title} - 评分: {rating}')
```

**输出：**
```
1. 肖申克的救赎 - 评分: 9.7
2. 霸王别姬 - 评分: 9.6
3. 阿甘正传 - 评分: 9.5
4. 泰坦尼克号 - 评分: 9.4
5. 千与千寻 - 评分: 9.3
...
```

## 8.3 方法三：使用 XPath 提取

XPath 是另一种在 XML/HTML 中定位节点的语言。以下是等效的 XPath 写法：

> ⚠️ **注意**：Python 原生不支持 XPath，需要配合 `lxml` 库使用：
> `pip install lxml`

```python
import requests
from lxml import etree

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}

url = 'https://www.douban.com/doulist/3936288/'
response = requests.get(url, headers=headers)
response.encoding = 'utf-8'
html = response.text

# 解析 HTML
tree = etree.HTML(html)

# XPath 提取电影名
# //div[@class='doulist-item'] 表示任意位置的 div，class 属性为 doulist-item
# .//a[contains(@href,'/subject/')] 表示在该 div 内的 a 标签，href 包含 /subject/
title_xpath = '//div[@class="doulist-item"]//a[contains(@href,"/subject/")]/text()'
titles = tree.xpath(title_xpath)

# XPath 提取评分
rating_xpath = '//div[@class="doulist-item"]//span[@class="rating_nums"]/text()'
ratings = tree.xpath(rating_xpath)

# 合并输出
for i, title in enumerate(titles[:10]):
    rating = ratings[i] if i < len(ratings) else '无评分'
    print(f'{i+1}. {title.strip()} - 评分: {rating}')
```

**输出：**
```
1. 肖申克的救赎 - 评分: 9.7
2. 霸王别姬 - 评分: 9.6
3. 阿甘正传 - 评分: 9.5
4. 泰坦尼克号 - 评分: 9.4
5. 千与千寻 - 评分: 9.3
...
```

## 8.4 三种方法对比

| 对比维度 | BeautifulSoup (CSS选择器) | 正则表达式 | XPath |
|----------|---------------------------|------------|-------|
| **学习难度** | ⭐ 低，容易上手 | ⭐⭐⭐ 较高，语法复杂 | ⭐⭐ 中等，有自己的语法体系 |
| **提取单位** | HTML 标签、属性 | 文本片段（任意位置） | XML/HTML 节点树 |
| **适用场景** | 结构规范的 HTML | 不规则文本、字符串处理 | 结构规范的 XML/HTML |
| **代码可读性** | 高，类似 CSS | 中，符号多 | 中，路径表达式较长 |
| **性能** | 较慢 | 快（编译后） | 快 |
| **灵活性** | 一般，依赖标签结构 | 极高，可匹配任意模式 | 较高，依赖节点结构 |
| **需要外部库** | beautifulsoup4 / lxml | 不需要（re 是内置） | lxml |

## 8.5 何时用哪种方法？

### 推荐用 **正则表达式** 的场景：

1. **文本内容分散在标签内外**
   ```html
   <script>
       window.data = {name: "流浪地球", score: 8.5};
   </script>
   ```
   BeautifulSoup 和 XPath 很难处理，但正则可以轻松提取 `name: "(.+?)"`

2. **需要精确的文本格式匹配**
   - 手机号：`\d{3}-\d{4}-\d{4}`
   - 邮箱：`[a-z]+@[a-z]+\.[a-z]+`
   - IP 地址：`\d+\.\d+\.\d+\.\d+`

3. **从日志或非结构化文本中提取**
   ```
   [2024-03-15 10:30:45] ERROR: connection failed
   [2024-03-15 10:31:00] INFO: retry successful
   ```

4. **数据清洗和替换**
   ```python
   # 把手机号脱敏
   re.sub(r'(\d{3})-(\d{4})-(\d{4})', r'\1-****-\3', text)
   ```

### 推荐用 **XPath** 的场景：

1. **HTML 结构清晰、层次分明**
   ```html
   <table>
     <tr><td>Python</td><td>90</td></tr>
     <tr><td>Math</td><td>85</td></tr>
   </table>
   ```
   `//table//tr/td[1]/text()` 即可提取第一列

2. **需要遍历树状结构**
   XPath 支持 `parent::*`、`following-sibling::*` 等轴向选择器

3. **结构化文档（如 XML）**
   XPath 是为 XML 设计的，处理 RSS、SVG 等格式更自然

### 推荐用 **BeautifulSoup (CSS)** 的场景：

1. **初学者入门**，语法最简单
2. **快速原型开发**，不需要精确控制
3. **CSS 选择器已够用**的简单场景

## 8.6 进阶：正则 + XPath 组合使用

实际上，最强大的做法是将两者结合：

```python
import requests
from lxml import etree
import re

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}

url = 'https://www.douban.com/doulist/3936288/'
response = requests.get(url, headers=headers)
response.encoding = 'utf-8'
html = response.text

# 第一步：用 XPath 快速定位到所有电影条目（结构筛选）
tree = etree.HTML(html)
movie_blocks = tree.xpath('//div[@class="doulist-item"]')

results = []
for block in movie_blocks[:10]:
    block_html = etree.tostring(block, encoding='unicode')

    # 第二步：在每个 block 内用正则精确提取
    movie_id = re.search(r'/subject/(\d+)/', block_html)
    movie_id = movie_id.group(1) if movie_id else '未知'

    title = block.xpath('.//a[contains(@href,"/subject/")]/text()')
    title = title[0].strip() if title else '未知'

    rating = block.xpath('.//span[@class="rating_nums"]/text()')
    rating = rating[0] if rating else '无评分'

    results.append(f'{movie_id}. {title} - 评分: {rating}')

for r in results:
    print(r)
```

**思路总结：**
```
XPath 负责：结构定位 → 快速找到目标区域（省去大量无关 HTML）
正则负责：精确提取 → 在区域内精准匹配目标文本
```

## 8.7 语法对照速查表

| 任务 | 正则表达式 | XPath |
|------|-----------|-------|
| 匹配所有 div 标签 | `r'<div>'` | `//div` |
| 匹配 class="title" 的元素 | `r'class="title"'` | `//*[@class="title"]` |
| 匹配包含 /subject/ 的链接 | `r'href="/subject/[^"]+"'` | `//a[contains(@href,"/subject/")]` |
| 提取标签文本内容 | `r'>([^<]+)</span>'` → group(1) | `//span/text()` |
| 匹配任意字符 | `.+?`（非贪婪） | `//text()[contains(.,'关键词')]` |
| 匹配数字 | `\d+` | `//span[number(text())]` |
| 匹配开头/结尾 | `^内容`、`内容$` | `//div[starts-with(@class,"title")]` |

---


# 9. 常见问题与解决方案

## 9.1 匹配不到内容

```python
import re

text = 'Hello\nWorld'

# 问题：. 不匹配换行符
print(re.findall(r'.+', text))  # ['Hello', 'World'] - 被拆成了两行？

# 解决1：用 re.DOTALL 模式（让 . 匹配换行）
print(re.findall(r'.+', text, re.DOTALL))  # ['Hello\nWorld']

# 解决2：用 [\s\S] 代替 .
print(re.findall(r'[\s\S]+', text))  # ['Hello\nWorld']
```

## 9.2 中文匹配

```python
import re

text = 'Python是一门很棒的语言，C语言也是'

# 匹配中文
chinese = re.findall(r'[\u4e00-\u9fff]+', text)
print(chinese)  # ['很棒的语言', '也是']

# 或者直接用 unicode
pattern = r'[\u4e00-\u9fff]+'
print(re.findall(pattern, text))
```

## 9.3 大小写不敏感匹配

```python
import re

text = 'Python PYTHON pYtHoN'

# 默认区分大小写
print(re.findall(r'python', text))  # []

# 用 re.IGNORECASE（可简写为 re.I）
print(re.findall(r'python', text, re.I))  # ['Python', 'PYTHON', 'pYtHoN']
```

## 9.4 多行模式

```python
import re

text = '''第一行内容
第二行内容
第三行内容'''

# 问题：^ 只匹配字符串开头
print(re.findall(r'^第.+', text))  # ['第一行内容']

# 解决：用 re.MULTILINE（可简写为 re.M）
print(re.findall(r'^第.+', text, re.M))  # ['第一行内容', '第二行内容', '第三行内容']
```

## 9.5 编译正则表达式提高性能

如果一个正则表达式要匹配多次，预先编译可以提高性能：

```python
import re
import time

# 需要匹配 10000 次的文本
text = '订单号：20240315-001，总额：999.50元'

# 方法1：每次调用都编译
start = time.time()
for _ in range(10000):
    re.findall(r'\d{4}-\d+', text)
print(f'未编译: {time.time() - start:.4f}秒')

# 方法2：预先编译
pattern = re.compile(r'\d{4}-\d+')
start = time.time()
for _ in range(10000):
    pattern.findall(text)
print(f'已编译: {time.time() - start:.4f}秒')
```

---

# 10. 动手练习

## 练习 1：提取天气预报

**目标**：从以下文本中提取日期、天气和温度。

```python
text = '''
2024-03-15 天气：晴 温度：15-25°C
2024-03-16 天气：多云 温度：12-20°C
2024-03-17 天气：小雨 温度：10-18°C
'''

# 提示：使用分组捕获日期、天气、温度
# pattern = r'你的正则表达式'

import re
pattern = r'(\d{4}-\d{2}-\d{2})\s*天气：([^ ]+)\s*温度：(\d+)-(\d+)°C'
matches = re.findall(pattern, text)

for match in matches:
    date, weather, low, high = match
    print(f'{date}: {weather}, {low}°C-{high}°C')
```

**预期输出：**
```
2024-03-15: 晴, 15°C-25°C
2024-03-16: 多云, 12°C-20°C
2024-03-17: 小雨, 10°C-18°C
```

---

## 练习 2：爬取豆瓣电影信息

**目标**：编写正则表达式，从模拟的 HTML 中提取电影信息。

```python
import re

html = '''
<div class="movie">
    <h2 class="name">《流浪地球》</h2>
    <span class="year">(2024)</span>
    <span class="rating">8.5</span>
    <span class="director">导演：郭帆</span>
</div>
<div class="movie">
    <h2 class="name">《你好，李焕英》</h2>
    <span class="year">(2024)</span>
    <span class="rating">7.9</span>
    <span class="director">导演：贾玲</span>
</div>
'''

# 编写正则表达式，提取所有电影信息
# pattern = r'你的正则表达式'

# 提示：可以用多个正则分别提取，或者用一个复杂的正则提取所有
name_pattern = r'<h2 class="name">《([^》]+)》</h2>'
year_pattern = r'<span class="year">\((\d{4})\)</span>'
rating_pattern = r'<span class="rating">([^<]+)</span>'
director_pattern = r'导演：([^<]+)'

names = re.findall(name_pattern, html)
years = re.findall(year_pattern, html)
ratings = re.findall(rating_pattern, html)
directors = re.findall(director_pattern, html)

for i in range(len(names)):
    print(f"{names[i]} | {years[i]} | 评分：{ratings[i]} | {directors[i]}")
```

---

## 练习 3：日志分析

**目标**：从服务器日志中提取 IP 地址、请求时间和状态码。

```python
import re

log = '''
192.168.1.100 - - [15/Mar/2024:10:15:30 +0800] "GET /index.html HTTP/1.1" 200 1234
10.0.0.50 - - [15/Mar/2024:10:15:31 +0800] "POST /api/login HTTP/1.1" 200 256
192.168.1.101 - - [15/Mar/2024:10:15:32 +0800] "GET /notfound.html HTTP/1.1" 404 512
172.16.0.200 - - [15/Mar/2024:10:15:33 +0800] "GET /images/logo.png HTTP/1.1" 200 4096
'''

# 提取 IP、时间和状态码
pattern = r'(\d+\.\d+\.\d+\.\d+).*?\[([^\]]+)\].*?" (\d{3}) \d+'

for match in re.finditer(pattern, log):
    ip, time, status = match.groups()
    print(f'IP: {ip:15} | 时间: {time:25} | 状态: {status}')
```

---

## 练习 4：电话号码脱敏

**目标**：将手机号中间四位用 `*` 替换，保护隐私。

```python
import re

phone_book = '''
张三：138-1234-5678
李四：139-5678-1234
王五：138-0000-1111
'''

# 脱敏：将 138-****-5678 格式输出
# 提示：使用分组和 re.sub

pattern = r'(\d{3})-(\d{4})-(\d{4})'

def mask_phone(match):
    return f'{match.group(1)}-****-{match.group(3)}'

masked = re.sub(pattern, mask_phone, phone_book)
print(masked)
```

---

## 练习 5：综合挑战（选做）

从以下课程表 HTML 中，用正则表达式提取所有课程信息：

```python
import re

html = '''
<table class="schedule">
    <tr><th>时间</th><th>课程</th><th>教室</th></tr>
    <tr><td>周一 1-2节</td><td>Python程序设计</td><td>A101</td></tr>
    <tr><td>周一 3-4节</td><td>数据结构</td><td>B205</td></tr>
    <tr><td>周二 1-2节</td><td>高等数学</td><td>C301</td></tr>
    <tr><td>周三 5-6节</td><td>Python程序设计</td><td>A102</td></tr>
</table>
'''

# 分别提取时间、课程、教室
time_pattern = r'<td>([^<]+)</td><td>([^<]+)</td><td>([^<]+)</td>'
courses = re.findall(time_pattern, html)

print('课程表：')
for time, course, room in courses:
    print(f'{time} | {course} | {room}')
```

---

# 📋 课程小结

## 核心要点

1. **正则表达式是强大的文本匹配工具**，可以精确提取任意文本中的目标内容

2. **元字符是基础**：
   - `.` 匹配任意字符
   - `\d` 匹配数字，`\w` 匹配字母数字下划线
   - `[]` 定义字符集，`[^...]` 排除字符集

3. **量词控制次数**：
   - `+` 一次或多次，`*` 零次或多次，`?` 零次或一次
   - `{n,m}` 指定范围

4. **贪婪 vs 非贪婪**：
   - 贪婪（`.*`、`\d+`）尽可能多匹配
   - 非贪婪（`.*?`、`\d+?`）尽可能少匹配
   - `[^<]+` 是爬虫中常用的非贪婪技巧

5. **分组 `()`**：
   - 捕获匹配内容
   - 用 `\1`、`\2` 在替换中引用分组
   - `(?P<name>...)` 命名分组更清晰

6. **BeautifulSoup + 正则 = 黄金组合**：
   - BeautifulSoup 负责结构定位
   - 正则负责精确提取

7. **re 模块常用函数**：
   - `findall()` 返回所有匹配列表
   - `search()` 找第一个匹配
   - `match()` 只匹配字符串开头
   - `finditer()` 返回迭代器，节省内存
   - `sub()` 替换匹配内容

## 常见错误速查

| 错误 | 原因 | 解决方法 |
|------|------|----------|
| 匹配结果为空 | `.` 不匹配换行符 | 用 `re.DOTALL` 或 `[^\n]` |
| 匹配太多 | 贪婪匹配 | 改为非贪婪 `*?`、`+?` |
| 匹配错误 | 元字符未转义 | 用 `\.` 匹配点号本身 |
| 中文匹配失败 | 字符集不对 | 用 `[\u4e00-\u9fff]` |

## 下节课预告
- XPath 选择器详解
- Selenium 动态页面抓取
- 反反爬策略与实战

---

*本讲义由 AI 助教生成，如有问题请随时提问。*