Python 基础教程

第一章 Python简介

大家好！我是 AI 大学堂的宋老师，非常开心在这里和各位朋友们见面，我将陪伴大家开启 Python 启航之路，希望各位朋友都可以掌握 Python，实现自己的学习目标！

首先做一下自我介绍，我叫宋伟，AI 大学堂高级讲师，十余年人工智能及大数据开发经验，精通 Python，内部培训 Python 工程师数百人。

千里之行，始于足下，只有把基础打牢，才能更好的利用 Python 去解放双手，提高效率！本次课程是 Python 基础课程，会将 Python 的基础语法逐一的介绍给大家，大家学会之后，可以掌握 Python 编程思维、语法规则，为后续成为爬虫工程师、数据分析师、人工智能算法工程师等打下坚实基础。

#1 Python 是什么？

介绍 Python 之前，我们先来介绍下什么是编程语言。

要让计算机为我们干活，需要给计算机下指令，编程语言便是用来编写让计算机干活的指令的语言。

举个做菜的例子，假设现在需要厨师做一道西红柿炒鸡蛋，在这里厨师便相当于计算机，菜谱便相当于给计算机下的指令，计算机依据我们下达的指令来完成某项任务便相当于厨师依据菜谱做出西红柿炒鸡蛋这道菜。

人们通过编程语言给计算机下达指令，计算机一一的响应执行，编程语言可以理解为人与计算机之间沟通的一种语言。

Python 就是一种编程语言，它是吉多·范罗苏姆（Guido van Rossum）在 1989 年的圣诞节期间，为了打发时间而编写的一个编程语言。（牛人就是牛人，打发时间的空隙可以开发出一门语言）。

之所以选中 Python 作为编程的名字，是因为他是 BBC 电视剧——《蒙提·派森的飞行马戏团》（Monty Python’s Flying Circus）的爱好者。

Python 是一种易于学习又功能强大的编程语言。它提供了高效的高级数据结构，还能简单有效地面向对象编程。Python 优雅的语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的理想语言。

Python 解释器及丰富的标准库，提供了适用于各个主要系统平台的源码或机器码，这些可以到 Python 官网 https://www.Python.org/ (opens new window)免费获取，并可自由地分发。许多免费的第三方 Python 模块、程序、工具和它们的文档，也能在这个网站上找到对应内容或链接。

Python 解释器易于扩展，可以使用 C 或 C++ 扩展新的功能和数据类型。

近年来，随着人工智能技术及应用的普及，Python 得到了越来越广泛的应用。从 TIOBE 语言排行榜的趋势可见一斑。2018 年以来，Python 在排行榜上一直处于上升的趋势。

上面我们简要介绍了 Python 是什么，下面我们用一道简单的题目来检验下自己的掌握情况吧：

吉多·范罗苏姆（Guido van Rossum）是在哪一年编写的 Python？

A. 1988

B. 1989

C. 1900

D. 1901

正确答案：B

选A信息提示：正确答案是1989年哦，同学要认真学习哟！ 选B信息提示：选择正确哦，Python是1989年被编写出来的！ 选C信息提示：正确答案是1989年哦，同学要认真学习哟！ 选D信息提示：正确答案是1989年哦，同学要认真学习哟！

下面，我们继续来看下强大的 Python 可以做些什么？

#2 Python 能干什么？

Python 拥有强大的生态，使得它能够在很多领域得到广泛的应用，下图是 Python 可以应用的一些典型的领域。

数据分析和自动化办公：

Python 适用范围非常广泛，各个领域的人群均可以使用 Python 进行数据分析及自动化办公，提高 Excel、Word 等办公必备软件的使用效率，在讯飞 AI 大学堂的培训里，我们也会针对财务和人力员工进行针对性的 Python培训，主要目的是提高大家的工作效率。通过以往举办的培训情况来看，人均工作效率至少提升 10 倍，下图为我们的财务和人力员工在课程中利用 Python 完成的作业展示，大家都表示，之前需要花费 3 天时间去处理的表格，现在只需要 30 分钟就可以完成了！工作效率提升了，加班变少了，竞争力变强了，有了更多升职加薪的机会，心情也变得更好了！！

网络爬虫：

Python 的另一个广泛应用就是网络爬虫，网络爬虫就是通过程序去获取 Web 页面上自己想要的数据，也就是自动抓取数据，你可以用爬虫去爬取图片，爬取视频等，只要能通过浏览器访问的数据都可以通过爬虫获取，大家经常使用的搜索引擎就是爬虫的典型应用哦，比如大家搜索“讯飞 AI 大学堂”，搜索引擎就会全网搜索讯飞 AI 大学堂相关的词条，最终将“讯飞 AI 大学堂”匹配度较高的网页显示出来，Python 非常适用于爬虫，学习过程也是趣味性很强，非常享受的一个过程，下面这张图就是我们的实习生小蕊爬取豆瓣《我的姐姐》的影评做出的词图，是不是特别精美，你也想跃跃欲试了呢，跟着课程打下良好 Python 基础，实现这些都是分分钟！

Web开发、游戏开发：

学好 Python，也可以进行 Web 及游戏的开发，Python 实现的 Web 开发及游戏开发对新手非常友好，具有易上手、快速开发等优势，就业前景非常广。

人工智能：

近几年 Python 出圈的主要原因就是人工智能了，Python 是最适合人工智能的一门编程语言，当前，人工智能正处于第三次发展浪潮，人工智能正在像水和电一样融入千家万户，我们现在已经能够感知到人工智能在我们生活中方方面面的应用，手机语音助手、商场的导购机器人、家庭里的智能电器、精通多国语言的翻译机、智慧交通系统、智慧教育、智能医疗，无人驾驶等等，这些都可以通过 Python 语言来实现，掌握了 Python 就掌握了人工智能的敲门砖，顺利进入人工智能行业。

而 Python 不但应用领域广泛，还得到众多大厂的青睐，下图中的 10 家公司都大量地应用 Python 语言进行数据分析、爬虫和 Web 开发，以及人工智能领域的开发，有大量的爬虫工程师、Python 开发工程师等职位。​

既然这么多大厂都在大量地使用 Python，所以学好了 Python，不愁找不到好的工作。

介绍完 Python 的众多应用之后，各位小伙儿更想去实现 Python 的哪一个应用呢？

A.数据分析

B.自动化办公

C.爬虫

D.人工智能

E.Web 开发

F.没有明显目标，想学习进行自我提升

（选A-E）非常棒哦，Python 基础是实现该应用的地基，加油学习哦！

（选F）学好Python基础，更好的实现自我提升！

我们接下来一起感受下 Python 之禅（此部分内容是 Python 优于其他编程语言的地方，感兴趣的朋友们可以仔细看下哦）。

#3 Python 之禅

Python 的设计哲学强调代码的可读性和简洁的语法，尤其是使用空格缩进划分代码块。相比于 Java，Python 让开发者能够用更少的代码表达想法。不管是小型还是大型程序，该语言都试图让程序的结构清晰明了。下面的 Python 之禅（The Zen of Python）列出了 Python 所提倡的一些编程理念（进入到 Python 的命令行界面，输入 import this 便可以看到下面的文字）。Python 之禅的内容其实已经超越了编程语言的范畴，它所提倡的一些理念在现实生活中同样适用。

感受完 Python 的魅力之后，我们正式开启 Python 基础语法的学习！

#4 print() 函数

对 Python 编程语言有了基本的了解之后，我们来看如何使用 Python 提供的 print() 函数将内容打印到屏幕上。

我们希望自己永远 18 岁，我们试下下方语句，点击运行：

print(18)

我们看到点击运行之后，屏幕上出现了 18。

我们仔细看左边的这个语句，18 是在 print() 中的，通过 print() 函数将 18 打印出来，print() 函数是 Python 中的信息输出函数，通过 print() 这一指令，将 () 内的内容打印出来。 

大家可以将 print(18) 这条语句复制到编辑框中，点击运行感受下 print() 函数。

#5 引号的作用

下面，大家可以运行下 print(50+50)，结果是 100，由此，我们看到print()函数不仅能够识别数字，还可以识别数学公式，但是有些情况下，我们希望直接将这个数学公式打印出来，这个时候要怎么办呢？在 Python 的世界里，可以巧妙的利用引号（单引号''、双引" "、三引号''' '''）来实现，我们一起来看下方语句：

