Python 入门基础教程：爬虫前置专用版

专为完全不懂编程的零基础小白打造，内容简单、知识点全面，结合实操练习学完即可看懂爬虫基础代码

---

第一章 认识Python并开启编程之旅

1.1 Python是什么？为什么学Python？

Python就像是一个超级翻译官，它能把我们人类能看懂的简单指令，翻译成电脑能执行的复杂操作。

为什么学Python？

• 最简单：语法像写英语句子一样，是所有编程语言中最容易上手的

• 最强大：能做爬虫、数据分析、人工智能、自动化办公等几乎所有事情

• 最适合爬虫：全世界90%以上的爬虫都是用Python写的，有大量现成的工具可以直接用

1.2 如何安装Python？

2025年最新版Python安装&PyCharm安装教程 （图文超级详细）_python下载安装教程-CSDN博客]

Windows系统安装步骤

1. 打开浏览器，访问Python官网：https://www.python.org/downloads/

2. 点击黄色的"Download Python 3.12.0"按钮（版本号可能不同，下载最新版即可）

3. 下载完成后双击安装包

4. 非常重要：勾选安装界面最下方的"Add Python 3.12 to PATH"

5. 点击"Install Now"，等待安装完成

6. 安装成功后，按键盘上的Win+R键，输入cmd，回车打开命令提示符

7. 输入python --version，如果显示类似Python 3.12.0的信息，说明安装成功

验证安装：运行第一个Python程序

1. 在电脑桌面新建一个文本文档

2. 把文件名改为hello.py（注意要把原来的.txt后缀也改掉）

3. 右键点击这个文件，选择"用记事本打开"

4. 输入以下代码：

# 这是我的第一个Python程序
print("你好，Python！我要开始学爬虫啦！")

1. 保存文件并关闭记事本

2. 在文件所在的文件夹地址栏输入cmd，回车打开命令提示符

3. 输入python hello.py，回车运行

4. 如果看到屏幕上显示你好，Python！我要开始学爬虫啦！，恭喜你！你已经成功运行了第一个Python程序！

1.3 什么是代码？什么是注释？

• 代码：就是我们写给Python翻译官看的指令，每一行代码都是一个操作

• 注释：是写给我们自己看的说明文字，Python会自动忽略注释

• 单行注释用#开头，多行注释用三个引号"""包裹

# 这是单行注释，Python不会执行这一行
print("这是代码，Python会执行这一行")

"""
这是多行注释
可以写很多行
Python同样不会执行
"""

1.4 pip包管理工具（⭐爬虫必备）

什么是pip？

pip是Python的官方包管理工具，就像是Python的"应用商店"。我们可以通过pip一键安装全世界开发者分享的各种Python工具库，比如爬虫必备的requests、Xpath等。

验证pip是否安装成功

打开命令提示符，输入：

pip --version

如果显示类似pip 24.0 from ...的信息，说明pip已经安装成功。

pip常用命令

# 安装第三方库
pip install 库名

# 示例：安装爬虫必备的requests库
pip install requests

# 卸载第三方库
pip uninstall 库名

# 查看已安装的所有库
pip list

# 查看某个库的详细信息
pip show 库名

配置国内镜像源（解决下载慢问题）

默认的pip源在国外，下载速度很慢。我们可以配置国内镜像源，让下载速度提升10倍以上。

临时使用国内源：

pip install requests -i https://pypi.tuna.tsinghua.edu.cn/simple

永久配置国内源（推荐）：

命令行一键设置（全平台通用，最简单）

直接在终端运行以下命令（任选其一）：

• # 1. 设置为清华源（推荐）
  pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
  pip config set global.trusted-host pypi.tuna.tsinghua.edu.cn

• # 2. 或设置为阿里源
  pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/
  pip config set global.trusted-host mirrors.aliyun.com

1.5 PyCharm专业代码编辑器使用（⭐爬虫必备）

虽然用记事本也能写Python代码，但专业的代码编辑器能让你的编程效率提升10倍。PyCharm是目前最流行的Python代码编辑器，有免费的社区版可以使用。

PyCharm安装步骤

1. 打开浏览器，访问PyCharm官网：https://www.jetbrains.com/pycharm/download/

2. 向下滚动找到"Community"（社区版），点击"Download"下载

3. 下载完成后双击安装包，一直点击"Next"即可

4. 安装完成后，勾选"Run PyCharm Community Edition"，点击"Finish"

PyCharm基本使用

1. 第一次打开PyCharm，选择"Do not import settings"，点击"OK"

2. 选择界面主题，点击"Next"

3. 点击"Create New Project"创建新项目

4. 在"Location"处选择项目保存位置，给项目起个名字（如python_spider）

5. 确保"Python Interpreter"已经选择了我们之前安装的Python版本

6. 点击"Create"创建项目

在PyCharm中运行Python程序

1. 右键点击左侧项目名称，选择"New" -> “Python File”

2. 给文件起个名字（如hello.py），回车

3. 在编辑区输入代码：

print("你好，PyCharm！")

1. 右键点击编辑区空白处，选择"Run ‘hello’"

2. 下方控制台会显示运行结果：你好，PyCharm！

PyCharm常用功能

• 代码补全：输入代码时会自动提示，按Tab键可以快速补全

• 语法检查：错误的代码会用红色波浪线标出

• 一键运行：点击右上角绿色三角形按钮即可运行当前文件

• 终端：点击底部"Terminal"标签，可以直接在PyCharm中使用命令行

本章小结

1. Python是一个能把人类指令翻译成电脑操作的翻译官

2. 安装Python时一定要勾选"Add Python to PATH"

3. Python程序文件的后缀是.py

4. 用python 文件名.py命令运行程序

5. print()函数的作用是在屏幕上打印输出内容

6. 注释是写给人看的，用#或"""表示

7. pip是Python的包管理工具，用来安装第三方库

8. PyCharm是专业的Python代码编辑器，能大幅提升编程效率

动手练习

1. 新建一个my_first_program.py文件

2. 用print()函数打印出你的名字和"我要学会爬虫！"

3. 给代码添加至少两行注释，说明这个程序的作用

4. 用pip安装requests库

