Python爬虫学习前传 —— Python从安装到学会一站式服务

早上好啊，大佬们。我们的python基础内容的这一篇终于写好了，啪唧啪唧啪唧......

说实话，这一篇确实写了很久，一方面是在忙其他几个专栏的内容，再加上生活学业上的事儿，确实精力有限，另一方面，是这一篇的内容确实很多很难写，而且爬虫的内容确实是现学的，除了这一篇Python的基础内容，后续的内容还是在学习当中，不能写完第一篇之后停好久，所以第一篇就多准备了一些时间。

所以大佬们见谅，原谅小白兔学习能力弱，要慢慢学爬虫的内容，这个专栏的更新可能相较其他专栏的更新会慢很多。

前言

Python爬虫是Python语法的一个应用领域，掌握Python的基本语法是编写爬虫的前提。同时，还需要了解和使用一些专门的库和框架来提高爬虫的效率和功能。

所以，总而言之，言而总之，要用Python写爬虫就需要先学会Python的基础语法。效仿浙里办理念------只用跑一次，我们只看这一篇，让大佬们入门Python。

一、简介

为了避免大伙想用Python爬虫但是又没有学过Python，我决定先出这么一篇博客，先来粗浅的讲讲我学的Python，纯新手向，大佬勿喷，不喜直接过。在写这篇博客的时候，我也还没有了解过爬虫是怎么实现的，后续的文章都是我现学现卖，大家勿喷，有错误也希望飘过的大佬能帮忙解决一下。

上面是我能想到的一些关于Python的内容，然后在本篇 里面只会涉及基础入门部分 的内容，一方面相信大家其实只是想写一些简单的爬虫去获取自己想要的内容，基本不会使用到高级编程部分的内容，所以学习那方面的内容远水解不了近渴，实在是划不来，另一方面是小白兔在高级编程方面也没有学习，可能等过一段时间会去学习这方面，如果大家想和小白兔一起学习这方面的内容，咱们到时候再出一个专栏来讲这些东西。

在本篇文章中，我选用了与C语言进行类比的方式来讲解Python的语法，但是为了让没有学过C语言直接学习Python的朋友也能够看懂，我努力多写了一些示例，让没有学过C语言直接学习Python的朋友也能够看懂。

二、编译环境下载

咱就是说，在学习任何一个语言之前都需要先下载它的编译环境，不然做啥都是捉瞎，所以在学习之前，咱们先讲一下怎么下载Python的编译环境，以及Pycharm的下载，官方提供了社区版和专业版，大家自行选择，然后在下面我们所需要下载的所有东西都已经通过网盘提供了。

夸克网盘链接：

链接：https://pan.quark.cn/s/3b873333e17d

提取码：txj3

1.Python环境下载

可以直接在Python的官网直接下载，然后本篇文末也会有网盘链接，可以直接使用那个。

在下载的时候比较重要的是，添加Python路径，最好是直接在下载的时候就直接勾选，也就是点击安装后下图所示的地方：

然后这样就安装好了。

可以win+R打开中断输入python，它显示内容就是安装成功，并且路径是对的，然后这边会显示python版本。

如果你非常倒霉催的没有添加这个路径，那就只能说，在系统变量里面去添加这个。

到这里，Python的环境变量就配置好了，然后就是下载Pycharm了。

2.Pycharm优势

1. PyCharm 提供了代码补全、代码片段、智能代码导航等高级编辑功能，使得代码编写更加高效。

2. PyCharm 能够实时检查代码中的错误和警告，提供快速修复建议，帮助开发者及时发现并修正问题。

3. PyCharm 支持多种项目视图，可以清晰地组织和管理项目文件，方便开发者快速定位文件和代码。

4. PyCharm 内置了强大的调试器和测试工具，支持图形化界面进行断点设置、变量查看和测试运行，简化了调试和测试过程。

5. PyCharm 集成了 Git、SVN 等版本控制系统，方便开发者进行代码版本管理。

6. PyCharm 提供了数据库工具，支持连接和操作数据库，方便进行数据库开发。

7. PyCharm 支持远程开发，可以连接到远程服务器进行开发和调试。

8. PyCharm 拥有一个丰富的插件市场，用户可以根据需要安装各种插件来扩展 IDE 的功能。

9. 除了 Python，PyCharm 还支持其他语言，如 JavaScript、TypeScript、HTML、CSS 等，适合全栈开发。

10. PyCharm 提供了免费的社区版和付费的专业版，社区版已经包含了大部分常用功能，而专业版则提供了更多高级特性。

11. PyCharm 的用户界面设计直观，易于上手，即使是初学者也能快速适应。

12. PyCharm 持续优化性能，确保在处理大型项目时也能保持良好的响应速度。

Pycharm有一个十分完善的Python编译环境，所以使用Pycharm可以让我们的代码编写变得更加便捷，所以Pycharm的下载还是十分有必要的。

Pycharm可以直接从Pycharm官网上下载，也可以直接从网盘里下载，然后里面有安装教程，小白兔都已经提供了。

说实话，安装的步骤很繁琐，但是俗话说的好嘛------"工欲善其事必先利其器"。所以先别开小差，重头戏现在才开始！！

到这里你的前期工作就已经完成了，下面就可以开始基础地学习python的基础内容了，以下所讲解的内容主要是帮助你们能看懂python的代码，和简单语句的书写。

三、Python------基础知识

3.1注释：

注释主要有两种形式：

单行注释：#往后的内容都是注释内容

多行注释：

"""

中间所有的内容都是注释内容。

"""

这是单行注释：

#这里是注释内容

这是多行注释：

"""
这是第一行注释
这是第二行注释
"""

然后还有一个就是在PyCharm里面用Ctrl+/ 可以对选定的所有行 进行单行注释 和 取消注释。

3.2变量：

这部分其实和其他语言都是一样的，但Python能支持中文命名，虽然一般都不会去使用。

Python 变量命名遵循一些基本规则和约定：

1. 标识符必须以字母或下划线开头：变量名的第一个字符必须是字母（a-z，A-Z）或下划线（_），不能以数字开头。

2. 标识符只能包含字母、数字和下划线：变量名可以包含字母、数字（0-9）和下划线（_），但不能包含空格、标点符号或特殊字符。

3. 区分大小写 ：Python 是区分大小写的编程语言，这意味着 Variable 和 variable 是两个不同的变量名。

4. 保留关键字 ：不能使用 Python 的保留关键字作为变量名，例如 if、for、while、def 等。

5. 避免使用特殊方法名 ：尽管技术上可以，但最好避免使用 Python 的特殊方法名（如 __init__、__del__ 等）作为变量名。

6. 可读性和描述性：变量名应该具有描述性，能够清楚地表达变量的用途或存储的数据类型，以提高代码的可读性。