print('50+50')，点击运行之后，我们看到屏幕上显示的就是数学算式，而两个语句的区别就在于是否添加了引号，特别注意，Python 中所有英文及数字和标点的输入都要是英文状态下的哦!

我们总结一下：

在 Python 中，我们使用引号来直接打印想要输出的信息，如果输出的信息需要经过计算机的处理，则不使用引号，让 print()函数打印出经过计算机运算处理过的信息。

下面，通过一个题目，我们来自测下本部分内容的掌握情况：

下列哪项语句可以输出 2：

A.print(1+1)

B.print(‘1+1’)

选A，恭喜你，引号的作用掌握的很好哦

选B，差一点就正确啦，可以再回顾下上部分内容哦

再次提醒大家，Python 中的括号、引号都要是英文状态下的哦

#6 转义字符

我们点击下方语句：

print("Twinkle, twinkle, little star, How I wonder what you are! Up above the world so high, Like a diamond in the sky. Twinkle, twinkle, little star, How I wonder what you are!")

上方语句打印出了《一闪一闪亮晶晶》的英文版本，我们看到歌词并没有按照每句歌词进行分行显示，很难分辨清不同歌词的位置，有什么方法可以使每句歌词分行显示么，当然是有啦！

这就要使用到转义字符\n，大家点击运行下方语句：

print("Twinkle, twinkle, little star, \nHow I wonder what you are! \nUp above the world so high, \nLike a diamond in the sky. \nTwinkle, twinkle, little star, \nHow I wonder what you are!")

我们看到加了转义字符之后，歌词就可以按照每句歌词分行显示，而每个分行的位置都是 \n 发挥的作用；而我们也看到本条语句 print() 中的引号是双引号，正如我们上方所介绍的，单引号、双引号、三引号的作用是一致的，但有一点需要大家注意的是，引号的使用是需要对称的，两个引号都是单引号，信息是正确的，一个单引号，一个双引号，程序就会报错啦！

转义字符的使用非常简单，大家可以收藏下方的图片，需要使用转义字符的时候拿出来看一看哦！

#7 小结

本节课程内容就到这里了，我们一起来总结下本节知识点：

#8 课后题

1.下列转义字符中表示换行的是：

A.\a

B.\b

C.\n

D.’

2.下列引号的使用符合规范的是：

A.print(‘盘古开天辟地”)

B.print(‘盘古开天辟地’)

C.print(‘盘古开天辟地’)

D.print(“‘盘古开天辟地’)

3.下列哪一项无法打印出 520：

A.print(‘500+20’)

B.print(‘520’)

C.print(500+20)

D.print(520)

4.实战题目：和盘古打招呼

很久很久以前，天和地还没有分开，宇宙混沌一片。有个叫盘古的巨人，在这个混沌的宇宙之中，他睡了十万八千年。有一天，盘古突然醒了。他见周围一片乌漆嘛黑，他就抡起大斧头，朝眼前的黑暗猛劈过去了。只听一声巨响，一片黑暗的东西渐渐分散开了。缓缓上升的东西，变成了天；慢慢下降的东西，变成了地。

时光一晃来到了新时代，你可以用Python和盘古打个招呼哦，使用 print() 打印出：盘古，你好！

第二章变量

大家好，现在要正式开始第二关内容的学习啦，在正式开始学习之前，我们先来回顾下上一关的内容吧！

上一关的最后，我们通过 print()函数实现了和盘古打招呼，本关我们将通过 Python 的力量去感受女娲补天的奇迹。

我们先来看下方语句：

name = '女娲'
print(name)

我们看到屏幕上显示的打印效果是：女娲。

大家可能会有疑问，想实现打印出女娲，直接用 print('女娲') 不就可以实现么？

宋老师这里也非常欣慰哦，小伙伴们对第一章内容的掌握程度真的是非常好呢！要继续加油哦！！

但是我们在实际 Python 的使用中，经常会遇到大量重复的语句，如果使用 print() 函数重复输出的话，如果信息出现了低级的错误，或者是信息需要更新，需要进行信息的更改，都需要修改很多遍，当代码数量非常多的时候，容易出现忘记修改信息等问题，这个时候就需要巧妙的利用变量来解决这个问题。

我们看下方语句：

print('女娲补天之后，天地定位，洪水归道，烈火熄灭，四海宁静。')
print('女娲补天之后，天地定位，洪水归道，烈火熄灭，四海宁静。')
print('女娲补天之后，天地定位，洪水归道，烈火熄灭，四海宁静。')
print('女娲补天之后，天地定位，洪水归道，烈火熄灭，四海宁静。')
print('女娲补天之后，天地定位，洪水归道，烈火熄灭，四海宁静。')

点击运行之后，我们看到显示五段同样的话，“女娲补天之后，天地定位，洪水归道，烈火熄灭，四海宁静。”

这个时候，我们想修改语句，删除掉’洪水归道’ 四个字，大家可以在编译器中，完成 5 段文字’洪水归道’的删除。

print('女娲补天之后，天地定位，，烈火熄灭，四海宁静。')
print('女娲补天之后，天地定位，，烈火熄灭，四海宁静。')
print('女娲补天之后，天地定位，，烈火熄灭，四海宁静。')
print('女娲补天之后，天地定位，，烈火熄灭，四海宁静。')
print('女娲补天之后，天地定位，，烈火熄灭，四海宁静。')

是不是觉得在做重复性的工作呢，而且一个不小心，就有一条语句忘记删除了，这个时候我们可以使用变量来解决这个问题，我们一起来运行下方语句：

life ='女娲补天之后，天地定位，洪水归道，烈火熄灭，四海宁静。'
print(life)
print(life)
print(life)
print(life)
print(life)

如果我们想删除洪水归道，只需要在变量 life 中删除掉洪水归道即可。

life ='女娲补天之后，天地定位，，烈火熄灭，四海宁静。'
print(life)
print(life)
print(life)
print(life)
print(life)

是不是方便了很多呢，上述语句中的 name 和 life 都是变量，下面我们就一起来认识下变量吧：

#1 什么是变量

在程序设计语言中，变量是存储单元的标示牌，在这块存储单元中，可以存储任何值，我们可以通过变量名来访问存储的值。

在上图中，age 是内存地址 0X107A5D960 的标示牌，我们可以通过 age 来访问变量的值 18。

在内存中存储值和我们在日常生活用收纳箱来收纳东西是类似的。在下图中，总共有 5 个抽屉，为 5 个抽屉从上到下分别编号 1、2、3、4、5，编号也相当于是抽屉的地址（和内存地址类似）， 五个抽屉从上到下分别存储了湿巾、毛巾、配饰、玩具、衣服（物品相当于在内存中存储的值），为了以后取东西快捷，我们会为五个抽屉分别写上存储物品的名字（相当于变量名）。这样以后我们在取东西的时候便可以很快的定位到某个抽屉，进而取出东西。

我们来用 Python 语句表示上述内容：抽屉的英文是drawer，我们将第一层抽屉用 drawer1 表示，第二层抽屉用drawer2 表示……第五层抽屉用 drawer5 表示，再将所放置的物品和抽屉进行一一对应：

drawer1 = '湿巾'
drawer2 = '毛巾'
drawer3 = '配饰'
drawer4 = '玩具'
drawer5 = '衣服'
print(drawer1)
print(drawer2)
print(drawer3)
print(drawer4)
print(drawer5)

这些语句中的 drawer1、drawer2、drawer3、drawer4、drawer5 就是变量名称。

上述语句也就是创建五个抽屉变量的过程。

接下来我们详细介绍下 Python 变量的创建。

#2 变量的创建

与其他编程语言不同的是，Python 没有声明变量的命令，首次为其赋值时，才会创建变量。赋值的语法：

#2.1 单变量的赋值

#变量name，表示名字，名字是女娲
name = '女娲'  
#变量age，表示年龄，年龄是18
age = 18   
#打印变量name
print(name)
#打印变量age
print(age)

这个语句中，我们可以看到 name 代表的是名字，age 代表的年龄，变量的名称是和后面要表达的信息内容相匹配的。

我们来运行下方语句：

name = '女娲'
name = '女娲后人'
print(name)

我们看到，打印 name 的结果是女娲后人，并不是女娲了，也就是同一个变量名称，我们对其进行多次赋值的时候，变量会取最后一次的赋值内容。

实践小练习：大家来通过变量打印出自己的名字、年龄和身高吧。