5. 在PyCharm中创建一个新项目，并运行一个简单的程序

---

第二章 变量：给数据起个名字

2.1 什么是变量？

变量就像是一个贴了标签的盒子，我们可以把数据放进盒子里，然后通过标签来找到这个数据。

生活中的例子：

• 你有一个盒子，贴上"零花钱"的标签，里面放了100元

• 后来你又放了50元进去，现在盒子里有150元

• 你随时可以通过"零花钱"这个标签，知道盒子里有多少钱

在Python中，我们这样定义变量：

# 变量名 = 数据
pocket_money = 100  # 定义一个叫pocket_money的变量，值为100
print(pocket_money)  # 输出：100

pocket_money = 150  # 修改变量的值
print(pocket_money)  # 输出：150

2.2 变量的命名规则

变量名不是随便起的，必须遵守以下规则：

1. 只能包含字母、数字和下划线

2. 不能以数字开头

3. 不能使用Python的关键字（如if、for、while等）

4. 区分大小写（name和Name是两个不同的变量）

好的变量名习惯：

• 见名知意：用article_title而不是a

• 多个单词用下划线连接：user_name、page_url

• 全部小写

# 正确的变量名
age = 20
user_name = "小明"
page_url = "https://www.example.com"

# 错误的变量名（不要这么写）
123abc = 100  # 不能以数字开头
user-name = "小红"  # 不能包含减号
if = "条件"  # 不能使用关键字

2.3 变量的赋值

• 赋值符号是=，不是数学中的等于号

• =左边是变量名，右边是要存储的数据

• 可以同时给多个变量赋值

# 单个变量赋值
title = "Python爬虫入门教程"

# 多个变量同时赋值
a, b, c = 1, 2, 3
print(a)  # 输出：1
print(b)  # 输出：2
print(c)  # 输出：3

# 爬虫场景：存储爬取到的文章信息
article_title = "如何用Python爬取新闻"
article_author = "张三"
article_time = "2024-01-01"

本章小结

1. 变量是贴了标签的盒子，用来存储数据

2. 变量定义格式：变量名 = 数据

3. 变量名只能包含字母、数字和下划线，不能以数字开头

4. 变量的值可以随时修改

5. 好的变量名要见名知意

动手练习

1. 定义三个变量，分别存储你的姓名、年龄和爱好

2. 用print()函数打印出这三个变量的值

3. 修改年龄变量的值，然后再次打印

---

第三章 数据类型：不同种类的数据

Python中有很多种数据类型，就像生活中有不同种类的物品一样。我们重点学习爬虫中最常用的6种数据类型。

3.1 整数(int)：没有小数点的数字

整数就是我们平时说的正整数、负整数和0。

# 整数类型
age = 25
page_number = 10
status_code = 200  # 爬虫中常用的状态码，200表示请求成功
negative_number = -5

print(type(age))  # 输出：<class 'int'>，type()函数可以查看变量的类型

3.2 浮点数(float)：有小数点的数字

浮点数就是带小数点的数字。

# 浮点数类型
price = 99.9
pi = 3.14159
temperature = 25.5

print(type(price))  # 输出：<class 'float'>

3.3 字符串(str)：文本内容

字符串就是用引号括起来的文本内容，可以是单引号'，也可以是双引号"，效果一样。

# 字符串类型
name = "小明"
message = '我要学爬虫'
url = "https://www.baidu.com"  # 爬虫中最常用的字符串，存储网址

# 多行字符串用三个引号
long_text = """这是第一行
这是第二行
这是第三行"""

print(type(url))  # 输出：<class 'str'>

字符串的基本操作

# 1. 字符串拼接：用+号连接两个字符串
first_name = "张"
last_name = "三"
full_name = first_name + last_name
print(full_name)  # 输出：张三

# 2. 字符串重复：用*号
star = "*"
print(star * 10)  # 输出：**********

# 3. 获取字符串长度：用len()函数
title = "Python爬虫入门教程"
print(len(title))  # 输出：10

# 爬虫场景：拼接URL
base_url = "https://www.example.com/page/"
page = 1
full_url = base_url + str(page)  # 注意：数字要先转成字符串才能拼接
print(full_url)  # 输出：https://www.example.com/page/1

字符串高级操作（⭐爬虫必备）

1. 字符串切片：截取子串

字符串切片就像是"切蛋糕"，可以从一个长字符串中截取我们需要的部分。

格式：字符串[起始索引:结束索引:步长]

• 起始索引：从哪个位置开始截取（包含），默认为0

• 结束索引：到哪个位置结束（不包含），默认为字符串长度

• 步长：每隔几个字符取一个，默认为1

text = "Python爬虫入门教程"

# 截取从索引0到索引5的字符（不包含5）
print(text[0:6])  # 输出：Python

# 省略起始索引，从开头截取到索引5
print(text[:6])  # 输出：Python

# 省略结束索引，从索引6截取到末尾
print(text[6:])  # 输出：爬虫入门教程

# 截取最后3个字符
print(text[-3:])  # 输出：入门教程

# 步长为2，每隔一个字符取一个
print(text[::2])  # 输出：Pto爬入程

# 反转字符串
print(text[::-1])  # 输出：程教门入虫爬nohtyP

# 爬虫场景：从URL中提取域名
url = "https://www.example.com/article/123.html"
domain = url[8:22]  # 截取"www.example.com"
print(domain)  # 输出：www.example.com

2. 字符串常用方法

text = "  Hello Python!  "

# strip()：去除字符串首尾的空格和换行符
print(text.strip())  # 输出：Hello Python!

# replace()：替换字符串中的内容
print(text.replace("Python", "爬虫"))  # 输出：  Hello 爬虫!  

# split()：按照指定分隔符分割字符串，返回列表
sentence = "苹果,香蕉,橙子,葡萄"
fruits = sentence.split(",")
print(fruits)  # 输出：['苹果', '香蕉', '橙子', '葡萄']

# join()：将列表中的字符串连接成一个字符串
fruits = ['苹果', '香蕉', '橙子', '葡萄']
sentence = "、".join(fruits)
print(sentence)  # 输出：苹果、香蕉、橙子、葡萄

