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优势

• PyCharm 提供了代码补全、代码片段、智能代码导航等高级编辑功能，使得代码编写更加高效。
  
• PyCharm 可以或许及时查抄代码中的错误和警告，提供快速修复建议，帮助开辟者及时发现并修正题目。
  
• PyCharm 支持多种项目视图，可以清楚地构造和管理项目文件，方便开辟者快速定位文件和代码。
  
• PyCharm 内置了强盛的调试器和测试工具，支持图形化界面举行断点设置、变量查看和测试运行，简化了调试和测试过程。
  
• PyCharm 集成了 Git、SVN 等版本控制体系，方便开辟者举行代码版本管理。
  
• PyCharm 提供了数据库工具，支持连接和操作数据库，方便举行数据库开辟。
  
• PyCharm 支持长途开辟，可以连接到长途服务器举行开辟和调试。
  
• PyCharm 拥有一个丰富的插件市场，用户可以根据需要安装各种插件来扩展 IDE 的功能。
  
• 除了 Python，PyCharm 还支持其他语言，如 JavaScript、TypeScript、HTML、CSS 等，得当全栈开辟。
  
• PyCharm 提供了免费的社区版和付费的专业版，社区版已经包含了大部分常用功能，而专业版则提供了更多高级特性。
  
• PyCharm 的用户界面设计直观，易于上手，纵然是初学者也能快速适应。
  
• PyCharm 连续优化性能，确保在处置惩罚大型项目时也能保持良好的响应速率。
  

Pycharm有一个十分美满的Python编译情况，所以使用Pycharm可以让我们的代码编写变得更加便捷，所以Pycharm的下载还是十分有必要的。
Pycharm可以直接从Pycharm官网上下载，也可以直接从网盘里下载，然后里面有安装教程，小白兔都已经提供了。

说实话，安装的步调很繁琐，但是俗话说的好嘛——“工欲善其事必先利其器”。所以先别开小差，重头戏如今才开始！！
           到这里你的前期工作就已经完成了，下面就可以开始基础地学习python的基础内容了，以下所教学的内容主要是帮助你们能看懂python的代码，和简朴语句的书写。
  三、Python——基础知识

3.1解释：

    解释主要有两种情势：
        单行解释：#往后的内容都是解释内容
          多行解释：
                          """
                          中间全部的内容都是解释内容。        
                          """
   这是单行解释：

1. #这里是注释内容

复制代码

这是多行解释：

1. """
2. 这是第一行注释
3. 这是第二行注释
4. """

复制代码

然后还有一个就是在PyCharm里面用 Ctrl+/ 可以对选定的全部行 举行单行解释 和 取消解释。
 3.2变量：

这部分实在和其他语言都是一样的，但Python能支持中文定名，虽然一样平常都不会去使用。
Python 变量定名遵照一些基本规则和约定：

• 标识符必须以字母或下划线开头：变量名的第一个字符必须是字母（a-z，A-Z）或下划线（_），不能以数字开头。
  
• 标识符只能包含字母、数字和下划线：变量名可以包含字母、数字（0-9）和下划线（_），但不能包含空格、标点符号或特别字符。
  
• 区分大小写：Python 是区分大小写的编程语言，这意味着 Variable 和 variable 是两个差别的变量名。
  
• 保留关键字：不能使用 Python 的保留关键字作为变量名，例如 if、for、while、def 等。
  
• 避免使用特别方法名：尽管技术上可以，但最好避免使用 Python 的特别方法名（如 __init__、__del__ 等）作为变量名。
  
• 可读性和描述性：变量名应该具有描述性，可以或许清楚地表达变量的用途或存储的数据范例，以提高代码的可读性。
  
• 使用下划线分隔单词：在 Python 中，变量名通常使用下划线分隔单词，这被称为“snake_case”风格。
  
• 避免使用缩写：除非缩写是广泛承认的，否则最好使用完整的单词来提高代码的清楚度。
  
• 同等性：在同一个项目中，应该保持变量定名的同等性。
  

这部分和其他语言基本同等就不外多赘述了。
3.3数据范例：

在这里我们先主要讲一下基本数据范例，对于组合数据范例，我们会在下文里详细阐明。
对于整数，它有4种情势：十进制数，二进制数，八进制数，十六进制数

1. a = 123     #十进制
2. b = +123    #十进制
3. c = 0b1111011   #二进制
4. d = 0o173   #8进制
5. e = 0x7B    #16进制

复制代码

  检测数据范例的函数：type()
  然后下面展示一下这几种范例：

1. a = 1
2. print(type(a))  # <class 'int'> -- 整型
4. b = 1.1
5. print(type(b))  # <class 'float'> -- 浮点型
7. c = 12.3+45.6j
8. print(type(c))  #<class 'complex'> -- 复数型
10. d = True
11. print(type(d))  # <class 'bool'> -- 布尔型

复制代码

3.4输入输出：

   这部分主要是两个函数：