在 Python 的实际应用中，除了简单的单变量赋值外，还会涉及多变量赋值，下面我们就一起来介绍下多变量的赋值。

#2.2 多变量的赋值

在 Python 的应用中，很多情况下，我们需要将同一个值赋给多个变量，下面我们一起来看下一个值是如何赋给多个变量的。在中国民间神话中，女娲在造人之前，于正月初一创造出鸡，初二创造狗，初三创造猪，初四创造羊，初五创造牛，初六创造马，初七这一天，女娲用黄土和水，仿照自己的样子造出了一个个小泥人，她造了一批又一批，觉得太慢，于是用一根藤条，沾满泥浆，挥舞起来，一点一点的泥浆洒在地上，都变成了人。人物 x、人物 y、人物 z 都是女娲造出的泥人，我们将 x、y、z 赋值为泥人，运行下方语句：

#2.2.1 一个值赋给多个变量

x = y = z = '泥人'

print(x)
print(y)
print(z)

我们看到一个值赋给多个变量的时候，可以用赋值符 = 将多个变量连接，如上方语句 x = y = z，再根据单个变量的赋值方法，将泥人赋值于x、y、z，再通过 print() 函数打印出来。

除了一个值赋给多个变量，Python 中还经常会出现，多个值赋给多个变量的情况，下面我们一起来看这种情况是如何赋值的：

#2.2.2 多个值赋给多个变量

我们运行下方语句：

name,age,weight = '女娲',18,49.99

print(name)
print(age)
print(weight)

我们看到屏幕输出女娲、18、49.99，我们将女娲赋给变量 name，18 赋给变量 age，49.99 赋给变量weight，根据我们之前所说的内容，变量的命名要能代表值所表达的内容，因此我们知道本条语句的含义是，名字是女娲，年龄是 18，体重是 49.99。

在编程语言中，我们追求代码的规范，而规范代码的表现之一就是变量名简洁有意义，能够让看到该段代码的人理解代码所表示的含义，那么在变量的命名上体现代码规范的一点就是要选择能够代表赋值内容的变量名，一般是赋值内容对应的英文单词，变量的命名除了这一条规则之外，还有一些其他的要求，我们一起来看下：

#3 变量的命名规则

• 变量名只能包含数字、字母和下划线，也就是只能包含 0-9 、a-z、A-Z 和  _，其余字符都是非法字符。
• 变量名的开头必须以字母或下划线字符开头，不能以数字开头。
• 变量名称区分大小写（name、Name 和 NAME 是三个不同的变量）。
• 如果一个变量名包含多个单词，使用下划线进行分隔，例如：my_name、her_mother 等。
• 为变量起一个有意义的名字，例如：name 优于 n，这一点就是前面我们强调的代码规范性了，用 n 表示名字，从变量的语法命名规则上来看是没问题的，但是却不符合我们的代码规范，宋老师再次提醒大家，养成一个良好的代码习惯，对于我们进阶成为 Python 大神是很有帮助的哦。

除此之外，Python 中还有一组关键字，这些关键字是保留字，不能用作变量名、函数名或任何其他标识符。关键字列表如下：

#4 小结

变量的内容我们介绍完成了，我们一起来总结下本部分内容：

下面，我们来通过一组题目测试下知识点的掌握程度吧！

#5 练习题

1.下列哪个变量名是合法的？

A.na&me

B.2type

C.m@y

D.my_name

2.下列关于变量的命名符合代码规范的是？

A.a = 20

B.weight = 100

C.n = ‘宋老师’

D.xy = ‘你最棒’

3.练习：

创建一个名为 story 的变量，并将 女娲造人的故事 赋给它，最终打印 story 变量。

第三章数据类型

name,age,weight = '女娲',18,49.99
print(name)
print(age)
print(weight)

day = 49
number = 365
print(day)
print(number)

#光速，每秒30万公里
speed_of_light = 300000   
#地球质量，5.97×10²⁴kg
mass_of_earth = 5970000000000000000000000
#地球最深峡谷的海拔，10994m，因在地下，我们这里用负数表示
altitude_of_mariana_trench = -10994
print(speed_of_light)
print(mass_of_earth)
print(altitude_of_mariana_trench)

pi = 3.1415926
negative_pi = -3.1415926

print(pi)
print(type(negative_pi))

day1 = 7
day2 = 7
day = day1 * day2
print(day)

a = 1
b = 1

c = 3.14
d = 2.71

print(a + b)
print(c + d)

a = 1
b = 1

c = 3.14
d = 2.71

print(a - b)
print(c - d)

a = 2
b = 1

c = 3.14
d = 2.71

print(a * b)
print(c * d)

a = 2
b = 1

c = 3.14
d = 2.71

print(a / b)
print(c / d)

a = 10
b = 3

print(a % b)

a = 10
b = 3

print(a ** b)

a = 10
b = 3