7. 使用下划线分隔单词：在 Python 中，变量名通常使用下划线分隔单词，这被称为"snake_case"风格。

8. 避免使用缩写：除非缩写是广泛认可的，否则最好使用完整的单词来提高代码的清晰度。

9. 一致性：在同一个项目中，应该保持变量命名的一致性。

这部分和其他语言基本一致就不过多赘述了。

3.3数据类型：

在这里我们先主要讲一下基本数据类型，对于组合数据类型，我们会在下文里详细说明。

对于整数，它有4种形式：十进制数，二进制数，八进制数，十六进制数

a = 123     #十进制
b = +123    #十进制
c = 0b1111011   #二进制
d = 0o173   #8进制
e = 0x7B    #16进制

检测数据类型的函数：type()

然后下面展示一下这几种类型：

a = 1
print(type(a))  # <class 'int'> -- 整型

b = 1.1
print(type(b))  # <class 'float'> -- 浮点型

c = 12.3+45.6j
print(type(c))  #<class 'complex'> -- 复数型

d = True
print(type(d))  # <class 'bool'> -- 布尔型

3.4输入输出：

这部分主要是两个函数：

输入：input()

输出：print()

3.4.1输入：

当程序执行到 input() 函数时，它会暂停执行，等待用户在控制台输入数据。用户输入的数据被按下回车键后，input() 函数会将输入的数据作为字符串返回。

基本用法

user_input = input("请输入一些内容: ")
print("你输入的内容是: ", user_input)

在这个例子中，程序会显示 "请输入一些内容：" 并等待用户输入。用户输入的文本在按下回车键后会被赋值给变量 user_input，然后程序会继续执行并打印用户输入的内容。

参数

input() 函数可以接受一个可选的字符串参数，这个字符串会作为提示信息显示给用户。

name = input("请输入你的名字: ")
print("你好, ", name)

返回值

input() 函数总是返回一个字符串类型的值，即使用户输入的是数字。如果需要将输入转换为其他类型（如整数或浮点数），你需要使用类型转换函数，如 int() 或 float()。

age = input("请输入你的年龄: ")
age = int(age)  # 转换为整数
print("你输入的年龄是: ", age)

注意事项

• 如果用户输入的数据无法转换为所需的类型，程序会抛出异常（如 ValueError）。因此，在使用类型转换时，可能需要进行错误处理。
• input() 函数在读取输入时不会进行任何验证，所以如果需要验证输入，应该在获取输入后进行。
• 在交互式环境（如Python的交互式解释器）中，input() 函数的行为与在脚本中运行时相同。

3.4.2输出：

print() 函数用于将信息输出到控制台。它非常灵活，可以打印各种类型的数据，并且可以格式化输出。

基本用法

print("Hello, World!")

多个参数

print() 可以同时打印多个参数，参数之间默认用空格分隔。

name = "Alice"
age = 30
print("Name:", name, "Age:", age)

分隔符（sep参数）

可以使用 sep 参数来指定参数之间的分隔符，默认为一个空格。

print("Python", "Java", "C++", sep=", ")

结尾字符（end参数）

可以通过 end 参数指定 print() 函数在输出结束后的结尾字符，默认为换行符 \n。

print("Hello, World!", end=" ")
print("Welcome to Python.")

3.4.3格式化输出

print() 函数支持多种格式化字符串的方式：

百分号（%）格式化

name = "Alice"
age = 30
print("Name: %s, Age: %d" % (name, age))

str.format() 方法

name = "Alice"
age = 30
print("Name: {}, Age: {}".format(name, age))

f-string（Python 3.6+）（个人感觉这个不好用）

name = "Alice"
age = 30
print(f"Name: {name}, Age: {age}")

格式化符号：

格式符号	转换
%s	字符串
%d	有符号十进制整数
%f	浮点数
%c	字符
%u	无符号十进制整数
%o	八进制整数
%x（X）	十六进制整数 小写ox（大写OX）
%e（E）	科学计数法e（E)
%g（G）	%f（F）和%e（E）的简写
[格式化符号]

转义字符

• \n：换行。

• \t：制表符，一个tab键（4个空格）的距离。

3.5运算符：

算数运算符

符号	描述
+	加
-	减
*	乘
**	指数
/	除
%	取余
//	整除
[算数运算符]

我们拿C语言进行对比来讲一下这些，基础的 加 减 乘 取余都是一样的，然后在Python中多出了指数运算，然后对于 / 这个类似于C语言中的浮点数除法，会有小数位，然后整数除法是 // 是没有小数位的。

a = 5
b = 2