# find()：查找子串的位置，找不到返回-1
print(text.find("Python"))  # 输出：8
print(text.find("Java"))  # 输出：-1

# 爬虫场景：处理爬取到的脏数据
dirty_title = "  【最新】Python爬虫入门教程  \n"
clean_title = dirty_title.strip().replace("【最新】", "")
print(clean_title)  # 输出：Python爬虫入门教程

3. 字符串格式化

字符串格式化可以让我们动态地在字符串中插入变量的值。

f-string格式化（Python3.6+推荐，最简单好用）：

name = "小明"
age = 20

# 在字符串前加f，用{}包裹变量名
print(f"我叫{name}，今年{age}岁")  # 输出：我叫小明，今年20岁

# 爬虫场景：动态生成URL
base_url = "https://www.example.com/page/"
page = 5
full_url = f"{base_url}{page}"
print(full_url)  # 输出：https://www.example.com/page/5

# 还可以在{}中进行计算
print(f"明年我就{age + 1}岁了")  # 输出：明年我就21岁了

4. 原始字符串

在字符串前加r表示原始字符串，Python不会处理其中的转义字符（如\n、\t等）。

# 普通字符串中的\会被当作转义字符
path = "C:\Users\小明\Desktop"  # 这会报错，因为\U是转义字符

# 原始字符串会原样输出
path = r"C:\Users\小明\Desktop"
print(path)  # 输出：C:\Users\小明\Desktop

# 爬虫场景：处理包含特殊字符的URL
url = r"https://www.example.com/search?q=python&page=1"

3.4 布尔值(bool)：只有两个值

布尔值只有两个：True（真）和False（假），通常用来表示条件是否成立。

# 布尔值类型
is_success = True
is_error = False

print(type(is_success))  # 输出：<class 'bool'>

# 爬虫场景：判断是否爬取成功
status_code = 200
is_success = (status_code == 200)
print(is_success)  # 输出：True

3.5 列表(list)：存储多个数据的容器

列表就像是一个大箱子，可以放很多不同类型的数据，而且可以随时添加、删除和修改里面的内容。

列表用方括号[]表示，里面的元素用逗号分隔。

# 列表类型
numbers = [1, 2, 3, 4, 5]
names = ["小明", "小红", "小刚"]
mixed = [1, "hello", 3.14, True]

print(type(numbers))  # 输出：<class 'list'>

列表的基本操作

# 1. 访问列表元素：通过索引（从0开始）
titles = ["文章1", "文章2", "文章3", "文章4", "文章5"]
print(titles[0])  # 输出：文章1（第一个元素）
print(titles[2])  # 输出：文章3（第三个元素）
print(titles[-1])  # 输出：文章5（最后一个元素）

# 2. 修改列表元素
titles[0] = "修改后的文章1"
print(titles)  # 输出：['修改后的文章1', '文章2', '文章3', '文章4', '文章5']

# 3. 添加元素：append()方法（在末尾添加）
titles.append("文章6")
print(titles)  # 输出：['修改后的文章1', '文章2', '文章3', '文章4', '文章5', '文章6']

# 4. 删除元素：del语句
del titles[1]
print(titles)  # 输出：['修改后的文章1', '文章3', '文章4', '文章5', '文章6']

# 5. 获取列表长度：len()函数
print(len(titles))  # 输出：5

# 爬虫场景：存储爬取到的多个文章标题
crawled_titles = []
crawled_titles.append("Python基础教程")
crawled_titles.append("爬虫入门指南")
crawled_titles.append("数据分析实战")
print(crawled_titles)  # 输出：['Python基础教程', '爬虫入门指南', '数据分析实战']

列表高级操作（⭐爬虫必备）

1. 列表切片

和字符串切片一样，列表也可以通过切片来获取子列表。

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 获取前3个元素
print(numbers[:3])  # 输出：[1, 2, 3]

# 获取从索引3到索引6的元素
print(numbers[3:7])  # 输出：[4, 5, 6, 7]

# 获取最后3个元素
print(numbers[-3:])  # 输出：[8, 9, 10]

# 反转列表
print(numbers[::-1])  # 输出：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

# 爬虫场景：只取前10条爬取到的数据
all_data = ["数据1", "数据2", "数据3", "数据4", "数据5", "数据6", "数据7", "数据8", "数据9", "数据10", "数据11", "数据12"]
top10_data = all_data[:10]
print(top10_data)

2. 列表常用方法

fruits = ["苹果", "香蕉", "橙子"]

# extend()：在列表末尾添加另一个列表的所有元素
more_fruits = ["葡萄", "西瓜"]
fruits.extend(more_fruits)
print(fruits)  # 输出：['苹果', '香蕉', '橙子', '葡萄', '西瓜']

# insert()：在指定位置插入元素
fruits.insert(1, "草莓")
print(fruits)  # 输出：['苹果', '草莓', '香蕉', '橙子', '葡萄', '西瓜']

# pop()：删除并返回指定位置的元素（默认最后一个）
last_fruit = fruits.pop()
print(last_fruit)  # 输出：西瓜
print(fruits)  # 输出：['苹果', '草莓', '香蕉', '橙子', '葡萄']

# index()：查找元素的索引
print(fruits.index("香蕉"))  # 输出：2

# count()：统计元素出现的次数
numbers = [1, 2, 3, 2, 1, 2, 4]
print(numbers.count(2))  # 输出：3

# sort()：对列表进行排序
numbers.sort()
print(numbers)  # 输出：[1, 1, 2, 2, 2, 3, 4]

# reverse()：反转列表
numbers.reverse()
print(numbers)  # 输出：[4, 3, 2, 2, 2, 1, 1]

3. 列表推导式

列表推导式是一种快速生成列表的方式，可以用一行代码代替多行循环。

# 普通方式生成1到10的平方列表
squares = []
for i in range(1, 11):
    squares.append(i * i)
print(squares)  # 输出：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 列表推导式生成同样的列表
squares = [i * i for i in range(1, 11)]
print(squares)  # 输出：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 带条件的列表推导式：只生成偶数的平方
even_squares = [i * i for i in range(1, 11) if i % 2 == 0]
print(even_squares)  # 输出：[4, 16, 36, 64, 100]