print(a // b)

a = 3

print(a)

number = 365
number += 30

print(number)

a = 3
a -= 3

print(a)

a = 3
a *= 3

print(a)

a = 3
a /= 3

print(a)

a = 10
a %= 3

print(a)

a = 10
a **= 3

print(a)

a = 10
a //= 3

print(a)

food_number = 50
drug_number = 200
print(food_number < drug_number)

a = 1
b = 2

print(a == b)

a = 1
b = 2

print(a != b)

a = 1
b = 2

print(a > b)

a = 1
b = 2

print(a < b)

a = 2
b = 2

print(a >= b)

a = 2
b = 2

print(a <= b)

food_number = 50
drug_number = 200
print(food_number < 60 and drug_number > 150)

a = 4
b = 8

print(a > 3 and b < 10)
print(a > 3 and b < 6)

a = 4
b = 8

print(a > 3 or b < 10)
print(a > 3 or b < 6)
print(a > 5 or b < 6)

a = 4
b = 8

print(not(a > 3 or b < 10))
print(not(a > 3 or b < 6))
print(not(a > 5 or b < 6))

print(True and True)
print(True and False)
print(False and False)

print(True or True)
print(True or False)
print(False or False)

print(not True)
print(not False)

print('hello world!')
print("hello world!")

print('''Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.''')

print("""Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.""")

say_hi = "hello world!"

print(say_hi)

star = "NEPTUNE"

print(star[0])
print(star[-1])
print(star[6])
print(star[-7])

star = "NEPTUNE"

# 获取 NEP
print(star[0:3])
# 获取 NEPTUNE
print(star[:])
# 获取 NE
print(star[-7:-5])
# 获取 EPTUNE
print(star[1:])
# 获取 NEPT
print(star[:4])

star = "NEPTUNE"

print(len(star))

star = " NEPTUNE "

print(star)
print(len(star))
print(star.strip())
print(len(star.strip()))

star = "NEPTUNE"

print(star.lower())

star = "neptune"

print(star.upper())

say_hi = "Hello World!"

print(say_hi.replace("World", "Kitty"))

say_hi = "Mercury,Venus,Earth,Mars,Jupiter,Saturn,Uranus,Neptune,Pluto"

print(say_hi.split(","))

book_name = "Men Are from Mars, Women Are from Venus"

is_exist = "Mars" in book_name
print(is_exist)

book_name = "Men Are from Mars, Women Are from Venus"

is_exist = "Mars" not in book_name
print(is_exist)

first_part = "Men Are from Mars"
second_part = "Women Are from Venus"

print(first_part + ', ' + second_part)

name = 'Earth'
age = 4.543E9

print(f"My name is {name}, {age} years old")

print("You're uinique, nothing can replace you.")

print('The man who has made up his mind to win will never say "impossible".')

print('You're uinique, nothing can replace you.')
print("The man who has made up his mind to win will never say "impossible"")

print('You\'re uinique, nothing can replace you.')

print("The man who has made up his mind to win will never say \"impossible\"")

#变量weight1，赋值为整数50
weight1= 50
#变量weight2，赋值为字符串50
weight2 = '50'
#变量weight3，赋值为浮点数50.00
weight3= 50.00
#打印变量weight1的数据类型
print(type(weight1))
#打印变量weight2的数据类型
print(type(weight2))
#打印变量weight3的数据类型
print(type(weight3))

weight1= 50
weight3= 50.00
weight4= int(weight3)
weight5=float(weight1)
print(type(weight1))
print(type(weight3))
print(type(weight4))
print(type(weight5))

num1 = 3
num2 = 50
num3 = 150
print('神农每天品尝 '+str(num1)+' 种草药，品尝了 '+str(num2)+' 天，一共品尝了 '+str(num3) + ' 种草药')

x = 5

x = 5.5

str = "Hello World!"

str = "Hello World!"

str = "Hello World!"

str = "  Hello World!  "

第四章流程控制

今天，我们要进入到第四关内容的学习，流程控制！

在流程控制内容开始之前， 我们一起来回顾下上一关内容：

我们一起进入本次课程内容的学习。

我们一起来了解下牛郎织女的故事：

传说古代天帝的孙女织女擅长织布，每天给天空织彩霞。她讨厌这枯燥的生活，就偷偷下到凡间，私自嫁给河西的牛郎，过上男耕女织的生活。此事惹怒了天帝，把织女捉回天宫，责令他们分离，只允许他们每年的农历七月七日在鹊桥上相会一次。

织女因为厌烦了每天织布的枯燥生活，选择下到凡间。

在我们的生活中，也经常要做大大小小的各种决策。影响我们做出决策的因素有很多，一般是当某些条件满足时，我们会做出决策 A；条件不满足时，做出决策 B。就比如像织女一样，因为感觉到每天织布，生活枯燥乏味，做出了下到凡间的决策；如果生活不枯燥，织女做的决策可能就是还留在天宫快乐地生活。

计算机的执行过程也是类似的，计算机不一定都是从上到下逐条执行指令，有些时候计算机也会对一些条件进行评估，当评估结果为 True 时（满足某些条件），执行某个代码块；当评估结果为 False 时（不满足某些条件），执行另一个代码块。在 Python 中，可以使用 if ... else 语句来完成上述代码流程的控制。

比如：织女厌烦了每天织布的枯燥生活，选择下到凡间。就可以用 if 语句来实现：

# 织女的生活状态是厌烦了每天织布的枯燥生活
living_conditions = '织女厌烦了每天织布的枯燥生活'
if living_conditions == '织女厌烦了每天织布的枯燥生活':
    print('织女下到凡间')

#1 if 语法

#1.1 if

我们一定要注意语法规范：if 条件语句后面要加 :，且是英文状态下的冒号 :，if 后的语句要缩进四个空格，这是因为语句块 1 是在满足 if 条件下要执行的，因此要有缩进。

织女下凡之后，认识了牛郎，也更加注重身材管理，我们通过 if 条件语句来帮助织女更好地进行身材管理吧！

现在我们假设织女的身高是 1.55 米，体重是 65 公斤，通过 BMI 的计算公式，计算出 BMI，依此来判断织女是否超重。

weight = 65
height = 1.55

BMI = float(weight) / (float(height) * float(height))
if BMI >= 25:
    print("BMI=", BMI)
    print("织女体重过重")

我们首先来看上面语句中需要注意的两点：

1. 不要忘记 if 语句后面的冒号:，如果不带冒号会报语法错误。
2. Python 语言通过缩进来标识代码块，在上述例子中，print("BMI=", BMI) 和 print("织女体重过重") 属于同一个代码块，当 if 语句的条件成立时，print("BMI=", BMI) 和 print("织女体重过重") 都会被执行。通过缩进来指定代码块是 Python 的一大特色。

织女每天严格控制体重，但是她希望对自己的体重情况有更清晰的认识，而不是仅仅知道自己的体重是否超重？这个时候我们就可以通过 if...else... 来帮助织女啦！

我们一起看下 if...else... 的语法规则：

#1.2 if...else

我们来进行稍微精细一点的划分，帮助织女更好的掌握自己的体重情况：

织女在知道自己体重过重之后，非常沮丧，沮丧之后重振旗鼓，执行了非常严格的饮食管理和运动，并且咬牙坚持了很长一段时间，终于体重瘦到了 40 公斤，下面我们用 if...else... 语句来帮助织女判断现在她的身材状态：

weight = 40
height = 1.55

BMI = float(weight) / (float(height) * float(height))
if 18.5 <= BMI < 25:
    print("BMI=", BMI)
    print("织女体重正常")
else:
    print("织女体重过重或过轻")

大家一定要记得 if 后面的冒号和 else 后面的冒号，以及 if 条件下的语句块和 else 下的语句块的缩进哟！织女看到结果后，不清楚自己的体重到底是过重还是过轻，我们有什么办法可以帮助她进一步判断么？这个当然有啦！我们可以使用 if...elif...else 语句来解决！

#1.3 if...elif...else

elif 语句块可出现一次或多次。

下面我们针对织女的需求，进行体重过重和过轻的进一步区分：

weight = 40
height = 1.55

BMI = float(weight) / (float(height) * float(height))
if 18.5 <= BMI < 25:
    print("BMI=", BMI)
    print("织女体重正常")
elif BMI < 18.5:
    print("BMI=", BMI)
    print("织女体重过轻")
else:
    print("BMI=", BMI)
    print("织女体重过重")

由于 elif 语句块可出现多次，我们还可以进行细分，帮助织女更详细的掌握自己的体重情况。

weight = 40
height = 1.55

BMI = float(weight) / (float(height) * float(height))
if BMI < 15:
    print("BMI=", BMI)
    print("织女非常严重的体重不足")
elif 15 <= BMI < 16:
    print("BMI=", BMI)
    print("织女严重体重不足")
elif 16 <= BMI < 18.5:
    print("BMI=", BMI)
    print("织女体重过轻")
elif 18.5 <= BMI < 25:
    print("BMI=", BMI)
    print("织女体重正常")
elif 25 <= BMI < 30:
    print("BMI=", BMI)
    print("织女体重过重")
elif 30 <= BMI < 35:
    print("BMI=", BMI)
    print("织女中等肥胖")
elif 35 <= BMI < 40:
    print("BMI=", BMI)
    print("织女严重肥胖")
else:
    print("BMI=", BMI)
    print("织女非常严重肥胖")

#1.4 嵌套 if 语句

由于 if 语句允许嵌套，也就是 if 语句中可以再包含 if 语句，需要注意的是相应的语法规则要对应上（比如 if 语句的冒号、缩进、else 的冒号和缩进等等），所以上述 if 语句后面跟的语句块同样可以包含 if 语句。使用嵌套 if 语句，可以将上述代码改成如下形式：

weight = 40
height = 1.55

BMI = float(weight) / (float(height) * float(height))
if 18.5 <= BMI < 25:
    print("BMI=", BMI)
    print("织女体重正常")
elif BMI < 18.5:
    print("BMI=", BMI)
    if 16 <= BMI:
        print("织女体重过轻")
    elif 15 <= BMI < 16:
        print("织女严重体重不足")
    else:
        print("织女非常严重的体重不足")
else:
    print("BMI=", BMI)
    if BMI < 30:
        print("织女体重过重")
    elif 30 <= BMI < 35:
        print("织女中等肥胖")
    elif 35 <= BMI < 40:
        print("织女严重肥胖")
    else:
        print("织女非常严重肥胖")

我们看到一共有3个 if...elif...else 语句，根据对齐位置判断语句间的关系，这里要再次强调，使用 if 语句的时候，一定不要忘记缩进和冒号哦！

今天的内容就介绍这里啦，我们一起来回顾下：

#2 总结

本节内容，我们主要介绍了流程控制 if 语句、if...else 语句、if...elif...else 语句以及嵌套if语句的用法，在使用这些语句的过程中，我们一定要注意冒号和缩进是不能忘的哦！还有所有的代码都要是英文状态下的哦。

#3 练习题

牛郎织女坚贞的爱情感动了喜鹊，无数喜鹊飞来，用身体搭成一道跨越天河的喜鹊桥，让牛郎织女在天河上相会。下面我们使用 if 语句来判断下鹊桥的长度吧：

如果喜鹊数量小于 1000 只，鹊桥长度为 1 米；喜鹊数量大于等于 1000 只，小于 10000 只，鹊桥长度为 10 米；喜鹊数量大于等于 10000 只，小于 100000 只，鹊桥长度为 100 米；喜鹊数量大于等于 100000只，鹊桥长度大于 100 米！

假定喜鹊数量有四种情况，500只、6000只、20000只、150000只，通过修改喜鹊数量的值来判断鹊桥长度吧！

第五章列表

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']

print(eight_immortal)

eight_immortal1 = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
eight_immortal2 = ['吕洞宾', '何仙姑', '蓝采和', '曹国舅', '汉钟离', '张果老', '韩湘子', '铁拐李']

print(eight_immortal1 == eight_immortal2)

eight_immortal = ['汉钟离', 1, '张果老', 2, '韩湘子', 3, '铁拐李', 4,'吕洞宾', 5, '何仙姑', 6, '蓝采和', 7, '曹国舅', 8]

print(eight_immortal)

eight_immortal1 = ['铁拐李', '铁拐李', '何仙姑', '何仙姑', '蓝采和', '蓝采和']

print(eight_immortal1)

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
print(eight_immortal[3])

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
print(eight_immortal[0])
print(eight_immortal[4])
print(eight_immortal[7])

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
print(eight_immortal[-5])

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
print(eight_immortal[-8])
print(eight_immortal[-4])
print(eight_immortal[-1])

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
print(eight_immortal[3:6])
print(eight_immortal[2:])
print(eight_immortal[:5])
print(eight_immortal[:])

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
print(eight_immortal[-5:-2])
print(eight_immortal[-5:])
print(eight_immortal[:-2])
print(eight_immortal[:])

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
print(eight_immortal[0:7:2])

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
print(eight_immortal[-8:-1:2])

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
print(eight_immortal[::-1])

my_list = ['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']
print(my_list)

my_list = ['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']
print(my_list[0])
print(my_list[1])
print(my_list[1][0])
print(my_list[1][1][0])

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']

eight_immortal[0] = '逍遥闲散'
eight_immortal[5] = '清婉动人'

print(eight_immortal)

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']

eight_immortal[0:3] = ['逍遥闲散', '倒骑毛驴','巧夺造化']

print(eight_immortal)

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']

eight_immortal[0:3] = [10, 20, 30]
eight_immortal[-5:-1] = [40, 50, 60, 70]

print(eight_immortal)

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']

del eight_immortal[1]
print(eight_immortal)

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']

del eight_immortal[0:3]
print(eight_immortal)

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
print(eight_immortal)

eight_immortal += ['容成公', '李耳', '、董仲舒','张道陵','严君平','李八百','范长生','尔朱先生']
print(eight_immortal)

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李']
print(eight_immortal)

eight_immortal.append('吕洞宾')
print(eight_immortal)

eight_immortal.append(['何仙姑', '蓝采和', '曹国舅'])
print(eight_immortal)

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李']
print(eight_immortal)

eight_immortal.insert(3, '吕洞宾')
print(eight_immortal)

eight_immortal.insert(4, ['何仙姑', '蓝采和', '曹国舅'])
print(eight_immortal)

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
print(eight_immortal)

eight_immortal.remove('汉钟离')
print(eight_immortal)

eight_immortal.remove('骆宾王')

eight_immortal = ['汉钟离', '张果老']
print(eight_immortal)

eight_immortal.pop()
print(eight_immortal)

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
print(eight_immortal)

eight_immortal.pop(1)
print(eight_immortal)

eight_immortal = ['汉钟离', '张果老', '韩湘子', '铁拐李', '吕洞宾', '何仙姑', '蓝采和', '曹国舅']
name = eight_immortal.pop(1)
print(name)

第六章循环

在上一关中，我们讲述了如何创建一个列表以及如何访问列表中的元素。

在这一关中，我们会讲述如何使用少量的几行代码来遍历列表，而不用关心列表的长度。

循环使得我们能够对列表中的每个元素执行相同的操作，这样对于任意长度的列表我们都可以很高效地对其进行处理。

远古的时候，大地出现了严重的旱灾。炎热烤焦了森林，烘干了大地，晒干了禾苗草木。原来，帝俊与羲和生了 10 个孩子都是太阳，他们住在东方海外，海水中有棵大树叫扶桑。10 个太阳睡在枝条的底下，轮流跑出来在天空执勤，照耀大地。但有时，他们一齐出来给人类带来了灾难。为了拯救人类，后羿张弓搭箭，向那 9 个太阳射去。只见天空出现爆裂的火球，坠下一只只三足乌。最后，天上只留下一个太阳。

现在需要我们使用循环语句来帮助后羿判断，什么情况下需要后羿保持射箭状态。

我们先来看for循环

#1 for 循环

for 循环用于迭代序列（即列表、元组、字典、集合或字符串等）。这与其他编程语言中的 for 关键字不太相似，而是更像其他面向对象编程语言中的迭代器方法。

通过使用 for 循环，我们可以为列表、元组、集合中的每个元素执行一系列的操作。

#1.1 for 循环语法

#1.2 for 循环流程图

#1.3 实例

我们一起来看一个数字的实例：依次打印出 1~20

# 打印出1-20
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

for var in numbers:
    print(var)

我们也可以在这个基础上进行进一步的数字计算，比如对 1 到 20 的数字进行求和：

# 对 1 到 20 的数字求和
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

count = 0
for var in numbers:
    count += var

print("count = ", count)

我们了解了 for 循环的使用方法之后，我们一起来帮助后羿判断射箭的动作什么时候可以停下来吧？

天空中有 10 个太阳，后羿的任务是要射掉其中的九只，留下一只在天上工作来保障地球的正常运转。也就是说，当天空中太阳数量为 2~10 时，后羿需要保持射箭动作。我们可以将天空中太阳的数量用一个列表sun_in_sky 表示，当太阳数量为2~10时，后羿需要继续射箭！语句如下，我们点击运行：

# 天空中的太阳数量在2-10时，保持射箭！
sun_in_sky = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for i in sun_in_sky:
    if i > 1:
        print("继续射箭 ")

#2 while 循环

我们也可以使用 while 循环来帮助后羿做判断，我们一起先来了解下 while 的语法规则：

while 循环：只要条件满足，就会一直执行一组语句。Python 中，while 表示的信息是当…时候，也就是说当 while 循环的条件满足时，会一直执行满足条件的语句。

#2.1 while 循环语法

在一次循环的过程中，首先会判断 condition 是否为 True。如果为 True，则执行循环体语句。

一次循环结束之后，会继续判断 condition 是否为 True，如果为 True，则继续执行循环体语句；上述过程会一直持续下去，直到 condition 为 False。

#2.2 while 循环流程图

#2.3 实例

和 for 循环一样，我们一起来看下使用 while 循环打印出：1~20。

# 打印1-20
i = 0
while i < 20:
    i += 1
    print(i)

我们继续来看一个复杂一些的例子，对 20 以内的正整数求和：

# 对 20 以内的正整数求和
count = 0
n = 20
i = 1
while i <= 20:
    count += i
    i += 1

print("count = ", count)

了解了 while 循环的语法规则之后，我们一起来看下如何用 while 循环来帮助后羿判断是否需要继续射箭呢？我们来回顾下后羿射箭的条件：当天空中太阳数量为 2~10 时，后羿需要保持射箭动作！

# 当天空中太阳数量为2-10时，大羿需要保持射箭动作！
sun_in_sky = 10
while sun_in_sky > 1:
    sun_in_sky -= 1
    print("继续射箭")

#3 break 和 continue

一般情况下，循环语句会重复执行循环体语句，直到循环条件不满足。但是，在有些情况下，我们需要提前结束本轮循环或者直接结束整个循环。这时候便要用到 break 和 continue 语句。

break 和 continue 语句的使用，通常是与 if 条件语句配合的，当满足 if 条件语句的时候，结束整个循环或者结束本轮循环。

我们一起先来看下 break 语句：

#3.1 break

如果想提前结束整个循环，可以使用 break 语句。

我们一起来看下方例子：对 1 到 20 的数字求和（和为 210），当和大于 100 时，停止求和，退出整个循环。

我们运行下方语句：

#3.1.1 将 break 用于 for 循环

# 对 1 到 20 的数字求和，当和大于 100 时，便停止求和
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

count = 0
for var in numbers:
    count += var
    if count >= 100:
        break

print("count = ", count)

我们看到打印出的结果是 105，我们提取出其中的 for 语句：

3.1.2 将 break 用于 while 循环

我们一起再来看下 while 循环中break 的使用：

# 对 20 以内的正整数求和，当和大于 100 时，停止求和
count = 0
n = 20
i = 1
while i <= 20:
    count += i
    i += 1
    if count >= 100:
        break

print("count = ", count)

我们看到打印的结果还是 105，当 count 值为 105 时，满足条件判断语句 if count >= 100: 执行break，退出整个循环。

在这里还是提醒大家，注意代码规范哟，注意各个语句的缩进，if 语句块是包含在 while 语句块中的，因此if 语句前面有 4 个空白字符，break 语句是在 if 语句下的，因此 break 语句相较于 if 语句前方又有四个空白字符，还有冒号及所有代码都是英文状态下的，这些细节千万不要忽略哈。

#3.2 continue

break 语句是结束整个循环，如果想提前结束本轮循环，可以使用 continue 语句。

#3.2.1 将 continue 用于 for 循环

我们先一起来看下continue 在 for 循环的应用，大家点击运行。

# 对 20 以内的偶数求和
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

count = 0
for var in numbers:
    # 奇数，除以2的余数不为0，也就是不能被2整除
    if var % 2 != 0:
        # 当数字为奇数时，退出本次循环
        continue
    count += var

print("count = ", count)

结果实现了对 20 以内偶数的求和。我们来看这部分的 for 循环语句：

continue 是退出本次循环，当数字为奇数时，则退出本次循环，不执行循环体内的命令；当数字为偶数时，执行循环体内的命令，完成求和。如果在上述语句中，continue 的位置是 break，打印的结果就是0，因为第一次循环 1 就是奇数，不能对 2 整除，直接跳出了整个循环，没有执行 count 变量的求和运算，结果还是count 的原始赋值 0。通过这个例子，希望大家可以分辨清 continue 和 break 循环的语法规则 ，能够灵活运用哦!

#3.2.2 将 continue 用于 while 循环

我们继续来看下continue 在于 while 循环中的应用：

# 对 20 以内的偶数求和
count = 0
n = 20
i = 0
while i < 20:
    i += 1
    if i % 2 != 0:
        continue
    count += i

print("count = ", count)

语法规则是一样的哦，当i是奇数时，退出本次循环，不执行 count += i求和语句，当i为偶数时，则执行求和语句，实现对 20 以内的偶数求和！

#4 总结

我们一起来看下本关总结：

#5 练习题

#5.1 使用 for 配合 continue 求解 20 以内的奇数的和。

#5.2 使用 while 配合 continue 求解 20 以内的奇数的和。

第七章字典

今天要开启第七关啦，在第七关开始之前，我们来回顾下第六关的内容：

第六关中，我们介绍循环语句 for 和 while，以及中断循环语句 break 和 continue。

下面，我们正式开启本关的闯关啦！本关我们将为大家介绍字典：

{'姓名':'张三','年龄':18} 就是一个字典，字典是一系列键值对的集合，姓名:张三 便是一个键值对，其中键为姓名，值为 张三。创建字典时，只需要将键值对用花括号{} 括起来，每个键值对的键和值之间用冒号 : 分隔，每个键值对之间用逗号 , 分隔。

（注意：冒号和逗号均为英文状态下的逗号和冒号）。

我们首先来看字典的创建语法：

#1 字典创建语法

d = {<key>: <value>,<key>: <value>,...<key>: <value>}

用大括号 {} 将键值对括起来，键值对的键和值之间用冒号 : 分隔，键值对之间用逗号 , 分隔。

#2 创建字典

现在我们一起看下字典的创建，哪吒闹海的神话故事大家一定非常熟悉，哪吒自幼喜欢习武，有一天，他同小朋友在海边嘻戏，正好碰上巡海夜叉，与东海龙王三太子出来肆虏百姓，残害儿童。小哪吒见此恶徒，义愤填膺，挺身而出，打死夜叉与三太子敖丙又抽了它的龙筋。东海龙王得知此讯后勃然大怒，降罪于哪吒的父亲，随即兴风作浪，口吐洪水淹没陈塘关。小哪吒不愿牵连父母，于是自己剖腹、剜肠、剔骨，还筋肉于双亲，仙师太乙真人借着荷叶莲花之力，为其脱胎换骨，化作莲花化身的哪吒。后来大闹东海，砸了龙宫，捉了龙王，为民除害。

这里呢，我们拿王者荣耀中哪吒这个英雄的各项属性值来创建一个字典：

属性数据字典：

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}
print(ne_zha)
print(type(ne_zha))

我们看到打印出了哪吒这个英雄的各项属性，数据类型返回值是字典。

需要注意的是，在创建字典时，字典中的键值不能重复，重复会报错。

#3 访问字典

字典创建完成之后，我们想要访问字典中的英雄名字、最大生命、生命成长的值，该如何访问呢？

访问字典中某个键值对的值：字典名[键名]，只需要将键值对的键名放到方括号 [] 中就可以啦。

我们运行下方语句。

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450,'最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

print(ne_zha['英雄名字'])
print(ne_zha['最大生命'])
print(ne_zha['生命成长'])

我们看到结果显示了英雄名字、最大生命和生命成长这三个键对应的值。

除了使用上述方式进行访问外，我们还可以使用 get() 方法进行访问，语法规则是字典名.get(键名)。

我们运行下方语句：

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

print(ne_zha.get('英雄名字'))
print(ne_zha.get('最大生命'))
print(ne_zha.get('生命成长'))

除了上述两种方法，我们还可以通过遍历的方式（一般通过for循环来实现遍历哦）来访问字典中的键值对。

下面代码逐个打印字典中的所有键名。

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

for key in ne_zha:
    print(key)

上述语句是打印键名，打印值的话，使用的是下方语句：

key 表示键名，根据刚刚我们介绍的访问键值的方法， ne_zha[key] 便表示键值。

#逐个打印字典中的所有值
ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

for key in ne_zha:
    print(ne_zha[key])

另外，还可以使用 values() 函数返回字典的值，语法规则是字典名.values()，运行下方语句：

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

for value in ne_zha.values():
    print(value)

还可以使用 items() 函数遍历键和值，语法规则是字典名.items()，运行下方语句：

（key 表示键名，value 表示键值）

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

for key, value in ne_zha.items():
    print("key = ", key, ", value = ", value)

#4 修改字典

和列表一样，我们可以对创建好的字典进行相应的修改。

我们首先来看在字典中添加项目。

#4.1 添加项目

我们之前在变量和列表中都介绍了索引，现在又是索引发挥作用的时刻了，我们可以通过使用新的索引键并为其赋值，来为字典添加新的项目。

我们使用索引将哪吒的“最大每5秒回血”这个属性添加到 ne_zha 这个字典中，具体语句如下：

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

ne_zha['最大每5秒回血'] = 98
print(ne_zha)

我们看到哪吒的“最大每5秒回血”添加到了ne_zha 这个字典的结尾处。

#4.2 删除项目

除了可以往字典中添加项目，我们也可以从字典中删除项目。我们可以通过多种方式删除字典中的项目，我们逐一介绍给大家：

#4.2.1 pop() 方法

pop() 方法删除具有指定键名的项，语法规则为字典名.pop(键名)。键名如果是字符串，记得加英文状态下的引号哟！我们运行下方语句：

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

ne_zha.pop('英雄名字')
print(ne_zha)

#4.2.2 popitem()

popitem() 方法删除最后插入的项目（在 3.7 之前的版本中，删除随机项目），语法规则为字典名.popitem()

运行下方语句：

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

print(ne_zha)
ne_zha.popitem()
print(ne_zha)

我们看到执行 popitem() 语句之后，字典中最后位置的 '初始物防': 99 被删除了。

#4.2.3 del

我们也可以使用 del 关键字删除具有指定键名的项目，语法规则为 del 字典名[键名]，我们运行下方语句：

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

del ne_zha['最大生命']
print(ne_zha)

我们看到字典 ne_zha 中的 '最大生命': 7268 被删除了。

del 关键字也可以完全删除字典，语法规则为：del 字典名

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

del ne_zha
print(ne_zha)  # 会报错，因为删除之后 ne_zha 不再存在。

#4.2.4 clear()

除了删除字典，我们也可以清空字典，有没有非常羡慕程序呢，有时候我们也想清空下自己，却发现实施起来太难太难！

clear() 函数清空字典，语法规则为：字典名.clear()，运行下方语句：

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

ne_zha.clear()
print(ne_zha)

#5 复制字典

在变量和列表中，我们可以通过 name2 = name1 的语句来将变量或者是列表的内容进行复制，但对于字典来说，是不能通过键入 dict2 = dict1 来复制字典。因为，dict2 只是对 dict1 的引用，而 dict1 中的更改也将自动在 dict2 中进行。有一些方法可以进行复制，一种方法是使用内建的字典方法 copy()，语法规则是 字典名.copy()，通过 ne_zha_copy = ne_zha.copy() 语句来实现列表 ne_zha 的复制，我们运行下方语句：

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

ne_zha_copy = ne_zha.copy()
print(ne_zha_copy)

制作副本的另一种方法是使用内建方法 dict()，语法规则是 dict(字典名)，通过ne_zha_copy = dict(ne_zha) 语句来实现对字典 ne_zha 的复制，运行下方语句：

ne_zha = {'英雄名字': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}

ne_zha_copy = dict(ne_zha)
print(ne_zha_copy)

#6 使用 dict() 创建字典

我们也可以使用 dict() 构造函数创建新的字典，语法规则为：字典名 = dict(键名=键值, 键名=键值,..., 键名=键值)

# 注意：1.关键字不是字符串字面量；2.使用了等号而不是冒号来赋值。
ne_zha = dict(英雄名字='哪吒', 最大生命=7268, 生命成长=270.4, 初始生命=3483, 最大法力=1808, 法力成长=97, 初始法力=450, 最高物攻=320, 物攻成长=11.5, 初始物攻=159, 最大物防=408, 物防成长=22.07, 初始物防=99)

print(ne_zha)

#7 总结

下面我们一起来看下本关总结：

#8 练习题

我们通过两个题目来验证下大家对于字典的掌握效果哦！

#8.1 向字典 ne_zha = {'英雄': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}中添加项目 {'每5秒回血成长': 3.214}。

#8.2 从字典 ne_zha = {'英雄': '哪吒', '最大生命': 7268, '生命成长': 270.4, '初始生命': 3483, '最大法力': 1808, '法力成长': 97, '初始法力': 450, '最高物攻': 320, '物攻成长': 11.5, '初始物攻': 159, '最大物防': 408, '物防成长': 22.07, '初始物防': 99}中删除项目 {'初始物攻': 159}

第八章元组

我们首先来回顾下上一关的内容，上一关我们介绍了字典：

今天，我们一起进入到元组的学习。

元组和列表很像，区别在于元组创建完成后便不能被修改。创建元组很简单，只需要将用逗号分隔的元素放到  () 中，(元素1,元素2,元素3,...,元素n)，如果元素为字符串，别忘记添加引号哟！

我们首先一起来看下元组的创建。

#1 创建元组

龙，是中国的“图腾”，在中国古代神话传说中，龙生有九子，九子不成龙，各有所好。比喻同胞兄弟品质、爱好各不相同。龙生的九子分别是：长子囚牛、次子睚眦(yá zì)、三子嘲风、四子蒲牢、五子狻猊（Suān ní）、六子霸下、七子狴犴(bì àn)、八子负屃（fù xì）、九子螭吻（chī wěn)。