输入：input()
  输出：print()
  3.4.1输入：

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

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

复制代码

在这个例子中，程序会显示 "请输入一些内容：" 并等待用户输入。用户输入的文本在按下回车键后会被赋值给变量 user_input，然后程序会继承实验并打印用户输入的内容。
参数
input() 函数可以继承一个可选的字符串参数，这个字符串会作为提示信息显示给用户。

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

复制代码

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

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

复制代码

注意事项

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

3.4.2输出：

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

1. print("Hello, World!")

复制代码

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

1. name = "Alice"
2. age = 30
3. print("Name:", name, "Age:", age)

复制代码

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

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

复制代码

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

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

复制代码

3.4.3格式化输出

print() 函数支持多种格式化字符串的方式：
百分号（%）格式化

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

复制代码

str.format() 方法

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

复制代码

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

1. name = "Alice"
2. age = 30
3. 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语言中的浮点数除法，会有小数位，然后整数除法是 // 是没有小数位的。

1. a = 5
2. b = 2
4. #加
5. print(a+b) # 7
6. #减
7. print(a-b)# 3
8. #乘
9. print(a*b)# 10
10. #整除
11. print(a//b)# 2
12. #取余
13. print(a%b)# 1
14. #除
15. print(a/b)# 2.5
16. #指数
17. print(a**b)# 25
19. #然后对于一些比较特殊的情况，我这边也展示一下，可能并不完全。
20. print(5.0 // 2) # 2.0
21. print(5.0 % 2) #1.0
22. print(5.0 ** 2) #25.0
23. #在这些时候他们的返回值也是浮点型

复制代码

赋值运算符

赋值运算符  =赋值 这个和C语言中类似，我们就不多说了。
复合赋值运算符

复合赋值运算符  符号描述+=加法赋值运算符-=减法赋值运算符*=乘法赋值运算符/=除法赋值运算符%=取余赋值运算符//=整除赋值运算符**=指数赋值运算符 对于这一部分，也是和C语言类似，然后也就是先运算等号右侧的值，然后与左侧的值举行相应运算得出结果。然后在Python中删除了C语言中的单目运算符 ++ 和 -- 也就是自增自减操作，下面举一些例子来展示一下。

1. c = 5
2. d = 5
4. #指数赋值运算符
5. c **= (5-1)/2
6. print(c) #25.0
8. #整除赋值运算符
9. d //= 6-4
10. print(d) #2

复制代码

比较运算符

比较运算符  符号 描述
== 等于。如果两个操作数的结果相等。
则条件结果为真(True)，否则条件结果为假(False)
!= 不等于 。如果两个操作数的结果不相等。
则条件为真(True)，否则条件结果为假(False)
> 运算符左侧操作数结果是否大于右侧操作数结果。
如果大于，则条件为真(True)，否则为假(False)
>= 运算符左侧操作数结果是否大于等于右侧操作数结果。
如果大于，则条件为真(True)，否则为假(False)
< 运算符左侧操作数结果是否小于右侧操作数结果。
如果小于，则条件为真(True)，否则为假(False)
<= 运算符左侧操作数结果是否小于等于右侧操作数结果。
如果小于，则条件为真(True)，否则为假(False)
  这些运算符的使用和C语言中是同等的，那么咱们讲一讲使用时不一样的点，就是说Python中你是可以或许连续使用的，这样说很不直观显着，咱们直接在代码里展示一下。
如果要判断一个 英语字母 是不是 大写，这时候判断条件怎么写？
先来一段C语言的代码：

1. #include <stdio.h>
3. int main()
4. {
5.     char x = 'H';
6.     if (x>='A' && x<='Z') //主要看这里的判断条件
7.     //我们在判断的时候是不是要用 && 将两个判断连起来
8.         printf("YES!!!");
9.     return 0;
10. }

复制代码

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

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

复制代码

这就是一个C语言和Python的小区别。
逻辑运算符

在逻辑运算符这部分，Python和C语言的差异就比较大了，咱们直接和C语言举行类比。
逻辑运算符  符号类比C语言运算符and&& or
||not! 基本效果是一样的，主要就是在写法上面有所区别，相对于C语言使用符号来表达逻辑的情势，Python直接使用了对应寄义的英文单词，让可读性更上一层楼，固然这里不是吹捧，只是在描述一个征象，语言是没有优劣之分的，只有更得当某一方面的说法。
对于这部分逻辑运算符的部分，对于这部分我们需要用到 if 语句，如果不知道寄义的可以先看看下面的分支语句的内容然后在返回看这里的内容，我们也举行简朴的展示。

1. if 10 > 20 and 5 < 10:
2.     print("第一个示例YES!!!") #不会输出
4. if 10 > 20 or 5 < 10:
5.     print("第二个示例YES!!!") # 会输出
7. if not 10 > 20:
8.     print("第三个示例YES!!!") # 会输出

复制代码

然后对于逻辑运算这里，对于C也好Python也好，and和or会有短路举动
   当使用 and 运算符时，如果第一个条件为假（False），则整个表达式的结果已经确定为假，因此 Python 不会评估后续的条件。这是由于 and 运算符要求全部条件都为真，整个表达式的结果才为真。
  
  当使用 or 运算符时，如果第一个条件为真（True），则整个表达式的结果已经确定为真，因此 Python 不会评估后续的条件。这是由于 or 运算符只要有一个条件为真，整个表达式的结果就为真。
  对于这点我们也展示一下。

1. #and的短路行为
3. def run_1():
4.     print("运行了run_1")
6. def run_2():
7.     print("运行了run_2")
9. # 第一个条件为假，因此不会执行第二个条件
10. if False and run_1():
11.     pass
12. else:
13.     run_2()
15. """
16. 上面的语句 不会运行run_1()函数 会运行run_2()函数
18. 下面的语句两个函数都会运行
19. """
21. # if True and run_1():
22. #     pass
23. # else:
24. #     run_2()

复制代码

1. #or的短路行为
3. def run_1():
4.     print("运行了run_1")
6. def run_2():
7.     print("运行了run_2")
9. # 第一个条件为假，因此不会执行第二个条件
10. if True or run_1():
11.     pass
12. else:
13.     run_2()
15. """
16. 上面的语句 不会运行run_1()函数 会运行run_2()函数
18. 下面的语句两个函数都会运行
19. """
21. # if False or run_1():
22. #     pass
23. # else:
24. #     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，本质是差不都的。
然后按照惯例，下面展示一下这个语句的使用方法。

1. #单if语句
2. x = 10
3. if x > 5:
4.     print("x is greater than 5")
6. #if……elif……语句
7. x = 20
8. if x > 30:
9.     print("x is greater than 30")
10. elif x > 10:
11.     print("x is greater than 10 but less than or equal to 30")
13. #if……elif……else……语句
14. x = 20
15. if x > 30:
16.     print("x is greater than 30")
17. elif x > 10:
18.     print("x is greater than 10 but less than or equal to 30")
19. else:
20.     print("x is 10 or less")
22. #if……else……语句
23. x = 5
24. if x > 10:
25.     print("x is greater than 10")
26. else:
27.     print("x is 10 or less")

复制代码

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

1. #嵌套使用
2. x = 5
3. if x > 10:
4.     print("x is greater than 10")
5. elif x > 5:
6.     if x < 8:
7.         print("x is between 5 and 8")
8.     else:
9.         print("x is 8 or greater but less than 10")
10. else:
11.     print("x is 5 or less")

复制代码

4.3循环结构

你玩原神想抽 凌华 ，但是你一直没抽到，但是你不甘心呐，发誓要一直抽一直抽直到抽到老婆为止，无穷无尽直到抽到为止才停下。
Python中循环有两种方式，for循环和while循环。
while循环

咱们先讲一下while循环，这个和C语言里面基本一样平常无二。
   while 循环条件：
          循环体
          ……

1. # 初始化计数器
2. counter = 1
4. # 使用while循环直到计数器达到6
5. while counter <= 5:
6.     print(counter)
7.     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() 函数可以接收一到三个参数，分别是：
  

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

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

1. #只写一个参数，会默认是stop位置的值
2. for i in range(5):
3.     print(i)
4. print("-------------------------")
6. #写两个参数会默认是start和stop的值
7. for i in range(2, 5):
8.     print(i)
9. print("-------------------------")
11. #三个值都写
12. for i in range(1, 6, 2):
13.     print(i)
14. print("-------------------------")
16. #还有一个比较常用的方式就是step的值为负数
17. for i in range(5, 0, -1):
18.     print(i)

复制代码

结果：

1. 0
2. 1
3. 2
4. 3
5. 4
6. -------------------------
7. 2
8. 3
9. 4
10. -------------------------
11. 1
12. 3
13. 5
14. -------------------------
15. 5
16. 4
17. 3
18. 2
19. 1

复制代码

---

然后是第二种方式，它是一种内容循环，从字符串、列表、字典等内容中逐个索取元素对i赋值举行遍历。
对于这种方式咱们在背面讲这些数据结构的时候再细说。

---

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

1.break
强行跳出该循环，在循环中一旦实验这个函数会直接跳出该循环。

1. #break
2. for i in range(10):
3.     print(i)
4.     if i == 5:
5.         break
6. """
7. 输出
8. 0
9. 1
10. 2
11. 3
12. 4
13. 5
14. """

复制代码

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

1. #continue
2. for i in range(10):
3.     if i % 2 == 0:
4.         continue
5.     print(i)
6. """
7. 1
8. 3
9. 5
10. 7
11. 9
12. """

复制代码

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

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

1. #enumerate
2. for p, i in enumerate(range(5)):
3.     print(p, i, sep=':')
4. print("----------------------")
6. list = [12, 15, 20, 25, 30, 35]
7. for i, num in enumerate(list):
8.     print(i, num, sep=':')
9. print("----------------------")
11. my_dict = {'a': 1, 'b': 2, 'c': 3}
12. for key, value in enumerate(my_dict):
13.     print(key, value)
15. """
16. 结果：
17. 0:0
18. 1:1
19. 2:2
20. 3:3
21. 4:4
22. ----------------------
23. 0:12
24. 1:15
25. 2:20
26. 3:25
27. 4:30
28. 5:35
29. ----------------------
30. 0 a
31. 1 b
32. 2 c
33. """

复制代码

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

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

1. #zip
2. list1 = [1, 2, 3]
3. list2 = ['a', 'b', 'c']
4. for i, j in zip(list1, list2):
5.     print(i, j)
7. """
8. 结果：
9. 1 a
10. 2 b
11. 3 c
12. """

复制代码

循环中的else

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

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

复制代码

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

复制代码

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

1. #没有break的else
2. count = 0
3. while count < 3:
4.     print(count)
5.     count += 1
6. else:
7.     print("循环正常结束，没有遇到break")
9. """
10. 0
11. 1
12. 2
13. 循环正常结束，没有遇到break
14. """

复制代码

1. #有break的else
2. count = 0
3. while count < 3:
4.     print(count)
5.     count += 1
6.     if count == 2:
7.         break
8. else:
9.     print("循环正常结束，没有遇到break")
11. """
12. 0
13. 1
14. """

复制代码

1. #没有break的else
2. for i in range(3):
3.     print(i)
4. else:
5.     print("循环正常结束，没有遇到break")
7. """
8. 0
9. 1
10. 2
11. 循环正常结束，没有遇到break
12. """

复制代码

1. #有break的else
2. for i in range(3):
3.     print(i)
4.     if i == 1:
5.         break
6. else:
7.     print("循环正常结束，没有遇到break")
9. """
10. 0
11. 1
13. """

复制代码

由于在一样平常的情况不怎么会用，我就不多说这个。
   下面的内容就是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 st2Trues索引。取索引号为i的字符st2[3]或 st2[-4]ds[start:end:step]切片。返回索引号 start 到 end，但不包罗 end 的子串;省略 start表示重新开始，省略 end 表示取到结尾;step 为步长，省略为 1st2[:-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。
下面演示一下这两个：

1. st = 'Python is a good programming language'
2. #索引：
3. print(st[0])
4. print(st[5])
5. print(st[-1])
6. print(st[-4])
8. #切片
9. print(st[:5])
10. print(st[0:5])
11. print(st[1:10:2])
12. print(st[2::2])
13. print(st[::2])
14. print(st[::-1])
15. print(st[::-2])
16. print(st[-5:-1])
19. """
20. P
21. n
22. e
23. u
24. Pytho
25. Pytho
26. yhni
27. to sago rgamn agae
28. Pto sago rgamn agae
29. egaugnal gnimmargorp doog a si nohtyP
30. eaga nmagr ogas otP
31. guag
32. """

复制代码

5.2常用方法

首先，这里提到了一个词——方法。
Python 中每一个数据范例都有一个对应的内置类，每新建一个数据，现实就初始化并天生一个对象。体系为对象提供了一些方法便于功能处置惩罚。
   方法引用格式——字符串对象,方法(参数)
      注意事项    ——方法作用于对象，方法引用的结果，不改变引用对象。
  以下实例中的参数：st='ABC DEFG BC'
字符串常用方法  分类方法描述实例结果统计
查找S.count(c)在字符串中统计 c 出现的个数st.count("B")2S.find(c)在字符串中找第一个出现 c串的位置，找不到返回-1sl.find("BB")-1S.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;否则返回 Falsesl.isalpha()
"asDF".isalpha()False
True 然后对于这部分，内容是比较多的，我主要说几个在爬虫中处置惩罚数据时比较常用的：

1. test='   python is s good language!   '
2. #strip方法：
3. print(test.strip())
4. print(test.lstrip())
5. print(test.rstrip())
6. print("-------------------------------------------------")
8. #replace方法：
9. print(test.replace('python','黑不拉几的小白兔').replace('language','博主'))
10. print("-------------------------------------------------")
12. #split方法：
13. print(test.split(' '))
14. print(test.split(' ')[3])
15. print("-------------------------------------------------")
17. #upper & lower方法：
18. print(test.upper().lower())
19. print("-------------------------------------------------")
21. #find方法：
22. print(test.find('p'))
23. print(test[test.find('p'):]) #取该字符右侧内容
24. print("-------------------------------------------------")
26. #len()函数：
27. print('test的字符长度是：',len(test))
28. print("-------------------------------------------------")
31. """
32. python is s good language!
33. python is s good language!   
34.    python is s good language!
35. -------------------------------------------------
36.    黑不拉几的小白兔 is s good 博主!   
37. -------------------------------------------------
38. ['', '', '', 'python', 'is', 's', 'good', 'language!', '', '', '']
39. python
40. -------------------------------------------------
41.    python is s good language!   
42. -------------------------------------------------
43. 3
44. python is s good language!   
45. -------------------------------------------------
46. test的字符长度是： 32
47. """

复制代码

如果我本日必有一死，那一定是Python

六、列表

这个我自以为是Python中最好用的结构——列表，列表是一个可变数据范例。
6.1列表的创建

(1)使用 “ [ ] ” 建立列表

通过 “ [ ] ” 内不带数据的方式将产生空列表;通过 “ [ ] ” 内以逗号分隔的数据将产生包含数据的列表。列表的元素还可以是列表构成的嵌套列表，如同传统数组中的二维数组。
(2)使用 list 函数建立列表

使用 list 函数也可以建立空列表、有数据列表，还可以将其他数据范例转换成列表，甚至还可以天生由 range 函数产生的有序序列。
下面展示一下两种创建方法：

1. """
2. 列表创建
3. """
4. #直接用[]进行创建
5. lst = [] #空列表创建
6. lst1 = ['dsa', 123, 'sda', [13, 'dsd']]
7. print(lst1)
9. #使用list 函数
10. lst = list() #空列表创建
11. lst2 = list("hello")
12. lst3 = list(range(10))
13. print(lst2)
14. print(lst3)
15. #这里比较常见的比如说和map(), input()函数结合使用
16. lst4 = list(map(str, input().split()))
17. print(lst4)
20. """
21. ['dsa', 123, 'sda', [13, 'dsd']]
22. ['h', 'e', 'l', 'l', 'o']
23. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
24. 123 sad d155 dsa 这里是输入
25. ['123', 'sad', 'd155', 'dsa']
26. """

复制代码

6.2列表的访问

列表中的每个元素都有对应的索引号，用正向索引或者反向索引可以访问列表中的元素，这点与字符串操作是同等的。
   (1)对一维列表L，元素访问格式为：
L[索引]
    (2)对二维列表 L的每个元素，可以为每个维度使用一个[]，元素访问格式为
L[行索引] ------------->这是索引列表内的某一个列表
L[行索引][列索引]--->这是索引列表内某一个列表的值

1. """
2. 列表访问
3. """
4. lst5 = ['dsa', 123, 'sda', [13, 'dsd']]
5. print(lst5[0])
6. print(lst5[3])
7. print(lst5[3][0])
8. print(lst5[-3])
11. """
12. dsa
13. [13, 'dsd']
14. 13
15. 123
16. """

复制代码

6.3列表遍历

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

1. lst6 = ["I", "am", "a", "Bunny", "Girl"]
2. for i in range(len(lst6)): #len函数是获取长度，在后面会详细说的
3.     print(lst6[i])
4. print("-------------------------------------")
6. for i in lst6:
7.     print(i)
8. print("-------------------------------------")
10. for i, item in enumerate(lst6):
11.     print(i, item)

复制代码

结果： 

1. """
2. I
3. am
4. a
5. Bunny
6. Girl
7. -------------------------------------
8. I
9. am
10. a
11. Bunny
12. Girl
13. -------------------------------------
14. 0 I
15. 1 am
16. 2 a
17. 3 Bunny
18. 4 Girly
19. """

复制代码

6.4列表的常用操作

（1）切片

   列表切片是指从 列表的片段中 取出形成列表，其格式为：
列表[start:end:step]
  作用:取列表中左闭右开的片段。在Python中险些全部的范围都是左闭右开。
  省略start则为0； 省略end 取到列表最后省略； step 则步长为1；
  全部省略取全部列表。
  在这里，我们要提一下string字符串，列表切片与字符串切片关键差别之处 —— 列表切片有赋值操作而字串没有。
由于字符串是不能被修改的，所以不可以对字符串举行切片赋值操作。而列表是可修改的，通过切片赋值操作，方便实现对列表插入、删除、修改等护操作。
那么我们看一下列表的切片操作吧！~

1. lst7 = [10, 20, 30, 40, 50]
2. print(lst7[1:4:2])
3. print(lst7[1:4])
4. print(lst7[1::2])
5. print(lst7[:5:2])
6. print(lst7[::2])
7. print(lst7[::])
8. print("-------------------------------------")
10. #可以使用切片实现以下操作
11. #插入操作， 会覆盖切片范围内的内容，再添加上新的内容
12. lst7[1:1] = [1, 2, 3, 4] #由于切片区域没有数据，所以没有内容被覆盖
13. print(lst7)
14. lst7[1:2] = [5, 6, 7, 8] #会将索引值为 1 位置的数删除，然后添加上新数据
15. print(lst7)
16. print("-------------------------------------")
18. #删除，其实和插入操作类似，只是将插入的列表设置为空
19. lst7[1:8] = []
20. print(lst7)

复制代码

结果：

1. """
2. [20, 40]
3. [20, 30, 40]
4. [20, 40]
5. [10, 30, 50]
6. [10, 30, 50]
7. [10, 20, 30, 40, 50]
8. -------------------------------------
9. [10, 1, 2, 3, 4, 20, 30, 40, 50]
10. [10, 5, 6, 7, 8, 2, 3, 4, 20, 30, 40, 50]
11. -------------------------------------
12. [10, 20, 30, 40, 50]
13. """

复制代码

（2）运算

大佬们，1+1等于多少？
2？不对喔，是11。
这是曾经网上的一个段子，但是在Python中的列表它是对的喔~
list 里有三个运算：
   连接“+”、复制“*”、测试“in”
  我们来看看Python里面怎么让1+1变成11吧！~

1. # 连接 “+”
2. lst8 = [1] #1
3. lst9 = [1] #1
4. print(lst8 + lst9) # 1+1 = 11咯
6. # 复制“*”
7. lst10 = [1, 2, 3]
8. print(lst10 * 3)
10. # 测试“in”
11. lst11 = [1, 2, 3, 45648, 498, 156, 3, 156, 65, 1531, 35, 1, "dsa", "31"]
12. if 31 in lst11:
13.     print("yes")
14. else:
15.     print("no")
16. if 45648 in lst11:
17.     print("yes")
18. else:
19.     print("no")

复制代码

 结果：

1. """
2. [1, 1]
3. [1, 2, 3, 1, 2, 3, 1, 2, 3]
4. no
5. yes
6. """

复制代码

（3）删除

如果有个人你不想见到了，你会怎么做，没错给他微信删了！！
在 list 里如果有个元素你不想要了，也是可以直接删除的。
   del 列表
del 列表[索引]
作用:“del 列表”语句用于删除整个列表,“de! 列表[索引]”语句用于删除列表中的元素。

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

复制代码

结果：

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

复制代码

6.5列表的常用函数

   (1)、若列表中的元素是字符串，求最大值是按元素首字母举行比较，大者则该元素大;否则再按第2个字符举行比较，直到比出大小。求最小值和排序均按此规则。
(2)、函数操作结果有返回值，但不会改变参数中的值
  常用函数  分类函数寄义统计max(L)返回列表中最大值min(L)返回列表中最小值len(L)返回列表长度sum(L)返回列表各元素和排序sorted(L)返回排序后的列表，默以为升序;如有reverse=True参数，则为降序 （1）max() && min() && sum() && len()

1. lst13 = [1, 2, 3, 15, 49, 6, 1, 8, 13]
2. lst14 = ['bunny', 'girl', 'breakfast', 'lunch', 'noodle', 'dinner']
3. lst15 = [[1, 2, 3], 4, 5, [6, 7, 8, 9]]
4. print(max(lst13))
5. print(max(lst14))
7. print(min(lst13))
8. print(min(lst14))
10. print(len(lst13))
11. print(len(lst14))
12. print(len(lst15)) #可以想一下这个是多少哦
14. print(sum(lst13))

复制代码

结果：

1. """
2. 49
3. noodle
4. 1
5. breakfast
6. 9
7. 6
8. 4
9. 98
10. """

复制代码

（2）sorted()

在sorted里面有两个关键字：key、reverse
   对于key关键字：通过关键字 key 确定内嵌的一维列表的某个元素，排序时一样平常通过 key 指定的lambda函数举行。
  对于reverse关键字：通过它来举行 升序 和 降序 的修改。

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

复制代码

 结果：

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

复制代码

（3）zip() 和 enumerate()

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

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

  
  enumerate()
  

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

  

1. lst18 = [1, 2, 3]
2. lst19 = ['a', 'b', 'c']
3. zipped = zip(lst18, lst19)
4. print(list(zipped))
5. print("-------------------------------------")
7. lst20 = ['apple', 'banana', 'cherry']
8. enumerated = enumerate(lst20)
9. print(list(enumerated))
13. """
14. [(1, 'a'), (2, 'b'), (3, 'c')]
15. -------------------------------------
16. [(0, 'apple'), (1, 'banana'), (2, 'cherry')]
17. """

复制代码

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 的删除。
  方法的使用和函数使用类似，所以就简朴展示一下——
 

1. lst21 = [11, 23, 423]
2. lst21.append(18)
3. print(lst21)
4. lst21.append([21, 231]) #它能够在列表中添加上列表等，作为一个独立的元素处在列表中
5. print(lst21)
6. """
7. [11, 23, 423, 18]
8. [11, 23, 423, 18, [21, 231]]
9. """
10. print("-------------------------------------")
12. lst22 = [12, 20, 43, 10, 8, 19, 97, 20]
13. lst22.sort(reverse=False) #默认是递增顺序，可以用reverse关键字改变
14. print(lst22)
15. """
16. [8, 10, 12, 19, 20, 20, 43, 97]
17. """
18. print("-------------------------------------")
20. lst23 = [1, 2, 3, 2, 1, 3, 2, 1, 1]
21. print(lst23.count(1))
22. print(lst23.count(2))
23. print(lst23.count(3))
24. """
25. 4
26. 3
27. 2
28. """
29. print("-------------------------------------")
31. lst24 = [1, 2, 3]
32. lst24.extend([4, 5, 6])
33. print(lst24)
34. """
35. [1, 2, 3, 4, 5, 6]
36. """
37. print("-------------------------------------")
39. lst25 = [1, 2, 3, 21, 23, 43, 21]
40. print(lst25.index(21))
41. """
42. 3
43. """
44. print("-------------------------------------")
46. lst26 = [1, 2, 3, 4, 5, 6, 7]
47. lst26.insert(3, 123)
48. print(lst26)
49. """
50. [1, 2, 3, 123, 4, 5, 6, 7]
51. """
52. print("-------------------------------------")
54. lst27 = [1, 2, 54, 47, 523, 6, 7]
55. lst27.reverse()
56. print(lst27)
57. """
58. [7, 6, 523, 47, 54, 2, 1]
59. """
60. print("-------------------------------------")
62. lst28 = [10, 20, 30, 40, 50, 60, 70]
63. lst28.pop(3)
64. print(lst28)
65. lst28.pop()
66. print(lst28)
67. """
68. [10, 20, 30, 50, 60, 70]
69. [10, 20, 30, 50, 60]
70. """
71. print("-------------------------------------")
73. lst29 = [10, 20, 30, 40, 50, 60, 70]
74. lst29.remove(20)
75. print(lst29)
76. """
77. [10, 30, 40, 50, 60, 70]
78. """

复制代码

6.7列表推导式

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

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

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

复制代码

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

复制代码

带有条件的列表推导式

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

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

复制代码

1. """
2. [0, 4, 16, 36, 64]
3. """

复制代码

嵌套的列表推导式

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

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

复制代码

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

复制代码

不可，要长脑筋了

 列表的内容很多，大家可以徐徐学，徐徐试试。
七、字典

字典你真别说，它在爬虫里似乎很好用，毕竟是一个哈希存储的数据范例，可以或许在大量数据里直接找到所需要的内容。
   字典的对象使用大括号{}将元素列出。
  
  字典的元素排列并没有一定的顺序，由于可以使用键值来取得该元素。
  
  不允许同一个键值多次出现。创建时如果同一个键值被赋值多次，那么只有最后一 个值有效，前面重复的键值将会被自动删除。
  
  由于字典键值必须不可变，所以可以用数字、字符串或元组充当，列表则不可。如果用列表做键值，将会报错。
  1.字典的初始化

   1.直接用 { } 将内容括起来
  2.用 dict( ) 函数将列表转换成字典

1. dic1 = {'cat': 10, 'dog': 20}
2. print(dic1)
3. # {'cat': 10, 'dog': 20}
4. temp_keys = ['cat', 'dog']
5. temp_values = [10, 20]
6. dic2 = dict(zip(temp_keys, temp_values))
7. print(dic2)
8. # {'cat': 10, 'dog': 20}

复制代码

2.字典的操作

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

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

1. dic3 = {'cat': 10, 'dog': 20}
2. print(dic3['cat'])
3. # 10
4. print(dic3['rabbit'])
5. # KeyError: 'rabbit'

复制代码

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

   dic[key] = value
  当key在字典中存在，就是修改
  若不存在，就是添加

1. dic4 = {'cat': 10, 'dog': 20}
2. dic4['dog'] = 30
3. dic4['rabbit'] = 40
4. print(dic4)
5. # {'cat': 10, 'dog': 30, 'rabbit': 40}

复制代码

（3）删除字典中的元素

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

1. dic5 = {'cat': 10, 'dog': 20}
2. del dic5['dog']
3. print(dic5['dog'])
4. # KeyError: 'dog'

复制代码

 3.字典内置函数

内置函数包罗 —— 
   len()        str()        type()
  这些不怎么常用，用处也和前面的类似，下面简朴看看怎么用。

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

复制代码

4.字典内置方法

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

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

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

复制代码

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

   get(k [, d])：k 是字典的索引值，d 是索引值的默认值。如果 k 存在，就返回其值， 否则返回 d。
  
  update(E)：E 是字典对象，由字典对象 E 来更新此字典。
  
  setdefault(k [, d])：k 是字典的键值，d 是键值的默认值。如果 k 存在，就返回其值； 否则返回 d，并将新的元素添加到字典中。

1. dic7 = {'cat': 10, 'dog': 20, 'rabbit': 30}
2. print(dic7.keys()) #返回值储存在列表中
3. print(dic7.values())
4. print(dic7.items())
5. """
6. dict_keys(['cat', 'dog', 'rabbit'])
7. dict_values([10, 20, 30])
8. dict_items([('cat', 10), ('dog', 20), ('rabbit', 30)])
9. """dic8 = {'cat': 10, 'dog': 20, 'rabbit': 30}print(dic8.get('cat'))print(dic8.get('cow', 'haha')) #当get的内容不存在时，不会报错"""10haha"""dic8.update({'dog' : 50})print(dic8)# {'cat': 10, 'dog': 50, 'rabbit': 30}print(dic8.setdefault('cat'))print(dic8.setdefault('cow', 100))"""10100"""

复制代码

（3）copy() & clear()

1. dic9 = {'cat': 10, 'dog': 20, 'rabbit': 30}
2. dic10 = dic9.copy()
3. print(dic10)
4. # {'cat': 10, 'dog': 20, 'rabbit': 30}
5. print("---------------------------------------")
7. dic10.clear()
8. print(dic10)
9. # {}

复制代码

（4）pop() 

   popitem()：删除字典中的最后一个元素。
  pop(k)：删除键为k的这个键值对

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

复制代码

八、元组

这个范例说实话很少用，这边就简朴带过一下。
首先对于元组这个范例，它是一个不可变对象，它的这个性质导致它很少会用到，可能在某些特别时候，你包管一些数据就是不会被修改的时候才会用到它吧。

---

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

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

1. tup1 = (10,)
2. print(tup1, type(tup1))
3. #(10,) <class 'tuple'>
4. tup2 = (10)
5. print(tup2, type(tup2))
6. #10 <class 'int'>

复制代码

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

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

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

复制代码

3. 删除元组内的对象

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

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

复制代码

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

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

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

复制代码

5. 组合元组

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

1. tup6 = (10, 20)
2. tup7 = ('black', 'bunny', 'girl')
3. print(tup6 + tup7)
4. # (10, 20, 'black', 'bunny', 'girl')

复制代码

6. 删除整个元组

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

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

复制代码

7.内置函数

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

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

复制代码

九、聚集

这个也不常使用，也简朴了解一下吧。
聚集是由无序且不重复的元素组成的可变序列。可以使用花括号{}或者set()函数来创建聚集。
1.聚集的初始化

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

复制代码

2.聚集的操作

（1）添加操作

使用add方法。

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

复制代码

（2）删除操作

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

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

复制代码

（3）并集 & 交集 & 差集

   并集 ： 使用union()方法或者|运算符可以获取两个聚集的并集
  交集 ：使用intersection()方法或者&运算符可以获取两个聚集的交集
  差集 ：使用difference()方法或者-运算符可以获取两个聚集的差集

1. set1 = {1, 2, 3}
2. set2 = {3, 4, 5}
3. u_set1 = set1.union(set2)
4. print(u_set1)  # 输出 {1, 2, 3, 4, 5}
6. # 或者使用 | 运算符
7. u_set2 = set1 | set2
8. print(u_set2)  # 输出 {1, 2, 3, 4, 5}
10. i_set1 = set1.intersection(set2)
11. print(i_set1)  # 输出 {3}
13. # 或者使用 & 运算符
14. i_set2 = set1 & set2
15. print(i_set2)  # 输出 {3}
17. d_set1 = set1.difference(set2)
18. print(d_set1)  # 输出 {1, 2}
20. # 或者使用 - 运算符
21. d_set2 = set1 - set2
22. print(d_set2)  # 输出 {1, 2}

复制代码

十、txt文本操作

这部分我们在后续爬虫爬取内容的时候，会很常使用到，但是不用担心学不会，用多了就能记住，在本篇里面不要求把握的很好。
如果希望爬虫趴下来的内容仍然可以或许生存， 需要使用其他的生存方式，文件就是一个很好的选择。在程序运行过程中将数据生存到文件中， 程序运行结束后，相干数据就生存在文件中了。
   1.open
2.with
  
w  只写
r  只读
a  只写追加
+  可读可写

1. #简单方式
2. file=open('test.txt','a+',encoding='utf8')
3. for i,line in enumerate(file.readlines()):
4.     print(i,line.strip())
5. file.close()
7. #自开合
8. with open('test.txt', 'w', encoding='utf8') as f:
9.     f.write("这是自开合里边写的")

复制代码

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

 很多多少很多多少，要死掉了啦

 总结

本篇内容很多吧，信赖开头小白兔说的，这篇 很多很难写 的话吧，大家徐徐学徐徐看，也可以给小白兔一些时间预备下一篇的内容，对于这个专栏的内容可能更新速率会比较慢，小白兔想要好好写爬虫这个专栏，想要让它成为我的一个得意之作。
在这里，我把本期里所写的代码以及pycharm的下载等内容的下载链接都放在下方 
下载链接

pycharm

链接：https://pan.quark.cn/s/a96a9f69de06
提取码：pyhp
示例代码

链接：https://pan.quark.cn/s/84de7213246c
提取码：kbDA

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。