# 爬虫场景：批量生成URL
urls = [f"https://www.example.com/page/{i}" for i in range(1, 11)]
print(urls)

3.6 字典(dict)：存储键值对的容器

字典就像是一本通讯录，你可以通过"姓名"（键）找到对应的"电话号码"（值）。

字典用大括号{}表示，每个元素都是一个"键: 值"对，键和值之间用冒号分隔，元素之间用逗号分隔。

# 字典类型
person = {
    "name": "小明",
    "age": 20,
    "hobby": "编程"
}

print(type(person))  # 输出：<class 'dict'>

字典的基本操作

# 1. 访问字典值：通过键
person = {"name": "小明", "age": 20, "hobby": "编程"}
print(person["name"])  # 输出：小明
print(person["age"])  # 输出：20

# 2. 修改字典值
person["age"] = 21
print(person)  # 输出：{'name': '小明', 'age': 21, 'hobby': '编程'}

# 3. 添加新的键值对
person["gender"] = "男"
print(person)  # 输出：{'name': '小明', 'age': 21, 'hobby': '编程', 'gender': '男'}

# 4. 删除键值对：del语句
del person["hobby"]
print(person)  # 输出：{'name': '小明', 'age': 21, 'gender': '男'}

# 爬虫场景：存储单条爬取到的文章信息
article = {
    "title": "Python爬虫入门教程",
    "author": "张三",
    "time": "2024-01-01",
    "url": "https://www.example.com/article/1"
}
print(article["title"])  # 输出：Python爬虫入门教程
print(article["url"])  # 输出：https://www.example.com/article/1

字典高级操作（⭐爬虫必备）

1. 字典常用方法

article = {
    "title": "Python爬虫入门教程",
    "author": "张三",
    "time": "2024-01-01"
}

# keys()：获取所有键
print(article.keys())  # 输出：dict_keys(['title', 'author', 'time'])

# values()：获取所有值
print(article.values())  # 输出：dict_values(['Python爬虫入门教程', '张三', '2024-01-01'])

# items()：获取所有键值对
print(article.items())  # 输出：dict_items([('title', 'Python爬虫入门教程'), ('author', '张三'), ('time', '2024-01-01')])

# get()：安全获取值，如果键不存在返回None（或指定默认值）
print(article.get("title"))  # 输出：Python爬虫入门教程
print(article.get("url"))  # 输出：None
print(article.get("url", "未知"))  # 输出：未知

# 爬虫场景：安全获取可能不存在的字段
content = article.get("content", "暂无内容")
print(content)  # 输出：暂无内容

2. 遍历字典

article = {
    "title": "Python爬虫入门教程",
    "author": "张三",
    "time": "2024-01-01"
}

# 遍历所有键
for key in article.keys():
    print(key)

# 遍历所有值
for value in article.values():
    print(value)

# 遍历所有键值对（最常用）
for key, value in article.items():
    print(f"{key}: {value}")

3. 嵌套字典

字典的值也可以是另一个字典，这就是嵌套字典，常用于存储复杂的数据结构。

# 爬虫场景：存储包含多个文章的网站信息
website = {
    "name": "示例网站",
    "url": "https://www.example.com",
    "articles": [
        {
            "title": "文章1",
            "author": "张三"
        },
        {
            "title": "文章2",
            "author": "李四"
        }
    ]
}

# 访问嵌套字典中的值
print(website["articles"][0]["title"])  # 输出：文章1
print(website["articles"][1]["author"])  # 输出：李四

3.7 其他数据类型（简要了解）

• 元组(tuple)：和列表类似，但不能修改，用小括号()表示

• 集合(set)：存储不重复的元素，用大括号{}表示

• 类与对象：面向对象编程的内容，爬虫入门阶段不需要掌握

本章小结

1. 整数(int)：没有小数点的数字

2. 浮点数(float)：有小数点的数字

3. 字符串(str)：用引号括起来的文本内容

4. 布尔值(bool)：只有True和False两个值

5. 列表(list)：用[]表示，存储多个数据，可以修改

6. 字典(dict)：用{}表示，存储键值对，通过键访问值

7. 爬虫中最常用的数据类型是：字符串、列表、字典

8. 掌握字符串、列表、字典的高级操作是爬虫数据处理的基础

动手练习

1. 创建一个字符串"https://www.example.com/article/123.html"，使用切片提取出"123"

2. 创建一个列表，存储你最喜欢的5部电影名称，使用切片获取前3部

3. 创建一个字典，存储你的个人信息，使用get()方法获取"职业"字段，默认值为"学生"

4. 使用列表推导式生成1到20之间所有能被3整除的数

---

第四章 运算符：对数据进行操作

运算符就是用来对数据进行运算的符号，就像我们数学中的加减乘除一样。

4.1 算术运算符：进行数学计算

运算符	说明	例子	结果
+	加	5 + 3	8
-	减	5 - 3	2
*	乘	5 * 3	15
/	除	5 / 3	1.666…
//	整除	5 // 3	1
%	取余	5 % 3	2
**	幂运算	5 ** 3	125

# 算术运算符示例
a = 10
b = 3