我们创建一个元组，包含这九子，语句如下：

loong_son = ('囚牛', '睚眦', '嘲风', '蒲牢', '狻猊', '霸下', '狴犴', '负屃', '螭吻')

print(loong_son)

如果需要创建一个仅包含一个元素的元组，必须在该元素后面添加一个逗号，否则，Python 无法将变量识别为元组。比如，我们只想创建一个仅仅包含长子囚牛的元组，语句如下：

loong_son1 = ('囚牛') # 不是元组
loong_son2 = ('囚牛',)

print(type(loong_son1))
print(type(loong_son2))

友情提示：type() 是获取数据类型的方法哦！

#2 访问元组

现在呢，我们想要访问元组 loong_son 中的囚牛、嘲风、螭吻，该如何访问呢？

大家可以回想下在之前列表、字典的介绍中，我们是如何访问其中的元素的。

我们可以使用索引操作符 [] 访问元组的元素，我们可以从左到右正索引，也可以从右到左负索引。我们先来看下正索引的语句：

#2.1 正索引

loong_son = ('囚牛', '睚眦', '嘲风', '蒲牢', '狻猊', '霸下', '狴犴', '负屃', '螭吻')

print(loong_son[0])
print(loong_son[2])
print(loong_son[8])

我们成功访问了囚牛、嘲风、螭吻。

