文章目录
- [Python 入门基础教程：爬虫前置专用版](#Python 入门基础教程：爬虫前置专用版)
- [第一章 认识Python并开启编程之旅](#第一章 认识Python并开启编程之旅)
- [第二章 变量：给数据起个名字](#第二章 变量：给数据起个名字)
- [第三章 数据类型：不同种类的数据](#第三章 数据类型：不同种类的数据)
-
- [3.1 整数(int)：没有小数点的数字](#3.1 整数(int)：没有小数点的数字)
- [3.2 浮点数(float)：有小数点的数字](#3.2 浮点数(float)：有小数点的数字)
- [3.3 字符串(str)：文本内容](#3.3 字符串(str)：文本内容)
-
- 字符串的基本操作
- 字符串高级操作（⭐爬虫必备）
-
- [1. 字符串切片：截取子串](#1. 字符串切片：截取子串)
- [2. 字符串常用方法](#2. 字符串常用方法)
- [3. 字符串格式化](#3. 字符串格式化)
- [4. 原始字符串](#4. 原始字符串)
- [3.4 布尔值(bool)：只有两个值](#3.4 布尔值(bool)：只有两个值)
- [3.5 列表(list)：存储多个数据的容器](#3.5 列表(list)：存储多个数据的容器)
-
- 列表的基本操作
- 列表高级操作（⭐爬虫必备）
-
- [1. 列表切片](#1. 列表切片)
- [2. 列表常用方法](#2. 列表常用方法)
- [3. 列表推导式](#3. 列表推导式)
- [3.6 字典(dict)：存储键值对的容器](#3.6 字典(dict)：存储键值对的容器)
-
- 字典的基本操作
- 字典高级操作（⭐爬虫必备）
-
- [1. 字典常用方法](#1. 字典常用方法)
- [2. 遍历字典](#2. 遍历字典)
- [3. 嵌套字典](#3. 嵌套字典)
- [3.7 其他数据类型（简要了解）](#3.7 其他数据类型（简要了解）)
- 本章小结
- 动手练习
- [第四章 运算符：对数据进行操作](#第四章 运算符：对数据进行操作)
- [第五章 控制结构：让程序有逻辑地运行](#第五章 控制结构：让程序有逻辑地运行)
-
- [5.1 if条件判断语句：根据条件做选择](#5.1 if条件判断语句：根据条件做选择)
-
- [5.1.1 单分支if语句](#5.1.1 单分支if语句)
- [5.1.2 双分支if-else语句](#5.1.2 双分支if-else语句)
- [5.1.3 多分支if-elif-else语句](#5.1.3 多分支if-elif-else语句)
- [5.2 for循环语句：重复执行指定次数](#5.2 for循环语句：重复执行指定次数)
-
- [5.2.1 遍历列表](#5.2.1 遍历列表)
- [5.2.2 使用range()函数生成数字序列](#5.2.2 使用range()函数生成数字序列)
- [5.2.3 使用enumerate()同时获取索引和元素](#5.2.3 使用enumerate()同时获取索引和元素)
- [5.2.4 循环嵌套](#5.2.4 循环嵌套)
- [5.3 while循环语句：条件满足时一直循环](#5.3 while循环语句：条件满足时一直循环)
- [5.4 break和continue语句：控制循环](#5.4 break和continue语句：控制循环)
- 本章小结
- 动手练习
- [第六章 异常处理：让程序更健壮（⭐爬虫必备）](#第六章 异常处理：让程序更健壮（⭐爬虫必备）)
- [第七章 函数：把重复的代码封装起来](#第七章 函数：把重复的代码封装起来)
- [第八章 文件操作：保存爬取到的数据（⭐爬虫必备）](#第八章 文件操作：保存爬取到的数据（⭐爬虫必备）)
- [第九章 模块与包：使用别人写好的代码（⭐爬虫必备）](#第九章 模块与包：使用别人写好的代码（⭐爬虫必备）)
- 爬虫基础必备知识点汇总表
- 学习建议
Python 入门基础教程：爬虫前置专用版
专为完全不懂编程的零基础小白打造，内容简单、知识点全面，结合实操练习学完即可看懂爬虫基础代码
第一章 认识Python并开启编程之旅
1.1 Python是什么？为什么学Python？
Python就像是一个超级翻译官，它能把我们人类能看懂的简单指令，翻译成电脑能执行的复杂操作。
为什么学Python？
-
最简单：语法像写英语句子一样，是所有编程语言中最容易上手的
-
最强大：能做爬虫、数据分析、人工智能、自动化办公等几乎所有事情
-
最适合爬虫：全世界90%以上的爬虫都是用Python写的，有大量现成的工具可以直接用
1.2 如何安装Python？
2025年最新版Python安装&PyCharm安装教程 （图文超级详细）_python下载安装教程-CSDN博客]
Windows系统安装步骤
-
打开浏览器，访问Python官网：https://www.python.org/downloads/
-
点击黄色的"Download Python 3.12.0"按钮（版本号可能不同，下载最新版即可）
-
下载完成后双击安装包
-
非常重要：勾选安装界面最下方的"Add Python 3.12 to PATH"
-
点击"Install Now"，等待安装完成
-
安装成功后，按键盘上的
Win+R键，输入cmd，回车打开命令提示符 -
输入
python --version，如果显示类似Python 3.12.0的信息，说明安装成功
验证安装：运行第一个Python程序
-
在电脑桌面新建一个文本文档
-
把文件名改为
hello.py（注意要把原来的.txt后缀也改掉） -
右键点击这个文件，选择"用记事本打开"
-
输入以下代码：
Python
# 这是我的第一个Python程序
print("你好，Python！我要开始学爬虫啦！")-
保存文件并关闭记事本
-
在文件所在的文件夹地址栏输入
cmd，回车打开命令提示符 -
输入
python hello.py，回车运行 -
如果看到屏幕上显示
你好，Python！我要开始学爬虫啦！，恭喜你！你已经成功运行了第一个Python程序！
1.3 什么是代码？什么是注释？
-
代码：就是我们写给Python翻译官看的指令，每一行代码都是一个操作
-
注释：是写给我们自己看的说明文字，Python会自动忽略注释
-
单行注释用
#开头，多行注释用三个引号"""包裹
Python
# 这是单行注释，Python不会执行这一行
print("这是代码，Python会执行这一行")
"""
这是多行注释
可以写很多行
Python同样不会执行
"""1.4 pip包管理工具（⭐爬虫必备）
什么是pip？
pip是Python的官方包管理工具 ，就像是Python的"应用商店"。我们可以通过pip一键安装全世界开发者分享的各种Python工具库，比如爬虫必备的requests、Xpath等。
验证pip是否安装成功
打开命令提示符，输入：
Bash
pip --version如果显示类似pip 24.0 from ...的信息，说明pip已经安装成功。
pip常用命令
Bash
# 安装第三方库
pip install 库名
# 示例：安装爬虫必备的requests库
pip install requests
# 卸载第三方库
pip uninstall 库名
# 查看已安装的所有库
pip list
# 查看某个库的详细信息
pip show 库名配置国内镜像源（解决下载慢问题）
默认的pip源在国外，下载速度很慢。我们可以配置国内镜像源，让下载速度提升10倍以上。
临时使用国内源：
Bash
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安装步骤
-
打开浏览器，访问PyCharm官网：https://www.jetbrains.com/pycharm/download/
-
向下滚动找到"Community"（社区版），点击"Download"下载
-
下载完成后双击安装包，一直点击"Next"即可
-
安装完成后，勾选"Run PyCharm Community Edition"，点击"Finish"
PyCharm基本使用
-
第一次打开PyCharm，选择"Do not import settings"，点击"OK"
-
选择界面主题，点击"Next"
-
点击"Create New Project"创建新项目
-
在"Location"处选择项目保存位置，给项目起个名字（如
python_spider） -
确保"Python Interpreter"已经选择了我们之前安装的Python版本
-
点击"Create"创建项目
在PyCharm中运行Python程序
-
右键点击左侧项目名称，选择"New" -> "Python File"
-
给文件起个名字（如
hello.py），回车 -
在编辑区输入代码：
Python
print("你好，PyCharm！")-
右键点击编辑区空白处，选择"Run 'hello'"
-
下方控制台会显示运行结果：
你好，PyCharm！
PyCharm常用功能
-
代码补全 ：输入代码时会自动提示，按
Tab键可以快速补全 -
语法检查：错误的代码会用红色波浪线标出
-
一键运行：点击右上角绿色三角形按钮即可运行当前文件
-
终端：点击底部"Terminal"标签，可以直接在PyCharm中使用命令行
本章小结
-
Python是一个能把人类指令翻译成电脑操作的翻译官
-
安装Python时一定要勾选"Add Python to PATH"
-
Python程序文件的后缀是
.py -
用
python 文件名.py命令运行程序 -
print()函数的作用是在屏幕上打印输出内容 -
注释是写给人看的，用
#或"""表示 -
pip是Python的包管理工具，用来安装第三方库
-
PyCharm是专业的Python代码编辑器，能大幅提升编程效率
动手练习
-
新建一个
my_first_program.py文件 -
用
print()函数打印出你的名字和"我要学会爬虫！" -
给代码添加至少两行注释，说明这个程序的作用
-
用pip安装
requests库 -
在PyCharm中创建一个新项目，并运行一个简单的程序
第二章 变量：给数据起个名字
2.1 什么是变量？
变量就像是一个贴了标签的盒子，我们可以把数据放进盒子里，然后通过标签来找到这个数据。
生活中的例子：
-
你有一个盒子，贴上"零花钱"的标签，里面放了100元
-
后来你又放了50元进去，现在盒子里有150元
-
你随时可以通过"零花钱"这个标签，知道盒子里有多少钱
在Python中，我们这样定义变量：
Python
# 变量名 = 数据
pocket_money = 100 # 定义一个叫pocket_money的变量，值为100
print(pocket_money) # 输出：100
pocket_money = 150 # 修改变量的值
print(pocket_money) # 输出：1502.2 变量的命名规则
变量名不是随便起的，必须遵守以下规则：
-
只能包含字母、数字和下划线
-
不能以数字开头
-
不能使用Python的关键字（如
if、for、while等） -
区分大小写（
name和Name是两个不同的变量）
好的变量名习惯：
-
见名知意：用
article_title而不是a -
多个单词用下划线连接：
user_name、page_url -
全部小写
Python
# 正确的变量名
age = 20
user_name = "小明"
page_url = "https://www.example.com"
# 错误的变量名（不要这么写）
123abc = 100 # 不能以数字开头
user-name = "小红" # 不能包含减号
if = "条件" # 不能使用关键字2.3 变量的赋值
-
赋值符号是
=，不是数学中的等于号 -
=左边是变量名，右边是要存储的数据 -
可以同时给多个变量赋值
Python
# 单个变量赋值
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"本章小结
-
变量是贴了标签的盒子，用来存储数据
-
变量定义格式：
变量名 = 数据 -
变量名只能包含字母、数字和下划线，不能以数字开头
-
变量的值可以随时修改
-
好的变量名要见名知意
动手练习
-
定义三个变量，分别存储你的姓名、年龄和爱好
-
用
print()函数打印出这三个变量的值 -
修改年龄变量的值，然后再次打印
第三章 数据类型：不同种类的数据
Python中有很多种数据类型，就像生活中有不同种类的物品一样。我们重点学习爬虫中最常用的6种数据类型。
3.1 整数(int)：没有小数点的数字
整数就是我们平时说的正整数、负整数和0。
Python
# 整数类型
age = 25
page_number = 10
status_code = 200 # 爬虫中常用的状态码，200表示请求成功
negative_number = -5
print(type(age)) # 输出：<class 'int'>，type()函数可以查看变量的类型3.2 浮点数(float)：有小数点的数字
浮点数就是带小数点的数字。
Python
# 浮点数类型
price = 99.9
pi = 3.14159
temperature = 25.5
print(type(price)) # 输出：<class 'float'>3.3 字符串(str)：文本内容
字符串就是用引号括起来的文本内容，可以是单引号'，也可以是双引号"，效果一样。
Python
# 字符串类型
name = "小明"
message = '我要学爬虫'
url = "https://www.baidu.com" # 爬虫中最常用的字符串，存储网址
# 多行字符串用三个引号
long_text = """这是第一行
这是第二行
这是第三行"""
print(type(url)) # 输出：<class 'str'>字符串的基本操作
Python
# 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
Python
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.com2. 字符串常用方法
Python
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+推荐，最简单好用）：
Python
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等）。
Python
# 普通字符串中的\会被当作转义字符
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（假），通常用来表示条件是否成立。
Python
# 布尔值类型
is_success = True
is_error = False
print(type(is_success)) # 输出：<class 'bool'>
# 爬虫场景：判断是否爬取成功
status_code = 200
is_success = (status_code == 200)
print(is_success) # 输出：True3.5 列表(list)：存储多个数据的容器
列表就像是一个大箱子，可以放很多不同类型的数据，而且可以随时添加、删除和修改里面的内容。
列表用方括号[]表示，里面的元素用逗号分隔。
Python
# 列表类型
numbers = [1, 2, 3, 4, 5]
names = ["小明", "小红", "小刚"]
mixed = [1, "hello", 3.14, True]
print(type(numbers)) # 输出：<class 'list'>列表的基本操作
Python
# 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. 列表切片
和字符串切片一样，列表也可以通过切片来获取子列表。
Python
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. 列表常用方法
Python
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. 列表推导式
列表推导式是一种快速生成列表的方式，可以用一行代码代替多行循环。
Python
# 普通方式生成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)：存储键值对的容器
字典就像是一本通讯录，你可以通过"姓名"（键）找到对应的"电话号码"（值）。
字典用大括号{}表示，每个元素都是一个"键: 值"对，键和值之间用冒号分隔，元素之间用逗号分隔。
Python
# 字典类型
person = {
"name": "小明",
"age": 20,
"hobby": "编程"
}
print(type(person)) # 输出：<class 'dict'>字典的基本操作
Python
# 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. 字典常用方法
Python
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. 遍历字典
Python
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. 嵌套字典
字典的值也可以是另一个字典，这就是嵌套字典，常用于存储复杂的数据结构。
Python
# 爬虫场景：存储包含多个文章的网站信息
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) ：存储不重复的元素，用大括号
{}表示 -
类与对象：面向对象编程的内容，爬虫入门阶段不需要掌握
本章小结
-
整数(int)：没有小数点的数字
-
浮点数(float)：有小数点的数字
-
字符串(str)：用引号括起来的文本内容
-
布尔值(bool)：只有True和False两个值
-
列表(list)：用[]表示，存储多个数据，可以修改
-
字典(dict)：用{}表示，存储键值对，通过键访问值
-
爬虫中最常用的数据类型是：字符串、列表、字典
-
掌握字符串、列表、字典的高级操作是爬虫数据处理的基础
动手练习
-
创建一个字符串"https://www.example.com/article/123.html"，使用切片提取出"123"
-
创建一个列表，存储你最喜欢的5部电影名称，使用切片获取前3部
-
创建一个字典，存储你的个人信息，使用get()方法获取"职业"字段，默认值为"学生"
-
使用列表推导式生成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 |
Python
# 算术运算符示例
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 |
Python
# 赋值运算符示例
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) # 输出：244.3 比较运算符：比较两个值的大小
比较运算符的结果是布尔值（True或False）。
| 运算符 | 说明 | 例子 | 结果 |
|---|---|---|---|
| == | 等于 | 5 == 3 | False |
| != | 不等于 | 5 != 3 | True |
| > | 大于 | 5 > 3 | True |
| < | 小于 | 5 < 3 | False |
| >= | 大于等于 | 5 >= 3 | True |
| <= | 小于等于 | 5 <= 3 | False |
Python
# 比较运算符示例
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) # 输出：False4.4 逻辑运算符：组合多个条件
逻辑运算符用来连接多个比较表达式，结果也是布尔值。
| 运算符 | 说明 | 例子 | 结果 |
|---|---|---|---|
| and | 与（两个都为True，结果才为True） | True and False | False |
| or | 或（只要有一个为True，结果就为True） | True or False | True |
| not | 非（取反） | not True | False |
Python
# 逻辑运算符示例
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都是正常状态码）本章小结
-
算术运算符：+、-、*、/、//、%、**
-
赋值运算符：=、+=、-=、*=、/=
-
比较运算符：==、!=、>、<、>=、<=，结果是布尔值
-
逻辑运算符：and、or、not，用来组合多个条件
-
爬虫中最常用的是比较运算符和逻辑运算符，用来做条件判断
动手练习
-
计算100除以7的商和余数
-
定义两个变量a=15，b=25，比较它们的大小并打印结果
-
判断一个数是否在10到20之间（包括10和20）
第五章 控制结构：让程序有逻辑地运行
控制结构可以让程序根据不同的条件执行不同的代码，或者重复执行某段代码。
5.1 if条件判断语句：根据条件做选择
if语句就像是生活中的"如果...那么..."，如果条件成立，就执行某段代码。
5.1.1 单分支if语句
Python
# 格式：
# if 条件:
# 条件成立时执行的代码
age = 18
if age >= 18:
print("你已经成年了")
# 爬虫场景：如果状态码是200，就打印爬取成功
status_code = 200
if status_code == 200:
print("网页请求成功，可以开始爬取数据")5.1.2 双分支if-else语句
Python
# 格式：
# 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语句
Python
# 格式：
# 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 遍历列表
Python
# 格式：
# 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()函数可以生成一个数字序列，常用于循环指定次数。
Python
# 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()同时获取索引和元素
Python
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 循环嵌套
循环嵌套就是在一个循环里面再写一个循环，常用于遍历多层数据结构。
Python
# 打印九九乘法表
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循环就像是生活中的"只要...就一直..."，只要条件成立，就一直执行循环体代码。
Python
# 格式：
# 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：跳过当前循环的剩余代码，直接进入下一次循环
Python
# 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)本章小结
-
if语句：根据条件执行不同的代码，有单分支、双分支、多分支三种形式
-
for循环：遍历列表或重复执行指定次数，常用range()函数生成数字序列
-
while循环：条件满足时一直循环，注意避免死循环
-
break：立即终止整个循环
-
continue：跳过当前循环，进入下一次循环
-
enumerate()函数可以同时获取索引和元素
-
循环嵌套用于遍历多层数据结构
-
爬虫中最常用的是for循环，用来遍历多个URL或页面
动手练习
-
用if语句判断一个数是正数、负数还是零
-
用for循环打印1到100的所有偶数
-
用while循环计算1到100的和
-
用break语句在循环中找到第一个能被7整除的数
-
使用enumerate()遍历一个列表，打印出每个元素的索引和值
第六章 异常处理：让程序更健壮（⭐爬虫必备）
6.1 什么是异常？
异常就是程序运行时出现的错误，会导致程序崩溃。比如：
-
除以零错误：
10 / 0 -
索引越界错误：访问列表中不存在的索引
-
键不存在错误：访问字典中不存在的键
-
网络连接错误：爬虫时网络不通
没有异常处理的程序：
Python
# 这段代码会崩溃，因为除以零
a = 10
b = 0
result = a / b
print(result)
print("程序继续运行") # 这行代码永远不会执行6.2 try-except基本结构
我们可以使用try-except语句来捕获异常，让程序在出现错误时不会崩溃，而是继续运行。
Python
# 格式：
# try:
# 可能会出现异常的代码
# except 异常类型:
# 出现异常时执行的代码
try:
a = 10
b = 0
result = a / b
print(result)
except ZeroDivisionError:
print("错误：不能除以零")
print("程序继续运行") # 这行代码会执行6.3 捕获多个异常
一个try语句可以对应多个except语句，分别处理不同类型的异常。
Python
try:
# 可能会出现多种异常的代码
num = int(input("请输入一个数字："))
result = 10 / num
print(f"结果是：{result}")
except ValueError:
print("错误：请输入有效的数字")
except ZeroDivisionError:
print("错误：不能除以零")6.4 捕获所有异常
如果不确定会出现什么类型的异常，可以使用except Exception来捕获所有异常。
Python
try:
# 可能会出现异常的代码
f = open("不存在的文件.txt", "r")
content = f.read()
f.close()
except Exception as e:
print(f"出现错误：{e}")6.5 else和finally子句
-
else子句：当try块中没有出现异常时执行 -
finally子句：无论是否出现异常都会执行，常用于释放资源
Python
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 爬虫中常见的异常
Python
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}")本章小结
-
异常是程序运行时出现的错误，会导致程序崩溃
-
使用
try-except语句可以捕获异常，让程序继续运行 -
可以使用多个
except语句分别处理不同类型的异常 -
else子句在没有异常时执行 -
finally子句无论是否出现异常都会执行 -
爬虫中必须使用异常处理，因为网络环境复杂，经常会出现各种错误
动手练习
-
编写一个程序，让用户输入两个数字，计算它们的商，使用异常处理捕获除以零和输入非数字的错误
-
尝试打开一个不存在的文件，使用异常处理捕获错误，并打印友好的提示信息
第七章 函数：把重复的代码封装起来
函数就像是一个工具，你可以把一段经常用到的代码封装成一个函数，然后在需要的时候直接调用它，不用每次都重复写同样的代码。
7.1 什么是函数？
生活中的例子：
-
榨汁机是一个工具，你把水果放进去，它就会输出果汁
-
函数也是一个工具，你把数据（参数）传进去，它就会执行一段代码，然后输出结果（返回值）
7.2 如何定义和调用函数？
Python
# 定义函数的格式：
# def 函数名(参数1, 参数2, ...):
# 函数体代码
# return 返回值
# 定义一个简单的函数，没有参数和返回值
def say_hello():
print("你好！欢迎学习Python爬虫！")
# 调用函数
say_hello() # 输出：你好！欢迎学习Python爬虫！
say_hello() # 可以多次调用7.3 带参数的函数
参数就是你传给函数的数据，函数可以根据不同的参数执行不同的操作。
Python
# 定义一个带一个参数的函数
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语句用来指定函数的返回值，调用函数时可以把返回值赋值给一个变量。
Python
# 定义一个带返回值的函数
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/27.5 函数的好处
-
代码复用：不用重复写同样的代码
-
代码更清晰：把复杂的程序分成一个个小函数
-
便于维护：修改一个函数，所有调用它的地方都会生效
本章小结
-
函数是封装重复代码的工具
-
定义函数用def关键字：
def 函数名(参数): -
调用函数直接写函数名加括号：
函数名(参数) -
参数是传给函数的数据，返回值是函数输出的结果
-
return语句用来指定函数的返回值
动手练习
-
定义一个函数，接收两个参数，返回它们的乘积
-
定义一个函数，接收一个字符串，返回字符串的长度
-
定义一个函数，接收一个数字，判断它是否是偶数，返回布尔值
第八章 文件操作：保存爬取到的数据（⭐爬虫必备）
爬虫的最终目的是获取数据并保存下来，文件操作就是用来把爬取到的数据保存到电脑上的。
8.1 文本文件的读写
打开文件
使用open()函数打开文件，格式：open(文件路径, 打开模式)
常用打开模式：
-
r：只读模式（默认），文件必须存在 -
w：写入模式，如果文件不存在会创建，如果存在会覆盖原有内容 -
a：追加模式，如果文件不存在会创建，如果存在会在末尾追加内容 -
r+：读写模式
读取文件
Python
# 方式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()写入文件
Python
# 写入模式：覆盖原有内容
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()方法，避免资源泄漏。
Python
# 推荐使用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文件
Python
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文件
Python
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文件
Python
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文件
Python
import json
with open("article.json", "r", encoding="utf-8") as f:
article = json.load(f)
print(article["title"])
print(article["author"])8.5 爬虫场景：保存爬取到的数据
Python
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("数据保存成功！")本章小结
-
使用
open()函数打开文件，需要指定文件路径和打开模式 -
常用打开模式：
r（只读）、w（写入）、a（追加） -
使用
with语句可以自动关闭文件，推荐使用 -
CSV文件适合存储表格数据，使用
csv模块读写 -
JSON文件适合存储结构化数据，使用
json模块读写 -
爬虫中最常用的是CSV和JSON格式来保存数据
动手练习
-
创建一个文本文件，写入你的姓名、年龄和爱好
-
读取这个文本文件的内容并打印出来
-
创建一个包含3个学生信息的列表，每个学生信息是一个字典（包含姓名、年龄、成绩），将其保存为CSV文件
第九章 模块与包：使用别人写好的代码（⭐爬虫必备）
9.1 什么是模块和包？
-
模块 ：就是一个
.py文件，里面包含了相关的函数、变量和类 -
包 ：就是一个包含多个模块的文件夹，里面有一个
__init__.py文件
Python之所以强大，就是因为有海量的第三方模块可以使用，我们不需要从零开始写所有代码。
9.2 导入模块的方式
Python
# 方式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模块：时间相关操作
Python
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:002. random模块：生成随机数
Python
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模块：文件和目录操作
Python
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)本章小结
-
模块是一个
.py文件，包是包含多个模块的文件夹 -
有四种导入模块的方式，推荐使用前两种
-
time模块用于时间操作，time.sleep()在爬虫中用来加延时 -
random模块用于生成随机数，模拟人类行为 -
os模块用于文件和目录操作，创建保存数据的文件夹
动手练习
-
导入
time模块，打印当前时间 -
使用
time.sleep()让程序暂停3秒 -
导入
random模块，生成1到100之间的随机整数 -
使用
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 | 专业代码编辑器 | 编写、运行和调试爬虫程序 |
学习建议
-
一定要动手写代码：编程是一门实践技能，光看是学不会的，每个例子都要自己敲一遍运行
-
遇到错误不要怕：报错是编程的常态，仔细看错误信息，它会告诉你哪里出了问题
-
循序渐进：按照教程的顺序学习，不要跳着学，基础打牢了后面学爬虫才会轻松
-
多做练习：每个章节后的动手练习一定要完成，巩固所学知识
-
学完本教程后 ：你就可以开始学习爬虫的核心内容了，比如请求库
requests、解析库Xpath等