#加
print(a+b) # 7
#减
print(a-b)# 3
#乘
print(a*b)# 10
#整除
print(a//b)# 2
#取余
print(a%b)# 1
#除
print(a/b)# 2.5
#指数
print(a**b)# 25

#然后对于一些比较特殊的情况，我这边也展示一下，可能并不完全。
print(5.0 // 2) # 2.0
print(5.0 % 2) #1.0
print(5.0 ** 2) #25.0
#在这些时候他们的返回值也是浮点型

赋值运算符

|---|----|
| = | 赋值 |
[赋值运算符]

这个和C语言中类似，我们就不多说了。

复合赋值运算符

符号	描述
+=	加法赋值运算符
-=	减法赋值运算符
*=	乘法赋值运算符
/=	除法赋值运算符
%=	取余赋值运算符
//=	整除赋值运算符
**=	指数赋值运算符
[复合赋值运算符]

对于这一部分，也是和C语言类似，然后也就是先运算等号右侧的值，然后与左侧的值进行相应运算得出结果。然后在Python中删除了C语言中的单目运算符 ++ 和 -- 也就是自增自减操作，下面举一些例子来展示一下。

c = 5
d = 5

#指数赋值运算符
c **= (5-1)/2
print(c) #25.0

#整除赋值运算符
d //= 6-4
print(d) #2

比较运算符

符号	描述
==	等于。如果两个操作数的结果相等。 则条件结果为真(True)，否则条件结果为假(False)
!=	不等于 。如果两个操作数的结果不相等。 则条件为真(True)，否则条件结果为假(False)
>	运算符左侧操作数结果是否大于右侧操作数结果。 如果大于，则条件为真(True)，否则为假(False)
>=	运算符左侧操作数结果是否大于等于右侧操作数结果。 如果大于，则条件为真(True)，否则为假(False)
<	运算符左侧操作数结果是否小于右侧操作数结果。 如果小于，则条件为真(True)，否则为假(False)
<=	运算符左侧操作数结果是否小于等于右侧操作数结果。 如果小于，则条件为真(True)，否则为假(False)
[比较运算符]

这些运算符的使用和C语言中是一致的，那么咱们讲一讲使用时不一样的点，就是说Python中你是能够连续使用的，这样说很不直观明显，咱们直接在代码里展示一下。

如果要判断一个 英语字母 是不是 大写，这时候判断条件怎么写？

先来一段C语言的代码：

#include <stdio.h>

int main()
{
    char x = 'H';
    if (x>='A' && x<='Z') //主要看这里的判断条件
    //我们在判断的时候是不是要用 && 将两个判断连起来
        printf("YES!!!");
    return 0;
}

然后咱们看一下Python的代码：

x = 'H'
if ('A'<=x<='Z'): #在这里我们就不需要用与运算符将两个条件连接起来，直接可以连续使用。
    print("YES!!!")

这就是一个C语言和Python的小区别。

逻辑运算符

在逻辑运算符这部分，Python和C语言的差别就比较大了，咱们直接和C语言进行类比。

符号	类比C语言运算符
and	&&
or	||
not	!
[逻辑运算符]

基本效果是一样的，主要就是在写法上面有所区别，相对于C语言使用符号来表达逻辑的形式，Python直接使用了对应含义的英文单词，让可读性更上一层楼，当然这里不是吹捧，只是在描述一个现象，语言是没有优劣之分的，只有更适合某一方面的说法。

对于这部分逻辑运算符的部分，对于这部分我们需要用到 if 语句，如果不知道含义的可以先看看下面的分支语句的内容然后在返回看这里的内容，我们也进行简单的展示。

if 10 > 20 and 5 < 10:
    print("第一个示例YES!!!") #不会输出

if 10 > 20 or 5 < 10:
    print("第二个示例YES!!!") # 会输出

if not 10 > 20:
    print("第三个示例YES!!!") # 会输出

然后对于逻辑运算这里，对于C也好Python也好，and和or会有短路行为

当使用 and 运算符时，如果第一个条件为假（False），则整个表达式的结果已经确定为假，因此 Python 不会评估后续的条件。这是因为 and 运算符要求所有条件都为真，整个表达式的结果才为真。

当使用 or 运算符时，如果第一个条件为真（True），则整个表达式的结果已经确定为真，因此 Python 不会评估后续的条件。这是因为 or 运算符只要有一个条件为真，整个表达式的结果就为真。

对于这点我们也展示一下。

#and的短路行为

def run_1():
    print("运行了run_1")

def run_2():
    print("运行了run_2")

# 第一个条件为假，因此不会执行第二个条件
if False and run_1():
    pass
else:
    run_2()

"""
上面的语句 不会运行run_1()函数 会运行run_2()函数

下面的语句两个函数都会运行
"""

# if True and run_1():
#     pass
# else:
#     run_2()

#or的短路行为

def run_1():
    print("运行了run_1")

def run_2():
    print("运行了run_2")

# 第一个条件为假，因此不会执行第二个条件
if True or run_1():
    pass
else:
    run_2()

"""
上面的语句 不会运行run_1()函数 会运行run_2()函数

下面的语句两个函数都会运行
"""

# if False or run_1():
#     pass
# else:
#     run_2()

现在还没有到疲惫的时候，再加把劲咯。

四、Python------流程控制

对于这部分，大体都和C语言类似，然后咱们会重点提一下C语言里不同的部分。

4.1顺序结构

就相当于妈妈给了你一个菜单，让你去买菜，要从上往下一个一个买，不能跳过其中一个，先买下一个菜。

这个部分就是按照代码的上下行顺序进行代码的运行，这里就不多说这个结构了。

4.2分支结构

就相当于，妈妈问你想吃 红烧肉 还是 宫保鸡丁，你就得开始想我今天想吃那个，然后再去买其中一个的材料。

分支语句也就是if......elif......else......语句。

if 判断条件：

代码块

......

括号内表示可有可无，不能没有 if 语句然后直接出现 elif 和 else。

（

elif 判断条件:

代码块

......

else:

代码块

......

）

这部分其实Python和C语言是一样的，就是C语言里面是else if在Python里面是elif，本质是差不都的。

然后按照惯例，下面展示一下这个语句的使用方法。

#单if语句
x = 10
if x > 5:
    print("x is greater than 5")

#if......elif......语句
x = 20
if x > 30:
    print("x is greater than 30")
elif x > 10:
    print("x is greater than 10 but less than or equal to 30")

#if......elif......else......语句
x = 20
if x > 30:
    print("x is greater than 30")
elif x > 10:
    print("x is greater than 10 but less than or equal to 30")
else:
    print("x is 10 or less")

#if......else......语句
x = 5
if x > 10:
    print("x is greater than 10")
else:
    print("x is 10 or less")

然后和C语言一样的，它也是可以嵌套使用的。

#嵌套使用
x = 5
if x > 10:
    print("x is greater than 10")
elif x > 5:
    if x < 8:
        print("x is between 5 and 8")
    else:
        print("x is 8 or greater but less than 10")
else:
    print("x is 5 or less")

4.3循环结构

你玩原神想抽 凌华 ，但是你一直没抽到，但是你不甘心呐，发誓要一直抽一直抽直到抽到老婆为止，无穷无尽直到抽到为止才停下。

Python中循环有两种方式，for循环和while循环。

while循环

咱们先讲一下while循环，这个和C语言里面基本一般无二。

while 循环条件：

循环体

......

# 初始化计数器
counter = 1

# 使用while循环直到计数器达到6
while counter <= 5:
    print(counter)
    counter += 1  # 每次循环增加计数器的值

还有一种比较常用的方法就是：

while True:

这种方法就是一个死循环，因为while是在判断条件为真时进入循环，而此时的条件是True也就是一直为真。

---

for循环

for循环比较常见的两种写法：

1.for i in range(100):

循环体

......

2.for i in list:

循环体

......

for循环在Python中的使用和在C语言中的使用出入还是很大的，在python中for循环的实现是采用的迭代的方式实现的，当然这在本篇中不重要，咱们只需要知道for循环是这么写的就行了。

那么言归正传，我们来讲一下这里面出现的一些内容。

首先是在for循环第一种写法中出现的 range() 函数；

range() 函数可以接收一到三个参数，分别是：

1. start（起始值，默认为0）：序列的起始值。
2. stop（结束值）：序列的结束值，但不包括这个值本身。
3. step（步长，默认为1）：序列中每一项之间的差。

下面我把range函数的三个参数的实现展示一下：

#只写一个参数，会默认是stop位置的值
for i in range(5):
    print(i)
print("-------------------------")

#写两个参数会默认是start和stop的值
for i in range(2, 5):
    print(i)
print("-------------------------")

#三个值都写
for i in range(1, 6, 2):
    print(i)
print("-------------------------")

#还有一个比较常用的方式就是step的值为负数
for i in range(5, 0, -1):
    print(i)

结果：

0
1
2
3
4
-------------------------
2
3
4
-------------------------
1
3
5
-------------------------
5
4
3
2
1

---

然后是第二种方式，它是一种内容循环，从字符串、列表、字典等内容中逐个索取元素对i赋值进行遍历。

对于这种方式咱们在后面讲这些数据结构的时候再细说。

---

在循环结构中常用的一些函数

1.break

强行跳出该 循环，在循环中一旦执行这个函数会直接跳出该循环。

#break
for i in range(10):
    print(i)
    if i == 5:
        break
"""
输出
0
1
2
3
4
5
"""

2.continue

continue 关键字用于跳过当前循环的剩余部分，并立即开始下一次迭代。也就是说，当 continue 被执行时，循环体中 continue 之后的代码将不会执行，并且控制流将直接跳转到循环的开始，进行下一次迭代的条件检查。

#continue
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)
"""
1
3
5
7
9
"""

3.enumerate

循环的时候自带计数（从0开始），它用于将一个可迭代对象（如列表、元组、字符串等）组合为一个索引序列，同时列出数据和数据下标。这在循环遍历可迭代对象时非常有用，尤其是当你需要在循环中使用索引时。

enumerate(iterable, start=0)

• iterable：一个可迭代对象，如列表、元组、字符串等。
• start（可选）：一个整数，指定索引的起始值，默认为0。

#enumerate
for p, i in enumerate(range(5)):
    print(p, i, sep=':')
print("----------------------")

list = [12, 15, 20, 25, 30, 35]
for i, num in enumerate(list):
    print(i, num, sep=':')
print("----------------------")

my_dict = {'a': 1, 'b': 2, 'c': 3}
for key, value in enumerate(my_dict):
    print(key, value)

"""
结果：
0:0
1:1
2:2
3:3
4:4
----------------------
0:12
1:15
2:20
3:25
4:30
5:35
----------------------
0 a
1 b
2 c
"""

4.zip

循环的时候合并多个列表，它用于将多个可迭代对象（如列表、元组、字符串等）"压缩"成一个元组列表。每个元组包含来自每个可迭代对象的相应元素。如果可迭代对象的长度不等，zip() 会停止在最短的可迭代对象结束时。

zip(*iterables)

• *iterables：一个或多个可迭代对象。

#zip
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
for i, j in zip(list1, list2):
    print(i, j)

"""
结果：
1 a
2 b
3 c
"""

循环中的else

在循环后面写else，这是在C语言代码里面闻所未闻的吧，但它在Python中却是存在的一种写法，在前面循环中的常用函数里咱们认识了一个函数break，它能让循环强行终止，也就是非正常退出。而在循环后面的else能够判定与它相连的循环是不是非正常退出。

基本写法如下：

while 条件:
    # 循环体
else:
    # 当循环条件不再为真时执行的代码块

for 元素 in 可迭代对象:
    # 循环体
else:
    # 当循环正常结束时执行的代码块

下面演示一下在循环中else的使用：

#没有break的else
count = 0
while count < 3:
    print(count)
    count += 1
else:
    print("循环正常结束，没有遇到break")

"""
0
1
2
循环正常结束，没有遇到break
"""

#有break的else
count = 0
while count < 3:
    print(count)
    count += 1
    if count == 2:
        break
else:
    print("循环正常结束，没有遇到break")

"""
0
1
"""

#没有break的else
for i in range(3):
    print(i)
else:
    print("循环正常结束，没有遇到break")

"""
0
1
2
循环正常结束，没有遇到break
"""

#有break的else
for i in range(3):
    print(i)
    if i == 1:
        break
else:
    print("循环正常结束，没有遇到break")

"""
0
1

"""

由于在一般的情况不怎么会用，我就不多说这个。

下面的内容就是python中的数据类型，是本篇中的重中之重，一定好好看喔！！！

五、字符串

5.1基本操作符

以下实例中的参数 st1= 'cde', st2 = 'abcdfg'；

操作符	描述	实例	结果
s1+s2	连接。将两个字符串连接	stl+st2	'cdeabcdefg'
n*s或s*n	复制。对字符串 s 复制 n次	3*stl	'cdecdecde'
s1 in s2	子串测试。s1 若是 s2 的子串， 返回 True，否则返回 False	stl in st2	True
s[i]	索引。取索引号为i的字符	st2[3]或 st2[-4]	d
s[start:end:step]	切片。返回索引号 start 到 end，但不包括 end 的子串;省略 start表示从头开始，省略 end 表示取到结尾;step 为步长，省略为 1	st2[:-4] st2[:6:2] st2[:]	abc' ace' 'abcdefg'
[字符串的基本操作符]

然后我们主要说一下索引和切片：

首先是索引：

字符串中的每个字符都是有索引号的，通过索引号和索引操作符 " [ ] " 可以获取单个字符。索引有两种表示方式: 正向递增和反向递减，习惯用正向。

然后是切片：

其实从本质来讲切片和索引是一样的，区别就只在于返回的是一个值还是一部分值。

切片语法：s[start:end:step]；

作用:对字符串取以 start 为起始、end 为结束但不包括 end，即取[start,end)区间的以 step 为步长的子串。其中 start、end、step 均可以省略，但至少保留一个冒号省略 start 表示0从头开始取，省略 end 表示到最后，省略 step 步长为1。

下面演示一下这两个：

st = 'Python is a good programming language'
#索引：
print(st[0])
print(st[5])
print(st[-1])
print(st[-4])

#切片
print(st[:5])
print(st[0:5])
print(st[1:10:2])
print(st[2::2])
print(st[::2])
print(st[::-1])
print(st[::-2])
print(st[-5:-1])


"""
P
n
e
u
Pytho
Pytho
yhni 
to sago rgamn agae
Pto sago rgamn agae
egaugnal gnimmargorp doog a si nohtyP
eaga nmagr ogas otP
guag
"""

5.2常用方法

首先，这里提到了一个词------方法。

Python 中每一个数据类型都有一个对应的内置类，每新建一个数据，实际就初始化并生成一个对象。系统为对象提供了一些方法便于功能处理。

方法引用格式------字符串对象,方法(参数)

注意事项 ------方法作用于对象，方法引用的结果，不改变引用对象。

以下实例中的参数：st='ABC DEFG BC'

分类	方法	描述	实例	结果
统计 查找	S.count(c)	在字符串中统计 c 出现的个数	st.count("B")	2
统计 查找	S.find(c)	在字符串中找第一个出现 c串的位置，找不到返回-1	sl.find("BB")	-1
统计 查找	S.index(c)	在字符串中找第一个出现 c子串的位置，找不到抛出 异常	s1.index("BC")	1
替换 分离 连接	S.strip(c)	去掉字符串两旁的c 子串，一般用于去掉空格，省略c表示空格	"123 ".strip()	'123'
替换 分离 连接	S.replace(old,new)	将字符串中new子串替换old子串	sl.replace("BC","WYZ")	'AWYZ DEFG WYZ'
替换 分离 连接	S.split([c])	将字符串按照 c 分隔符分离，返回结果是列表。省略 c 按空格、制表符或换行符分隔	s2="a 12 34" s2.split() s2.split(" ")	['a','12' ,'34'] ['a',' ', '12','34']
替换 分离 连接	c,join(L)	将 L 序列的字符串元素以字符 c为分隔符连接成字符串	1st=[a"12' 34] ";" join(lst)	'a;12;34'
转换 测试	S.lower()	全部转换成小写字母	st.lower()	'abc defg bc'
转换 测试	S.upper()	全部字母大写	"who".upper()	'WHO'
转换 测试	S.title()	将字符串的所有单词首字母大写，其余字母小写	"who are yoU".title()	'Who Are You'
转换 测试	S.isnumeric()	字符串全部是数字，返回 True;否则返回False	st.isnumeric() "123"isnumeric)	False True
转换 测试	S.isalpha()	字符串全部是字母，返回 True;否则返回 False	sl.isalpha() "asDF".isalpha()	False True
[字符串常用方法]

然后对于这部分，内容是比较多的，我主要说几个在爬虫中处理数据时比较常用的：

test='   python is s good language!   '
#strip方法：
print(test.strip())
print(test.lstrip())
print(test.rstrip())
print("-------------------------------------------------")

#replace方法：
print(test.replace('python','黑不拉几的小白兔').replace('language','博主'))
print("-------------------------------------------------")

#split方法：
print(test.split(' '))
print(test.split(' ')[3])
print("-------------------------------------------------")

#upper & lower方法：
print(test.upper().lower())
print("-------------------------------------------------")

#find方法：
print(test.find('p'))
print(test[test.find('p'):]) #取该字符右侧内容
print("-------------------------------------------------")

#len()函数：
print('test的字符长度是：',len(test))
print("-------------------------------------------------")


"""
python is s good language!
python is s good language!   
   python is s good language!
-------------------------------------------------
   黑不拉几的小白兔 is s good 博主!   
-------------------------------------------------
['', '', '', 'python', 'is', 's', 'good', 'language!', '', '', '']
python
-------------------------------------------------
   python is s good language!   
-------------------------------------------------
3
python is s good language!   
-------------------------------------------------
test的字符长度是： 32
"""

如果我今天必有一死，那一定是Python

六、列表

这个我自认为是Python中最好用的结构------列表，列表是一个可变数据类型。

6.1列表的创建

(1)利用 " [ ] " 建立列表

通过 " [ ] " 内不带数据的方式将产生空列表;通过 " [ ] " 内以逗号分隔的数据将产生包含数据的列表。列表的元素还可以是列表构成的嵌套列表，如同传统数组中的二维数组。

(2)利用 list 函数建立列表

利用 list 函数也可以建立空列表、有数据列表，还可以将其他数据类型转换成列表，甚至还可以生成由 range 函数产生的有序序列。

下面展示一下两种创建方法：

"""
列表创建
"""
#直接用[]进行创建
lst = [] #空列表创建
lst1 = ['dsa', 123, 'sda', [13, 'dsd']]
print(lst1)

#使用list 函数
lst = list() #空列表创建
lst2 = list("hello")
lst3 = list(range(10))
print(lst2)
print(lst3)
#这里比较常见的比如说和map(), input()函数结合使用
lst4 = list(map(str, input().split()))
print(lst4)


"""
['dsa', 123, 'sda', [13, 'dsd']]
['h', 'e', 'l', 'l', 'o']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
123 sad d155 dsa 这里是输入
['123', 'sad', 'd155', 'dsa']
"""

6.2列表的访问

列表中的每个元素都有对应的索引号，用正向索引或者反向索引可以访问列表中的元素，这点与字符串操作是一致的。

(1)对一维列表L，元素访问格式为：

L[索引]
(2)对二维列表 L的每个元素，可以为每个维度使用一个[]，元素访问格式为

L[行索引] ------------->这是索引列表内的某一个列表

L[行索引][列索引]--->这是索引列表内某一个列表的值

"""
列表访问
"""
lst5 = ['dsa', 123, 'sda', [13, 'dsd']]
print(lst5[0])
print(lst5[3])
print(lst5[3][0])
print(lst5[-3])


"""
dsa
[13, 'dsd']
13
123
"""

6.3列表遍历

在这里咱们先来回顾一下循环的内容，在循环中我们不是展示了两种方式嘛，一种通过range函数进行的遍历，以及直接的内容遍历。在这里，了解完list的内容之后，我们再来看看这个代码，大家可以重新理解一下。

lst6 = ["I", "am", "a", "Bunny", "Girl"]
for i in range(len(lst6)): #len函数是获取长度，在后面会详细说的
    print(lst6[i])
print("-------------------------------------")

for i in lst6:
    print(i)
print("-------------------------------------")

for i, item in enumerate(lst6):
    print(i, item)

结果：

"""
I
am
a
Bunny
Girl
-------------------------------------
I
am
a
Bunny
Girl
-------------------------------------
0 I
1 am
2 a
3 Bunny
4 Girly
"""

6.4列表的常用操作

（1）切片

列表切片是指从 列表的片段中 取出形成列表，其格式为：
列表[start:end:step]

作用:取列表中左闭右开的片段。在Python中几乎所有的范围都是左闭右开。

省略start则为0； 省略end 取到列表最后省略； step 则步长为1；

全部省略取全部列表。

在这里，我们要提一下string字符串，列表切片与字符串切片关键不同之处 ------ 列表切片有赋值操作而字串没有。

因为字符串是不能被修改 的，所以不可以对字符串进行切片赋值操作。而列表是可修改 的，通过切片赋值操作，方便实现对列表插入、删除、修改等护操作。

那么我们看一下列表的切片操作吧！~

lst7 = [10, 20, 30, 40, 50]
print(lst7[1:4:2])
print(lst7[1:4])
print(lst7[1::2])
print(lst7[:5:2])
print(lst7[::2])
print(lst7[::])
print("-------------------------------------")

#可以使用切片实现以下操作
#插入操作， 会覆盖切片范围内的内容，再添加上新的内容
lst7[1:1] = [1, 2, 3, 4] #由于切片区域没有数据，所以没有内容被覆盖
print(lst7)
lst7[1:2] = [5, 6, 7, 8] #会将索引值为 1 位置的数删除，然后添加上新数据
print(lst7)
print("-------------------------------------")

#删除，其实和插入操作类似，只是将插入的列表设置为空
lst7[1:8] = []
print(lst7)

结果：

"""
[20, 40]
[20, 30, 40]
[20, 40]
[10, 30, 50]
[10, 30, 50]
[10, 20, 30, 40, 50]
-------------------------------------
[10, 1, 2, 3, 4, 20, 30, 40, 50]
[10, 5, 6, 7, 8, 2, 3, 4, 20, 30, 40, 50]
-------------------------------------
[10, 20, 30, 40, 50]
"""

（2）运算

大佬们，1+1等于多少？

2？不对喔，是11。

这是曾经网上的一个段子，但是在Python中的列表它是对的喔~

list 里有三个运算：

连接"+"、复制"*"、测试"in"

我们来看看Python里面怎么让1+1变成11吧！~

# 连接 "+"
lst8 = [1] #1
lst9 = [1] #1
print(lst8 + lst9) # 1+1 = 11咯

# 复制"*"
lst10 = [1, 2, 3]
print(lst10 * 3)

# 测试"in"
lst11 = [1, 2, 3, 45648, 498, 156, 3, 156, 65, 1531, 35, 1, "dsa", "31"]
if 31 in lst11:
    print("yes")
else:
    print("no")
if 45648 in lst11:
    print("yes")
else:
    print("no")

结果：

"""
[1, 1]
[1, 2, 3, 1, 2, 3, 1, 2, 3]
no
yes
"""

（3）删除

如果有个人你不想见到了，你会怎么做，没错给他微信删了！！

在 list 里如果有个元素你不想要了，也是可以直接删除的。

del 列表

del 列表[索引]

作用:"del 列表"语句用于删除整个列表,"de! 列表[索引]"语句用于删除列表中的元素。

lst12 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
del lst12[0]
print(lst12)
del lst12[1:3]
print(lst12)
del lst12
#print(lst12)
#NameError: name 'lst12' is not defined. 

结果：

"""
[2, 3, 4, 5, 6, 7, 8, 9]
[2, 5, 6, 7, 8, 9]
"""

6.5列表的常用函数

(1)、若列表中的元素是字符串，求最大值是按元素首字母进行比较，大者则该元素大;否则再按第2个字符进行比较，直到比出大小。求最小值和排序均按此规则。

(2)、函数操作结果有返回值，但不会改变参数中的值

分类	函数	含义
统计	max(L)	返回列表中最大值
统计	min(L)	返回列表中最小值
统计	len(L)	返回列表长度
统计	sum(L)	返回列表各元素和
排序	sorted(L)	返回排序后的列表，默认为升序;若有reverse=True参数，则为降序
[常用函数]

（1）max() && min() && sum() && len()

lst13 = [1, 2, 3, 15, 49, 6, 1, 8, 13]
lst14 = ['bunny', 'girl', 'breakfast', 'lunch', 'noodle', 'dinner']
lst15 = [[1, 2, 3], 4, 5, [6, 7, 8, 9]]
print(max(lst13))
print(max(lst14))

print(min(lst13))
print(min(lst14))

print(len(lst13))
print(len(lst14))
print(len(lst15)) #可以想一下这个是多少哦

print(sum(lst13))

结果：

"""
49
noodle
1
breakfast
9
6
4
98
"""

（2）sorted()

在sorted里面有两个关键字：key、reverse

对于key 关键字：通过关键字 key 确定内嵌的一维列表的某个元素，排序时一般通过 key 指定的lambda函数进行。

对于reverse关键字：通过它来进行 升序 和 降序 的修改。

lst16 = [5, 78, 46, 5, 1, 351, 531, 351, 564, 64, 984, 9]
sorted(lst16, reverse=True)
print(sorted(lst16, reverse=True))
print(sorted(lst16, reverse=False))
print(lst16) #sorted是函数，它不会修改原列表，而是生成新的列表
print("-------------------------------------")
#如果说我们要按照列表中每个列表里的第二个元素进行排序
lst17 = [['皮卡丘', 15], ['小火龙', 13], ['水箭龟', 35], ['耿鬼', 67], ['妙蛙种子', 5]]
print(sorted(lst17, reverse=True, key=lambda x: x[1]))
print("-------------------------------------")

结果：

"""
[984, 564, 531, 351, 351, 78, 64, 46, 9, 5, 5, 1]
[1, 5, 5, 9, 46, 64, 78, 351, 351, 531, 564, 984]
[5, 78, 46, 5, 1, 351, 531, 351, 564, 64, 984, 9]
-------------------------------------
[['耿鬼', 67], ['水箭龟', 35], ['皮卡丘', 15], ['小火龙', 13], ['妙蛙种子', 5]]
"""

（3）zip() 和 enumerate()

这个在前面讲循环的时候有提到过，这里我们在学了列表的内容之后再来看看它们的其它作用。

zip()

• 定义 ：zip()是 Python 内置函数，它可以将多个可迭代对象（如列表、元组、字符串等）中对应的元素打包成一个个元组，然后返回由这些元组组成的迭代器。如果可迭代对象的长度不一致，zip()会以最短的可迭代对象为准。
• 基本语法 ：zip(iterable1, iterable2,...)

enumerate()

• 定义 ：enumerate()是 Python 内置函数，它可以将一个可迭代对象组合为一个索引序列，同时返回一个枚举对象，该对象包含了元素的索引和元素本身。
• 基本语法 ：enumerate(iterable, start=0)，其中start参数是起始索引，默认为 0。

lst18 = [1, 2, 3]
lst19 = ['a', 'b', 'c']
zipped = zip(lst18, lst19)
print(list(zipped))
print("-------------------------------------")

lst20 = ['apple', 'banana', 'cherry']
enumerated = enumerate(lst20)
print(list(enumerated))



"""
[(1, 'a'), (2, 'b'), (3, 'c')]
-------------------------------------
[(0, 'apple'), (1, 'banana'), (2, 'cherry')]
"""

6.6列表的常用方法

大家是不是在这里懵了一下，上面不是刚说了常用函数吗？这里怎么又有方法，两个有什么不一样？

其实对于一个class来说，两种是有差别的，但是对于入门而言，我们不需要了解那么多。

OK，言归正传，我们目前需要知道的就是两者的调用方式不同即可：

函数：

函数（参数）

例如说前面的 max( ) 函数，我们调用方法是，max（lst）,列表是作为参数进入max()函数内的。

方法：

列表对象.方法(参数)

它是将列表作为主体对它进行操作，还有一个点，就是方法是直接对列表进行操作，是没有返回值的。

下面列举几个比较常用的列表方法：

（1）lst.append(object)

在列表对象的结尾，加上新对象 object。

（2）lst.sort()

将列表对象中的元素依照大小顺序排列。

（3）lst.count(value)

针对列表对象中的相同元素值 value 计算其数目。

（4）lst.extend(list)

将参数 list 列表对象中的元素加到此列表中，成为此列表的新元素。

（5）lst.index(value)

将列表对象中元素值为 value 的索引值返回。

（6）lst.insert(index, object)

将在列表对象中索引值为index的元素之前插入新元素object。

（7）lst.reverse()

将列表对象中的元素颠倒排列。

（8）lst.pop([index])

将列表对象中索引值为 index 的元素删除。如果没有指定 index 的值，就 将最后一个元素删除。

（9）lst.remove(value)

将列表对象中元素值为 value 的删除。

方法的使用和函数使用类似，所以就简单展示一下------

lst21 = [11, 23, 423]
lst21.append(18)
print(lst21)
lst21.append([21, 231]) #它能够在列表中添加上列表等，作为一个独立的元素处在列表中
print(lst21)
"""
[11, 23, 423, 18]
[11, 23, 423, 18, [21, 231]]
"""
print("-------------------------------------")

lst22 = [12, 20, 43, 10, 8, 19, 97, 20]
lst22.sort(reverse=False) #默认是递增顺序，可以用reverse关键字改变
print(lst22)
"""
[8, 10, 12, 19, 20, 20, 43, 97]
"""
print("-------------------------------------")

lst23 = [1, 2, 3, 2, 1, 3, 2, 1, 1]
print(lst23.count(1))
print(lst23.count(2))
print(lst23.count(3))
"""
4
3
2
"""
print("-------------------------------------")

lst24 = [1, 2, 3]
lst24.extend([4, 5, 6])
print(lst24)
"""
[1, 2, 3, 4, 5, 6]
"""
print("-------------------------------------")

lst25 = [1, 2, 3, 21, 23, 43, 21]
print(lst25.index(21))
"""
3
"""
print("-------------------------------------")

lst26 = [1, 2, 3, 4, 5, 6, 7]
lst26.insert(3, 123)
print(lst26)
"""
[1, 2, 3, 123, 4, 5, 6, 7]
"""
print("-------------------------------------")

lst27 = [1, 2, 54, 47, 523, 6, 7]
lst27.reverse()
print(lst27)
"""
[7, 6, 523, 47, 54, 2, 1]
"""
print("-------------------------------------")

lst28 = [10, 20, 30, 40, 50, 60, 70]
lst28.pop(3)
print(lst28)
lst28.pop()
print(lst28)
"""
[10, 20, 30, 50, 60, 70]
[10, 20, 30, 50, 60]
"""
print("-------------------------------------")

lst29 = [10, 20, 30, 40, 50, 60, 70]
lst29.remove(20)
print(lst29)
"""
[10, 30, 40, 50, 60, 70]
"""

6.7列表推导式

这部分的内容很有意思，但个人认为不是很重要，大家了解能这么写就好，在爬虫里面其实它没有那么重要至少。

基本语法

• 基本的列表推导式的形式是[表达式 for 变量 in 可迭代对象]。

lst1 = [i * i for i in range(10)]
print(lst1)

"""
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
"""

带有条件的列表推导式

• 列表推导式还可以包含条件语句，语法是[表达式 for 变量 in 可迭代对象 if 条件]。

lst2 = [i * i for i in range(10) if i % 2 ==0]
print(lst2)

"""
[0, 4, 16, 36, 64]
"""

嵌套的列表推导式

• 列表推导式可以嵌套使用。

lst3 = [[i * j for j in range(3)] for i in range(3)]
print(lst3)

"""
[[0, 0, 0], [0, 1, 2], [0, 2, 4]]
"""

不行，要长脑子了

列表的内容很多，大家可以慢慢学，慢慢试试。

七、字典

字典你真别说，它在爬虫里好像很好用，毕竟是一个哈希存储的数据类型，能够在大量数据里直接找到所需要的内容。

字典的对象使用大括号{}将元素列出。

字典的元素排列并没有一定的顺序，因为可以使用键值来取得该元素。

不允许同一个键值多次出现。创建时如果同一个键值被赋值多次，那么只有最后一 个值有效，前面重复的键值将会被自动删除。

因为字典键值必须不可变，所以可以用数字、字符串或元组充当，列表则不行。如果用列表做键值，将会报错。

1.字典的初始化

1.直接用 { } 将内容括起来

2.用 dict( ) 函数将列表转换成字典

dic1 = {'cat': 10, 'dog': 20}
print(dic1)
# {'cat': 10, 'dog': 20}
temp_keys = ['cat', 'dog']
temp_values = [10, 20]
dic2 = dict(zip(temp_keys, temp_values))
print(dic2)
# {'cat': 10, 'dog': 20}

2.字典的操作

（1）获取字典中的元素值

通过使用键值作为索引，可以返回字典中的元素。在获取字典中的元素值时，必须保证输入的键值在字典中是存在的，否则 Python 会产生 一个 KeyError 错误。

dic3 = {'cat': 10, 'dog': 20}
print(dic3['cat'])
# 10
print(dic3['rabbit'])
# KeyError: 'rabbit'

（2）添加和修改字典中的元素值

dic[key] = value

当key在字典中存在，就是修改

若不存在，就是添加

dic4 = {'cat': 10, 'dog': 20}
dic4['dog'] = 30
dic4['rabbit'] = 40
print(dic4)
# {'cat': 10, 'dog': 30, 'rabbit': 40}

（3）删除字典中的元素

使用 del 语句可以删除字典中的元素。

dic5 = {'cat': 10, 'dog': 20}
del dic5['dog']
print(dic5['dog'])
# KeyError: 'dog'

3.字典内置函数

内置函数包括 ------

len() str() type()

这些不怎么常用，用处也和前面的类似，下面简单看看怎么用。

dic6 = {'cat': 10, 'dog': 20}
print(len(dic6), str(dic6), type(dic6))
# 2 {'cat': 10, 'dog': 20} <class 'dict'>

4.字典内置方法

（1）keys() & values() & items()

这三个方法能过分别获取字典的 键，值，键值对。

dic7 = {'cat': 10, 'dog': 20, 'rabbit': 30}
print(dic7.keys()) #返回值储存在列表中
print(dic7.values())
print(dic7.items())
"""
dict_keys(['cat', 'dog', 'rabbit'])
dict_values([10, 20, 30])
dict_items([('cat', 10), ('dog', 20), ('rabbit', 30)])
"""

（2）get() & update() & setdefault()

get(k [, d])：k 是字典的索引值，d 是索引值的默认值。如果 k 存在，就返回其值， 否则返回 d。

update(E)：E 是字典对象，由字典对象 E 来更新此字典。

setdefault(k [, d])：k 是字典的键值，d 是键值的默认值。如果 k 存在，就返回其值； 否则返回 d，并将新的元素添加到字典中。

dic7 = {'cat': 10, 'dog': 20, 'rabbit': 30}
print(dic7.keys()) #返回值储存在列表中
print(dic7.values())
print(dic7.items())
"""
dict_keys(['cat', 'dog', 'rabbit'])
dict_values([10, 20, 30])
dict_items([('cat', 10), ('dog', 20), ('rabbit', 30)])
"""

dic8 = {'cat': 10, 'dog': 20, 'rabbit': 30}
print(dic8.get('cat'))
print(dic8.get('cow', 'haha')) #当get的内容不存在时，不会报错
"""
10
haha
"""

dic8.update({'dog' : 50})
print(dic8)
# {'cat': 10, 'dog': 50, 'rabbit': 30}

print(dic8.setdefault('cat'))
print(dic8.setdefault('cow', 100))
"""
10
100
"""

（3）copy() & clear()

dic9 = {'cat': 10, 'dog': 20, 'rabbit': 30}
dic10 = dic9.copy()
print(dic10)
# {'cat': 10, 'dog': 20, 'rabbit': 30}
print("---------------------------------------")

dic10.clear()
print(dic10)
# {}

（4）pop()

popitem()：删除字典中的最后一个元素。

pop(k)：删除键为k的这个键值对

dic11 = {'cat': 10, 'dog': 20, 'rabbit': 30}
dic11.pop('cat')
dic11.popitem()
print(dic11)
# {'dog': 20}

八、元组

这个类型说实话很少用，这边就简单带过一下。

首先对于元组这个类型，它是一个不可变对象，它的这个性质导致它很少会用到，可能在某些特殊时候，你保证一些数据就是不会被修改的时候才会用到它吧。

---

1. 创建只有一个元素的元组

如果创建的元组对象只有一个元素，就必须在元素之后加上逗号（,），否则 Python 会认 为此元素是要设置给变量的值。

tup1 = (10,)
print(tup1, type(tup1))
#(10,) <class 'tuple'>
tup2 = (10)
print(tup2, type(tup2))
#10 <class 'int'>

2. 元组的对象值不能修改

在元组中，不可以修改元组对象内的元素值，否则会提示错误。这个决定了元组整体的一个性质。

tup3 = (10, 20, 30)
tup3[1] = 100
#TypeError: 'tuple' object does not support item assignment

3. 删除元组内的对象

虽然元组内的元素值不能修改，但是可以删除，从而达到更新元组对象的效果。

tup4 = (100, 200, 300, 400)
tup4 = tup4[0], tup4[2], tup4[3]
print(tup4)
#(100, 300, 400)

4. 获取元组对象的元素值

元组对象支持使用索引值的方式来返回元素值。

tup5 = (10, 20, 30, 40, 50)
print(tup5[1], tup5[3])
# 20 40

5. 组合元组

虽然元组的元素值不能修改，但是可以组合。

tup6 = (10, 20)
tup7 = ('black', 'bunny', 'girl')
print(tup6 + tup7)
# (10, 20, 'black', 'bunny', 'girl')

6. 删除整个元组

使用 del 语句可以删除整个元组。

tup8 = (10, 20)
del tup8
print(tup8)
# NameError: name 'tup8' is not defined.

7.内置函数

元组也能使用的函数有 ------ len(), max(), min(), sum()。这些在前面都遇见过，效果和使用方法都差不多，我们就简单看看怎么用。

tup9 = (10, 20, 30, 40)
print(max(tup9), min(tup9), len(tup9), sum(tup9))
# 40 10 4 100

九、集合

这个也不常使用，也简单了解一下吧。

集合是由无序且不重复的元素组成的可变序列。可以使用花括号{}或者set()函数来创建集合。

1.集合的初始化

set1 = set([10, 20, 30, 40, 50, 60, 70])
set2 = {1, 2, 3, 4, 5, 6, 7}
print(type(set1))# <class 'set'>
print(type(set2))# <class 'set'>

2.集合的操作

（1）添加操作

使用add方法。

set3 = {1, 2, 3}
set3.add(4)
print(set3)
# {1, 2, 3, 4}

（2）删除操作

使用 remove() 和 discard() ，其中当集合中不存在指定删除元素时，remove会引起KeyError，而discard不会。

set4 = {1, 2, 3, 4}
set4.remove(3)
print(set4)
# {1, 2, 4}
#set4.remove(5) 会报错
#KeyError: 5
set4.discard(5)
# 元素5不存在，不会报错
print(set4)
# 输出 {1, 2, 4}

（3）并集 & 交集 & 差集

并集 ： 使用union()方法或者|运算符可以获取两个集合的并集

交集 ：使用intersection()方法或者&运算符可以获取两个集合的交集

差集 ：使用difference()方法或者-运算符可以获取两个集合的差集

set1 = {1, 2, 3}
set2 = {3, 4, 5}
u_set1 = set1.union(set2)
print(u_set1)  # 输出 {1, 2, 3, 4, 5}

# 或者使用 | 运算符
u_set2 = set1 | set2
print(u_set2)  # 输出 {1, 2, 3, 4, 5}

i_set1 = set1.intersection(set2)
print(i_set1)  # 输出 {3}

# 或者使用 & 运算符
i_set2 = set1 & set2
print(i_set2)  # 输出 {3}

d_set1 = set1.difference(set2)
print(d_set1)  # 输出 {1, 2}

# 或者使用 - 运算符
d_set2 = set1 - set2
print(d_set2)  # 输出 {1, 2}

十、txt文本操作

这部分我们在后续爬虫爬取内容的时候，会很常使用到，但是不用担心学不会，用多了就能记住，在本篇里面不要求掌握的很好。

如果希望爬虫爬下来的内容仍然能够保存， 需要使用其他的保存方式，文件就是一个很好的选择。在程序运行过程中将数据保存到文件中， 程序运行结束后，相关数据就保存在文件中了。

1.open
2.with

**w 只写
r 只读
a 只写追加

• 可读可写**

#简单方式
file=open('test.txt','a+',encoding='utf8')
for i,line in enumerate(file.readlines()):
    print(i,line.strip())
file.close()

#自开合
with open('test.txt', 'w', encoding='utf8') as f:
    f.write("这是自开合里边写的")

我们对于文本操作的了解就先到这里，到后面遇到无法解决的就到时候再说。

好多好多，要死掉了啦

总结

本篇内容很多吧，相信开头小白兔说的，这篇 很多很难写 的话吧，大家慢慢学慢慢看，也可以给小白兔一些时间准备下一篇的内容，对于这个专栏的内容可能更新速度会比较慢，小白兔想要好好写爬虫这个专栏，想要让它成为我的一个得意之作。

在这里，我把本期里所写的代码以及pycharm的下载等内容的下载链接都放在下方

下载链接

pycharm

链接：https://pan.quark.cn/s/a96a9f69de06

提取码：pyhp

示例代码

链接：https://pan.quark.cn/s/84de7213246c

提取码：kbDA

OK，那么大家下回见，如果感兴趣stm32的内容或者算法的内容，大家也可以看看小白兔其他的一些专栏。