#2.2 负索引

负索引表示从末尾开始，-1 表示最后一个元素，-2 表示倒数第二个元素，依此类推。

loong_son = ('囚牛', '睚眦', '嘲风', '蒲牢', '狻猊', '霸下', '狴犴', '负屃', '螭吻')

print(loong_son[-1])
print(loong_son[-7])
print(loong_son[-9])

成功访问了囚牛、嘲风、螭吻。

索引部分的内容和之前介绍的一样，正索引是从左到右，用 0 表示第一个元素；负索引是从右到左，用 -1 表示右边第一个元素，大家一定要记清楚哟！

#2.3 切片

现在我们想访问龙的前三个孩子，即囚牛、睚眦、嘲风，怎么操作呢？

当然，我们可以通过索引的方式一个一个访问出来，但是这样操作的效率非常低！

我们在学习前面知识的时候提到过，通过切片可以一次访问多个元素，对于访问元组中的多个元素，还是采用切片的方式：

loong_son = ('囚牛', '睚眦', '嘲风', '蒲牢', '狻猊', '霸下', '狴犴', '负屃', '螭吻')
print(loong_son[0:3])

关于切片的语法，大家可以通过下方语句回顾下，这里我们就不过多介绍啦！

loong_son = ('囚牛', '睚眦', '嘲风', '蒲牢', '狻猊', '霸下', '狴犴', '负屃', '螭吻')