print(a + b)  # 输出：13
print(a - b)  # 输出：7
print(a * b)  # 输出：30
print(a / b)  # 输出：3.3333333333333335
print(a // b)  # 输出：3（只取整数部分）
print(a % b)  # 输出：1（余数）
print(a ** b)  # 输出：1000（10的3次方）

4.2 赋值运算符：给变量赋值

运算符	说明	例子	等价于
=	简单赋值	a = 10	a = 10
+=	加等于	a += 3	a = a + 3
-=	减等于	a -= 3	a = a - 3
*=	乘等于	a *= 3	a = a * 3
/=	除等于	a /= 3	a = a / 3

# 赋值运算符示例
a = 10
a += 5  # 等价于 a = a + 5
print(a)  # 输出：15

a -= 3  # 等价于 a = a - 3
print(a)  # 输出：12

a *= 2  # 等价于 a = a * 2
print(a)  # 输出：24

4.3 比较运算符：比较两个值的大小

比较运算符的结果是布尔值（True或False）。

运算符	说明	例子	结果
==	等于	5 == 3	False
!=	不等于	5 != 3	True
>	大于	5 > 3	True
<	小于	5 < 3	False
>=	大于等于	5 >= 3	True
<=	小于等于	5 <= 3	False

# 比较运算符示例
a = 10
b = 20

print(a == b)  # 输出：False
print(a != b)  # 输出：True
print(a > b)  # 输出：False
print(a < b)  # 输出：True
print(a >= 10)  # 输出：True
print(b <= 15)  # 输出：False

# 爬虫场景：判断状态码是否为200
status_code = 404
print(status_code == 200)  # 输出：False

4.4 逻辑运算符：组合多个条件

逻辑运算符用来连接多个比较表达式，结果也是布尔值。

运算符	说明	例子	结果
and	与（两个都为True，结果才为True）	True and False	False
or	或（只要有一个为True，结果就为True）	True or False	True
not	非（取反）	not True	False

# 逻辑运算符示例
a = 10
b = 20
c = 30

# and：两个条件都满足才为True
print(a < b and b < c)  # 输出：True（10<20 且 20<30）
print(a < b and b > c)  # 输出：False（10<20 但 20不大于30）

# or：只要有一个条件满足就为True
print(a > b or b < c)  # 输出：True（10不大于20 但 20<30）
print(a > b or b > c)  # 输出：False（两个条件都不满足）

# not：取反
print(not a < b)  # 输出：False（a<b是True，取反后是False）

# 爬虫场景：判断状态码是否正常
status_code = 200
print(status_code >= 200 and status_code < 300)  # 输出：True（200-299都是正常状态码）

本章小结

1. 算术运算符：+、-、*、/、//、%、**

2. 赋值运算符：=、+=、-=、*=、/=

3. 比较运算符：==、!=、>、<、>=、<=，结果是布尔值

4. 逻辑运算符：and、or、not，用来组合多个条件

5. 爬虫中最常用的是比较运算符和逻辑运算符，用来做条件判断

动手练习

1. 计算100除以7的商和余数

2. 定义两个变量a=15，b=25，比较它们的大小并打印结果

3. 判断一个数是否在10到20之间（包括10和20）

---

第五章 控制结构：让程序有逻辑地运行

控制结构可以让程序根据不同的条件执行不同的代码，或者重复执行某段代码。

5.1 if条件判断语句：根据条件做选择

if语句就像是生活中的"如果…那么…"，如果条件成立，就执行某段代码。

5.1.1 单分支if语句

# 格式：
# if 条件:
#     条件成立时执行的代码

age = 18
if age >= 18:
    print("你已经成年了")

# 爬虫场景：如果状态码是200，就打印爬取成功
status_code = 200
if status_code == 200:
    print("网页请求成功，可以开始爬取数据")

5.1.2 双分支if-else语句

# 格式：
# if 条件:
#     条件成立时执行的代码
# else:
#     条件不成立时执行的代码

age = 16
if age >= 18:
    print("你已经成年了")
else:
    print("你还未成年")

# 爬虫场景：根据状态码判断是否成功
status_code = 404
if status_code == 200:
    print("网页请求成功")
else:
    print("网页请求失败，状态码：", status_code)

5.1.3 多分支if-elif-else语句

# 格式：
# if 条件1:
#     条件1成立时执行的代码
# elif 条件2:
#     条件2成立时执行的代码
# elif 条件3:
#     条件3成立时执行的代码
# else:
#     所有条件都不成立时执行的代码

score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

# 爬虫场景：根据不同状态码给出不同提示
status_code = 403
if status_code == 200:
    print("请求成功")
elif status_code == 404:
    print("页面不存在")
elif status_code == 403:
    print("没有访问权限")
elif status_code == 500:
    print("服务器内部错误")
else:
    print("未知错误，状态码：", status_code)

注意：Python中用缩进来表示代码块，通常用4个空格作为一个缩进级别。同一个代码块的缩进必须相同。

5.2 for循环语句：重复执行指定次数

for循环就像是生活中的"遍历"，比如遍历一个列表中的所有元素，或者重复执行某段代码指定次数。

5.2.1 遍历列表

# 格式：
# for 变量 in 列表:
#     循环体代码

# 遍历列表中的每个元素
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print("我喜欢吃", fruit)

# 爬虫场景：遍历多个URL进行爬取
urls = [
    "https://www.example.com/page/1",
    "https://www.example.com/page/2",
    "https://www.example.com/page/3"
]
for url in urls:
    print("正在爬取：", url)
    # 这里可以写爬取网页的代码

5.2.2 使用range()函数生成数字序列

range()函数可以生成一个数字序列，常用于循环指定次数。

# range(n)：生成0到n-1的数字
for i in range(5):
    print(i)  # 输出：0 1 2 3 4

# range(a, b)：生成a到b-1的数字
for i in range(2, 6):
    print(i)  # 输出：2 3 4 5

# range(a, b, step)：生成a到b-1的数字，步长为step
for i in range(1, 10, 2):
    print(i)  # 输出：1 3 5 7 9

# 爬虫场景：爬取前10页数据
for page in range(1, 11):
    url = "https://www.example.com/page/" + str(page)
    print("正在爬取第", page, "页：", url)

5.2.3 使用enumerate()同时获取索引和元素

titles = ["文章1", "文章2", "文章3"]

# 普通方式：需要自己维护索引
index = 0
for title in titles:
    print(f"第{index+1}篇文章：{title}")
    index += 1

# 使用enumerate()：同时获取索引和元素
for index, title in enumerate(titles):
    print(f"第{index+1}篇文章：{title}")

5.2.4 循环嵌套

循环嵌套就是在一个循环里面再写一个循环，常用于遍历多层数据结构。

# 打印九九乘法表
for i in range(1, 10):
    for j in range(1, i+1):
        print(f"{j}×{i}={i*j}", end="\t")
    print()  # 换行

# 爬虫场景：遍历嵌套列表
all_articles = [
    ["文章1-1", "文章1-2", "文章1-3"],
    ["文章2-1", "文章2-2", "文章2-3"],
    ["文章3-1", "文章3-2", "文章3-3"]
]

for page_articles in all_articles:
    for article in page_articles:
        print("正在处理：", article)

5.3 while循环语句：条件满足时一直循环

while循环就像是生活中的"只要…就一直…"，只要条件成立，就一直执行循环体代码。

# 格式：
# while 条件:
#     循环体代码

# 打印1到5
i = 1
while i <= 5:
    print(i)
    i += 1  # 一定要有改变条件的语句，否则会变成死循环

# 爬虫场景：循环爬取直到没有下一页
has_next_page = True
page = 1
while has_next_page:
    url = "https://www.example.com/page/" + str(page)
    print("正在爬取第", page, "页")
    
    # 这里可以写判断是否有下一页的代码
    # 假设爬取到第3页就没有下一页了
    if page == 3:
        has_next_page = False
    
    page += 1

警告：使用while循环时，一定要确保条件最终会变成False，否则程序会一直运行下去，变成死循环。

5.4 break和continue语句：控制循环

• break：立即终止整个循环

• continue：跳过当前循环的剩余代码，直接进入下一次循环

# break示例：找到第一个大于10的数就停止
numbers = [1, 5, 8, 12, 3, 15]
for num in numbers:
    if num > 10:
        print("找到第一个大于10的数：", num)
        break  # 立即终止循环
    print(num)

# continue示例：跳过所有偶数，只打印奇数
for i in range(1, 11):
    if i % 2 == 0:
        continue  # 跳过当前循环，进入下一次
    print(i)  # 只会打印奇数：1 3 5 7 9

# 爬虫场景：遇到错误状态码就停止爬取
urls = [
    "https://www.example.com/page/1",
    "https://www.example.com/page/2",
    "https://www.example.com/page/3",
    "https://www.example.com/page/4"
]
for url in urls:
    # 模拟请求状态码
    if url == "https://www.example.com/page/3":
        status_code = 404
    else:
        status_code = 200
    
    if status_code != 200:
        print("请求失败，停止爬取")
        break
    
    print("成功爬取：", url)

本章小结

1. if语句：根据条件执行不同的代码，有单分支、双分支、多分支三种形式

2. for循环：遍历列表或重复执行指定次数，常用range()函数生成数字序列

3. while循环：条件满足时一直循环，注意避免死循环

4. break：立即终止整个循环

5. continue：跳过当前循环，进入下一次循环

6. enumerate()函数可以同时获取索引和元素

7. 循环嵌套用于遍历多层数据结构

8. 爬虫中最常用的是for循环，用来遍历多个URL或页面

动手练习

1. 用if语句判断一个数是正数、负数还是零

2. 用for循环打印1到100的所有偶数

3. 用while循环计算1到100的和

4. 用break语句在循环中找到第一个能被7整除的数

5. 使用enumerate()遍历一个列表，打印出每个元素的索引和值

---

第六章 异常处理：让程序更健壮（⭐爬虫必备）

6.1 什么是异常？

异常就是程序运行时出现的错误，会导致程序崩溃。比如：

• 除以零错误：10 / 0

• 索引越界错误：访问列表中不存在的索引

• 键不存在错误：访问字典中不存在的键

• 网络连接错误：爬虫时网络不通

没有异常处理的程序：

# 这段代码会崩溃，因为除以零
a = 10
b = 0
result = a / b
print(result)
print("程序继续运行")  # 这行代码永远不会执行

6.2 try-except基本结构

我们可以使用try-except语句来捕获异常，让程序在出现错误时不会崩溃，而是继续运行。

# 格式：
# try:
#     可能会出现异常的代码
# except 异常类型:
#     出现异常时执行的代码

try:
    a = 10
    b = 0
    result = a / b
    print(result)
except ZeroDivisionError:
    print("错误：不能除以零")

print("程序继续运行")  # 这行代码会执行

6.3 捕获多个异常

一个try语句可以对应多个except语句，分别处理不同类型的异常。

try:
    # 可能会出现多种异常的代码
    num = int(input("请输入一个数字："))
    result = 10 / num
    print(f"结果是：{result}")
except ValueError:
    print("错误：请输入有效的数字")
except ZeroDivisionError:
    print("错误：不能除以零")

6.4 捕获所有异常

如果不确定会出现什么类型的异常，可以使用except Exception来捕获所有异常。

try:
    # 可能会出现异常的代码
    f = open("不存在的文件.txt", "r")
    content = f.read()
    f.close()
except Exception as e:
    print(f"出现错误：{e}")

6.5 else和finally子句

• else子句：当try块中没有出现异常时执行

• finally子句：无论是否出现异常都会执行，常用于释放资源

try:
    f = open("test.txt", "r")
    content = f.read()
except Exception as e:
    print(f"读取文件失败：{e}")
else:
    print("文件读取成功")
    print(content)
finally:
    # 无论是否出现异常，都会关闭文件
    if 'f' in locals():
        f.close()
    print("文件已关闭")

6.6 爬虫中常见的异常

import requests

try:
    # 发送网络请求
    response = requests.get("https://www.example.com", timeout=3)
    response.raise_for_status()  # 如果状态码不是200，会抛出异常
    print("请求成功")
except requests.exceptions.ConnectionError:
    print("网络连接错误")
except requests.exceptions.Timeout:
    print("请求超时")
except requests.exceptions.HTTPError as e:
    print(f"HTTP错误：{e}")
except Exception as e:
    print(f"未知错误：{e}")

本章小结

1. 异常是程序运行时出现的错误，会导致程序崩溃

2. 使用try-except语句可以捕获异常，让程序继续运行

3. 可以使用多个except语句分别处理不同类型的异常

4. else子句在没有异常时执行

5. finally子句无论是否出现异常都会执行

6. 爬虫中必须使用异常处理，因为网络环境复杂，经常会出现各种错误

动手练习

1. 编写一个程序，让用户输入两个数字，计算它们的商，使用异常处理捕获除以零和输入非数字的错误

2. 尝试打开一个不存在的文件，使用异常处理捕获错误，并打印友好的提示信息

---

第七章 函数：把重复的代码封装起来

函数就像是一个工具，你可以把一段经常用到的代码封装成一个函数，然后在需要的时候直接调用它，不用每次都重复写同样的代码。

7.1 什么是函数？

生活中的例子：

• 榨汁机是一个工具，你把水果放进去，它就会输出果汁

• 函数也是一个工具，你把数据（参数）传进去，它就会执行一段代码，然后输出结果（返回值）

7.2 如何定义和调用函数？

# 定义函数的格式：
# def 函数名(参数1, 参数2, ...):
#     函数体代码
#     return 返回值

# 定义一个简单的函数，没有参数和返回值
def say_hello():
    print("你好！欢迎学习Python爬虫！")

# 调用函数
say_hello()  # 输出：你好！欢迎学习Python爬虫！
say_hello()  # 可以多次调用

7.3 带参数的函数

参数就是你传给函数的数据，函数可以根据不同的参数执行不同的操作。

# 定义一个带一个参数的函数
def greet(name):
    print("你好，", name, "！")

# 调用函数时传入参数
greet("小明")  # 输出：你好， 小明 ！
greet("小红")  # 输出：你好， 小红 ！

# 定义一个带两个参数的函数
def add(a, b):
    result = a + b
    print(a, "+", b, "=", result)

add(3, 5)  # 输出：3 + 5 = 8
add(10, 20)  # 输出：10 + 20 = 30

# 爬虫场景：定义一个打印爬取信息的函数
def print_crawl_info(url, page):
    print("正在爬取第", page, "页：", url)

print_crawl_info("https://www.example.com/page/1", 1)
print_crawl_info("https://www.example.com/page/2", 2)

7.4 带返回值的函数

return语句用来指定函数的返回值，调用函数时可以把返回值赋值给一个变量。

# 定义一个带返回值的函数
def add(a, b):
    result = a + b
    return result  # 返回计算结果

# 调用函数并接收返回值
sum_result = add(3, 5)
print(sum_result)  # 输出：8

# 定义一个计算平方的函数
def square(x):
    return x * x

print(square(4))  # 输出：16
print(square(5))  # 输出：25

# 爬虫场景：定义一个生成URL的函数
def generate_url(base_url, page):
    full_url = base_url + str(page)
    return full_url

url1 = generate_url("https://www.example.com/page/", 1)
url2 = generate_url("https://www.example.com/page/", 2)
print(url1)  # 输出：https://www.example.com/page/1
print(url2)  # 输出：https://www.example.com/page/2

7.5 函数的好处

1. 代码复用：不用重复写同样的代码

2. 代码更清晰：把复杂的程序分成一个个小函数

3. 便于维护：修改一个函数，所有调用它的地方都会生效

本章小结

1. 函数是封装重复代码的工具

2. 定义函数用def关键字：def 函数名(参数):

3. 调用函数直接写函数名加括号：函数名(参数)

4. 参数是传给函数的数据，返回值是函数输出的结果

5. return语句用来指定函数的返回值

动手练习

1. 定义一个函数，接收两个参数，返回它们的乘积

2. 定义一个函数，接收一个字符串，返回字符串的长度

3. 定义一个函数，接收一个数字，判断它是否是偶数，返回布尔值

---

第八章 文件操作：保存爬取到的数据（⭐爬虫必备）

爬虫的最终目的是获取数据并保存下来，文件操作就是用来把爬取到的数据保存到电脑上的。

8.1 文本文件的读写

打开文件

使用open()函数打开文件，格式：open(文件路径, 打开模式)

常用打开模式：

• r：只读模式（默认），文件必须存在

• w：写入模式，如果文件不存在会创建，如果存在会覆盖原有内容

• a：追加模式，如果文件不存在会创建，如果存在会在末尾追加内容

• r+：读写模式

读取文件

# 方式1：一次性读取所有内容
f = open("test.txt", "r", encoding="utf-8")
content = f.read()
print(content)
f.close()  # 一定要记得关闭文件

# 方式2：逐行读取
f = open("test.txt", "r", encoding="utf-8")
for line in f:
    print(line.strip())  # strip()去除换行符
f.close()

# 方式3：读取所有行到列表
f = open("test.txt", "r", encoding="utf-8")
lines = f.readlines()
print(lines)
f.close()

写入文件

# 写入模式：覆盖原有内容
f = open("output.txt", "w", encoding="utf-8")
f.write("第一行内容\n")
f.write("第二行内容\n")
f.close()

# 追加模式：在末尾添加内容
f = open("output.txt", "a", encoding="utf-8")
f.write("第三行内容\n")
f.close()

8.2 with语句：自动关闭文件

使用with语句可以自动关闭文件，不需要手动调用close()方法，避免资源泄漏。

# 推荐使用with语句
with open("test.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)
# 离开with块后，文件会自动关闭

# 写入文件
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("使用with语句写入的内容\n")

8.3 CSV文件的读写

CSV是一种逗号分隔的文本文件格式，非常适合存储表格数据，是爬虫保存数据最常用的格式之一。

写入CSV文件

import csv

# 要保存的数据
data = [
    ["标题", "作者", "时间"],
    ["Python爬虫入门", "张三", "2024-01-01"],
    ["数据分析实战", "李四", "2024-01-02"],
    ["人工智能基础", "王五", "2024-01-03"]
]

# 写入CSV文件
with open("articles.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerows(data)

读取CSV文件

import csv

with open("articles.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

8.4 JSON文件的读写

JSON是一种轻量级的数据交换格式，常用于API返回数据，也是爬虫保存数据的常用格式。

写入JSON文件

import json

# 要保存的数据
article = {
    "title": "Python爬虫入门教程",
    "author": "张三",
    "time": "2024-01-01",
    "url": "https://www.example.com/article/1"
}

# 写入JSON文件
with open("article.json", "w", encoding="utf-8") as f:
    json.dump(article, f, ensure_ascii=False, indent=4)

读取JSON文件

import json

with open("article.json", "r", encoding="utf-8") as f:
    article = json.load(f)
    print(article["title"])
    print(article["author"])

8.5 爬虫场景：保存爬取到的数据

import csv

# 模拟爬取到的文章数据
articles = [
    {
        "title": "Python爬虫入门",
        "author": "张三",
        "time": "2024-01-01"
    },
    {
        "title": "数据分析实战",
        "author": "李四",
        "time": "2024-01-02"
    },
    {
        "title": "人工智能基础",
        "author": "王五",
        "time": "2024-01-03"
    }
]

# 保存到CSV文件
with open("crawled_articles.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["title", "author", "time"])
    writer.writeheader()  # 写入表头
    writer.writerows(articles)  # 写入所有数据

print("数据保存成功！")

本章小结

1. 使用open()函数打开文件，需要指定文件路径和打开模式

2. 常用打开模式：r（只读）、w（写入）、a（追加）

3. 使用with语句可以自动关闭文件，推荐使用

4. CSV文件适合存储表格数据，使用csv模块读写

5. JSON文件适合存储结构化数据，使用json模块读写

6. 爬虫中最常用的是CSV和JSON格式来保存数据

动手练习

1. 创建一个文本文件，写入你的姓名、年龄和爱好

2. 读取这个文本文件的内容并打印出来

3. 创建一个包含3个学生信息的列表，每个学生信息是一个字典（包含姓名、年龄、成绩），将其保存为CSV文件

---

第九章 模块与包：使用别人写好的代码（⭐爬虫必备）

9.1 什么是模块和包？

• 模块：就是一个.py文件，里面包含了相关的函数、变量和类

• 包：就是一个包含多个模块的文件夹，里面有一个__init__.py文件

Python之所以强大，就是因为有海量的第三方模块可以使用，我们不需要从零开始写所有代码。

9.2 导入模块的方式

# 方式1：导入整个模块
import math
print(math.pi)  # 输出：3.141592653589793
print(math.sqrt(16))  # 输出：4.0

# 方式2：从模块中导入指定的函数或变量
from math import pi, sqrt
print(pi)  # 输出：3.141592653589793
print(sqrt(16))  # 输出：4.0

# 方式3：从模块中导入所有内容（不推荐）
from math import *
print(pi)
print(sqrt(16))

# 方式4：给模块起别名
import math as m
print(m.pi)
print(m.sqrt(16))

9.3 爬虫常用内置模块

1. time模块：时间相关操作

import time

# 获取当前时间戳（从1970年1月1日到现在的秒数）
print(time.time())

# 暂停程序执行指定秒数（爬虫中用来加延时，避免被封IP）
print("开始等待")
time.sleep(2)  # 暂停2秒
print("等待结束")

# 格式化时间
print(time.strftime("%Y-%m-%d %H:%M:%S"))  # 输出：2024-01-01 12:00:00

2. random模块：生成随机数

import random

# 生成0到1之间的随机浮点数
print(random.random())

# 生成指定范围内的随机整数
print(random.randint(1, 10))  # 生成1到10之间的整数

# 从列表中随机选择一个元素
fruits = ["苹果", "香蕉", "橙子"]
print(random.choice(fruits))

# 爬虫场景：生成随机延时，模拟人类行为
delay = random.uniform(1, 3)  # 生成1到3之间的随机浮点数
print(f"等待{delay:.2f}秒")
time.sleep(delay)

3. os模块：文件和目录操作

import os

# 获取当前工作目录
print(os.getcwd())

# 创建目录
os.mkdir("data")  # 创建单个目录
os.makedirs("data/articles", exist_ok=True)  # 创建多级目录

# 列出目录中的文件
print(os.listdir("."))  # 列出当前目录中的所有文件和目录

# 判断文件或目录是否存在
print(os.path.exists("data"))  # 输出：True
print(os.path.isfile("test.txt"))  # 判断是否是文件
print(os.path.isdir("data"))  # 判断是否是目录

# 爬虫场景：创建保存数据的文件夹
save_dir = "crawled_data"
if not os.path.exists(save_dir):
    os.makedirs(save_dir)

本章小结

1. 模块是一个.py文件，包是包含多个模块的文件夹

2. 有四种导入模块的方式，推荐使用前两种

3. time模块用于时间操作，time.sleep()在爬虫中用来加延时

4. random模块用于生成随机数，模拟人类行为

5. os模块用于文件和目录操作，创建保存数据的文件夹

动手练习

1. 导入time模块，打印当前时间

2. 使用time.sleep()让程序暂停3秒

3. 导入random模块，生成1到100之间的随机整数

4. 使用os模块在当前目录下创建一个名为my_data的文件夹

---

爬虫基础必备知识点汇总表

知识点	核心内容	爬虫中的用途
print()函数	在屏幕上打印输出内容	打印爬取进度、结果和错误信息
变量	存储数据的容器	存储URL、爬取到的标题、内容等
字符串	文本内容	存储URL、HTML代码、爬取到的文本
字符串高级操作	切片、strip()、replace()、split()、f-string	处理和清洗爬取到的文本数据
列表	存储多个数据的有序容器	存储多个URL、多个文章标题
列表高级操作	切片、append()、extend()、列表推导式	批量处理爬取到的数据
字典	存储键值对的容器	存储单条文章信息（标题、作者、时间等）
字典高级操作	get()、items()、嵌套字典	安全获取数据、遍历数据
比较运算符	比较两个值的大小	判断状态码是否为200、判断是否有下一页
逻辑运算符	组合多个条件	组合多个判断条件
if语句	根据条件执行不同代码	根据状态码执行不同的处理逻辑
for循环	重复执行指定次数	遍历多个URL、爬取多个页面
异常处理	捕获程序运行时错误	处理网络错误、数据解析错误等
函数	封装重复代码	封装请求网页、解析数据等重复操作
文件操作	读写文本、CSV、JSON文件	保存爬取到的数据
模块与包	导入和使用第三方库	使用requests、Xpath等爬虫库
pip包管理	安装和管理第三方库	安装爬虫所需的各种工具库
PyCharm	专业代码编辑器	编写、运行和调试爬虫程序

---

学习建议

1. 一定要动手写代码：编程是一门实践技能，光看是学不会的，每个例子都要自己敲一遍运行

2. 遇到错误不要怕：报错是编程的常态，仔细看错误信息，它会告诉你哪里出了问题

3. 循序渐进：按照教程的顺序学习，不要跳着学，基础打牢了后面学爬虫才会轻松

4. 多做练习：每个章节后的动手练习一定要完成，巩固所学知识

5. 学完本教程后：你就可以开始学习爬虫的核心内容了，比如请求库requests、解析库Xpath等