print(loong_son[1:])
print(loong_son[:3])
print(loong_son[:])
print(loong_son[-3:-1])
print(loong_son[-3:])
print(loong_son[:-1])

#2.4 遍历元组

我们也可以使用 for 循环遍历元组元素，运行下方语句。

loong_son = ('囚牛', '睚眦', '嘲风', '蒲牢', '狻猊', '霸下', '狴犴', '负屃', '螭吻')

for elem in loong_son:
    print(elem)

通过 for 循环，我们完成了元组 loong_son 中元素的遍历。

#3 元组修改

我们在介绍元组时提到了元组的一个特征是：元组在创建完成后便不能被修改！因此任何关于修改元组的操作都会报错，比如添加新元素到元组中，或者是删除元组中的某些元素，我们逐一来看下添加和删除两种情况：

#3.1 添加元素

元组一旦创建，就无法向其添加元素，元组是不可改变的。

loong_son = ('囚牛', '睚眦', '嘲风', '蒲牢', '狻猊', '霸下', '狴犴', '负屃', '螭吻')

loong_son[10] = '龙' # 会报错，元组不可改变

#3.2 删除元素

元组是不可改变的，因此无法从中删除元素，但可以删除整个元组。

loong_son = ('囚牛', '睚眦', '嘲风', '蒲牢', '狻猊', '霸下', '狴犴', '负屃', '螭吻')

del loong_son
print(loong_son) # 会报错，因为删除之后，loong_son 不再存在

#4 合并元组

元组不能被修改，但是两个元组是可以合并成一个新的元组的，在 Python 中，使用 + 运算符可以连接两个或多个元组，语句如下：

loong_son1 = ('囚牛', '睚眦', '嘲风', '蒲牢', '狻猊')
loong_son2 = ('霸下', '狴犴', '负屃', '螭吻')

loong_son = loong_son1 + loong_son2
print(loong_son)

我们看到通过 + 运算符，元组 loong_son1 和元组 loong_son2 形成了一个新的元组 loong_son。

#5 总结

下面我们一起来回顾下本关内容：

#6 练习题

创建一个包含 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' 这个 12 个元素的元组，并尝试对元组进行修改，看看会报什么错。

第九章集合

我们先来一起复习下上一关元组的内容：

今天我们来学习集合。

集合是无序元素的集合，集合中的元素不可重复，并且创建完成后，其中的元素不可更改。但是整个集合是可以更改的，我们可以向其增加元素，也可以从中删除元素。也就是说，我们无法修改集合中的元素，但是我们可以对整个集合进行添加或者是删除等更改的操作。

集合的创建非常简单，只需要将以逗号分隔的元素放在花括号 {} 中，{元素1,元素2,元素3,...,元素n}。

#1 集合创建

不知道大家是否有个武侠梦呢，我从小就喜欢看武侠小说，以及根据小说改编的各种电视剧，最爱的就是气度翩翩的赵敏，黎姿版的赵敏真的是一眸一笑深入人心…啧啧啧，有些跑偏，还不小心暴露了年纪，我们还是回到课程中来。

现在呢，我们来创建一个名为 novels 的集合，集合中的元素为武侠小说的名称，让我们在集合的世界里畅游武侠江湖！

novels = {'飞狐外传', '雪山飞狐', '连城诀', '天龙八部', '射雕英雄传', '白马啸西风', '鹿鼎记', '笑傲江湖', '书剑恩仇录', '神雕侠侣', '侠客行', '倚天屠龙记', '碧血剑', '鸳鸯刀'}

print(novels)

集合中的元素不可重复，如果有重复元素，重复的元素将被忽略。

novels = {'飞狐外传', '飞狐外传', '雪山飞狐', '连城诀', '天龙八部', '射雕英雄传', '白马啸西风', '鹿鼎记', '笑傲江湖', '书剑恩仇录', '神雕侠侣', '侠客行', '倚天屠龙记', '碧血剑', '鸳鸯刀'}

print(novels)

我们看到集合中有两个元素 '飞狐外传'，但是打印的集合中，只显示一个飞狐外传，集合中的第二个元素 '飞狐外传' 被认定为是重复元素，被忽略，没有显示。

#2 集合访问

我们在介绍集合时，提到了集合中的元素是无序的！（列表、元组都是有序的哦）

元素的顺序主要应用在索引中，集合中的元素是无序的，也就无法应用索引进行访问了。

那么访问集合中的元素可以通过哪些方式呢？

我们可以通过 for 循环来遍历集合的元素，另外，还可以使用 in 关键字来判断集合中是否存在某个元素。

我们首先来看通过 for 循环遍历集合的元素。

#2.1 for 循环

novels = {'飞狐外传', '雪山飞狐', '连城诀', '天龙八部', '射雕英雄传', '白马啸西风', '鹿鼎记', '笑傲江湖', '书剑恩仇录', '神雕侠侣', '侠客行', '倚天屠龙记', '碧血剑', '鸳鸯刀'}

for novel in novels:
    print(novel)

#2.2 in

使用 in 关键字来判断集合中是否存在某个元素，如果元素在集合内，返回 True，如果元素不在集合内，返回 False，运行下方语句：

novels = {'飞狐外传', '雪山飞狐', '连城诀', '天龙八部', '射雕英雄传', '白马啸西风', '鹿鼎记', '笑傲江湖', '书剑恩仇录', '神雕侠侣', '侠客行', '倚天屠龙记', '碧血剑', '鸳鸯刀'}

print('鸳鸯刀' in novels)
print('越女剑' in novels)

鸳鸯刀在集合中，因此返回 True；越女剑不在集合中，返回 False。

#3 集合修改

我们也可以对整个集合进行一些修改。

#3.1 add() and update()

add() 和 update() 都可用于向集合添加元素。

语法规则为：集合名.add(元素名)、集合名.update({元素1,元素2,...,元素n})

我们看到 add() 和 update() 的一个区别是 add() 添加的是一个元素；update() 添加的是集合或者是列表，添加的是多个元素，我们一起来运行下方语句：

novels = {'飞狐外传', '雪山飞狐', '连城诀', '天龙八部', '射雕英雄传', '白马啸西风', '鹿鼎记'}

novels.add('笑傲江湖')
print(novels)
novels.add('书剑恩仇录')
print(novels)
novels.add('神雕侠侣')
print(novels)

novels.update({'侠客行', '倚天屠龙记'})  # update 的参数为集合
print(novels)
novels.update(['碧血剑', '鸳鸯刀'])
print(novels)  # update 的参数为列表

我们看到执行 add() 和 update() 的语句后，在集合结尾处添加了相应的元素。

#3.2 discard() and remove()

除了可以对整个集合添加元素，我们还可以删除集合中的元素。

discard() 和 remove() 用于从集合中删除元素。

语法规则为：集合名.discard()、集合名.remove()。这两个函数的区别在于，从集合中删除一个不存在的元素时，discard() 不会执行任何操作，而 remove() 会抛出一个异常。

#3.2.1 删除存在的元素

我们首先看一下删除存在的元素，discard() 和 remove()的使用是一样的，结果也是一样的，运行下方语句：

novels = {'飞狐外传', '雪山飞狐', '连城诀', '天龙八部', '射雕英雄传', '白马啸西风', '鹿鼎记', '笑傲江湖', '书剑恩仇录', '神雕侠侣', '侠客行', '倚天屠龙记', '碧血剑', '鸳鸯刀'}

novels.discard('飞狐外传')
print(novels)
novels.remove('雪山飞狐')
print(novels)

#3.2.2 删除不存在的元素

对于删除不存在的元素，discard() 不会执行任何操作，而 remove() 会抛出一个异常，运行下方语句：

novels = {'飞狐外传', '雪山飞狐', '连城诀', '天龙八部', '射雕英雄传', '白马啸西风', '鹿鼎记', '笑傲江湖', '书剑恩仇录', '神雕侠侣', '侠客行', '倚天屠龙记', '碧血剑', '鸳鸯刀'}

novels.discard('越女剑')  # 不会执行任何操作
print(novels)

novels = {'飞狐外传', '雪山飞狐', '连城诀', '天龙八部', '射雕英雄传', '白马啸西风', '鹿鼎记', '笑傲江湖', '书剑恩仇录', '神雕侠侣', '侠客行', '倚天屠龙记', '碧血剑', '鸳鸯刀'}

novels.remove('越女剑')  # 会抛出异常
print(novels)

我们看到 discard() 不会执行任何操作，而 remove() 会抛出一个异常。

大家在删除集合中的元素时，要灵活掌握这些方法哦！

#4 集合操作

我们在数学中，也学习到了集合的相关概念，在数学中，我们可以对集合进行一系列的操作，比如并集、交集和差集。Python 中的集合，我们也可以做相应的操作，实现 Python 集合的并集、交集和差集。

我们先一起来看下 Python 中集合的并集：

#4.1 并集

在数学中，关于并集的定义是：给定两个集合A，B，把他们所有的元素合并在一起组成的集合，叫做集合 A 与集合 B 的并集，记作 A∪B，读作 A 并 B。

Python 中的并集也是一个含义，将集合 A 和集合 B 的所有元素合并在一起，就组成了集合 A 和集合 B 的并集。Python 中，实现集合并集可以使用 union() 和 | 操作符。

#4.1.1 union()

我们先来看下使用 union() 实现集合的并集，语法规则为：集合1.union(集合2)，运行下方语句：

novels_1 = {'飞狐外传', '雪山飞狐', '连城诀', '天龙八部', '射雕英雄传', '白马啸西风', '鹿鼎记', '笑傲江湖'}
novels_2 = {'鹿鼎记', '笑傲江湖', '书剑恩仇录', '神雕侠侣', '侠客行', '倚天屠龙记', '碧血剑', '鸳鸯刀'}

print(novels_1.union(novels_2))
print(novels_2.union(novels_1))

我们看到，通过 union() 实现了集合 novels_1 和集合 novels_2 的并集。

#4.1.2 |

也可以使用 | 对两个集合进行并集的运算，语法规则为 集合1|集合2，运行下方语句：

novels_1 = {'飞狐外传', '雪山飞狐', '连城诀', '天龙八部', '射雕英雄传', '白马啸西风', '鹿鼎记', '笑傲江湖'}
novels_2 = {'鹿鼎记', '笑傲江湖', '书剑恩仇录', '神雕侠侣', '侠客行', '倚天屠龙记', '碧血剑', '鸳鸯刀'}

print(novels_1 | novels_2)

#4.2 交集

我们继续一起来看交集：

A，B 是两个集合，由所有属于集合 A 且属于集合 B 的元素所组成的集合，叫做集合 A 与集合 B 的交集（intersection），记作 A∩B。我们使用 intersection() 和 & 实现不同集合间的交集。

#4.2.1 intersection()

可以实现集合 A 和集合 B 的交集运算，语法规则是 集合1.intersection(集合2)，运行下方语句 ：

novels_1 = {'飞狐外传', '雪山飞狐', '连城诀', '天龙八部', '射雕英雄传', '白马啸西风', '鹿鼎记', '笑傲江湖'}
novels_2 = {'鹿鼎记', '笑傲江湖', '书剑恩仇录', '神雕侠侣', '侠客行', '倚天屠龙记', '碧血剑', '鸳鸯刀'}

print(novels_1.intersection(novels_2))
print(novels_2.intersection(novels_1))

#4.2.2 &

& 也可以实现集合 A 和集合 B 的交集运算，语法规则是 集合1 & 集合2，运行下方语句：