Chapter Two : Python 语言基础、运算符与表达式、程序的控制结构合集

在本章的开头送给大家一句话：生活不会突变，你要做的只是耐心和积累。人这一辈子没法做太多的事情，所以每一件事情都要做得精彩绝伦。— 史蒂夫·乔布斯(苹果公司联合创始人)

一、Python 语言基础

熟练掌握一门编程语言，最好的方法就是充分了解、掌握其基础知识，并亲自体验，多敲代码，才能熟能生巧。这一小节先对 Python 的语法规则进行详细讲解，其次在介绍 Python 中的保留字、标识符、变量、基本数据类型以及数据类型间的转换；最后介绍如何通过输入和输出函数进行交互。

1. Python 语法规则

1.1 注释

注释是指在代码中添加的标注性的文字，旨在告诉别人你的代码要实现什么功能，从而帮助程序员更好地阅读代码。注释的内容将被 Python 解释器忽略，并不会在执行结果中体现出来。在 Python 中，通常包括 3 种类型的注释，分别是单行注释、多行注释和中文编码声明注释。这些注释在 Pycharm 中的效果如图所示。

在 Python 中，使用 # 作为单行注释的符号。从符号 # 开始直到换行为止，其后面所有的内容都作为注释的内容而被 Python 解释器忽略。语法如下：

# 注释内容

单行注释可以放在需要添加注释代码的前一行，也可以放在需要添加注释代码的右侧。例如，下面的两种注释形式都是正确的。

# 第一种形式：
# 要求输入姓名，如：Amo
name = input("请输入您的身高: ")
# 第二种形式:
name = input("请输入您的身高: ")  # 要求输入姓名，如：Amo

说明：为了符合 Python 的 PEP8 规范，书写注释时使用 # 注释内容 ，如果注释放在右侧，先两个空格，在书写 # 注释内容。在添加注释时，一定要有意义，即注释能充分体现代码的作用。在 Pycharm 开发工具中，可以使用快捷键 Ctrl + / 快速注释代码和取消注释。

在 Python 中，并没有一个单独的多行注释标记，而是将包含在一对三引号 """.....""" 或者 '''......''' 之间，并且不属于任何语句的内容认为是注释，这样的代码解释器将忽略。由于这样的代码可以分为多行编写，所以也作多行注释。多行注释通常用来作为 Python 文件、模块、类或者函数等添加版权、功能等信息。语法如下：

"""
注释内容1
注释内容2
......
"""
或者
'''
注释内容1
注释内容2
......
'''

例如，下面代码将使用多行注释为 6.绘制圆或弧形.py 文件添加作者、文件名及创建日期信息。

"""
@author:AmoXiang
@file:6.绘制圆或弧形.py
@time:2020/12/30
"""

注意：如果三引号作为语句的一部分出现，那么就不是注释，而是字符串，这一点一定要注意区分。如下面所示的代码即为字符串：

print('''请在控制台输出您的姓名、学号、以及身份证信息''')
name = """Amo Xiang"""

在 Python 中，还提供了一种特殊的中文编码声明注释。该注释的出现主要是为了解决 Python 2.x 中不支持直接写中文的问题。虽然在 Python 3.x 中，该问题已经不存在了。但是为了规范页面的编码，也为了方便其他人及时了解文件所用的编码，建议在文件开始处加上中文编码声明注释。语法如下：

# -*- coding: 编码 -*-
或者
# coding=编码

在上面的语法中，编码为文件所使用的字符编码类型，如果采用 UTF-8 编码，则设置为 utf-8；如果采用 GBK 编码，则设置为 gbk 或 cp936。例如，指定编码为 UTF-8，可以使用下面的中文编码声明注释：

# -*- coding: UTF-8 -*-

说明：在上面的代码中，-*- 没有特殊的作用，只是为了美观才加上的，所以上面的代码也可以使用 # coding:utf-8 代替。另外，下面的代码也是正确的中文编码声明注释：

# coding=utf-8

1.2 代码缩进

Python 不像其他程序设计语言(如 Java 或者 C 语言)采用大括号 {} 分隔代码块，而是采用代码缩进和冒号 : 区分代码之间的层次。缩进可以使用空格或者 Tab 键实现。其中，使用空格时，一般采用 4 个空格作为一个缩进量，而使用 Tab 键时，则采用一个 Tab 键作为一个缩进量。通常情况下建议采用空格进行缩进。

补充说明: 在不同的编辑器里 Tab 的长度可能不一致，所以在一个编辑器里用 Tab 设置缩进后，在其它编辑器里看可能缩进就乱了。空格不会出现这个问题，因为空格就占一个字符的位置。

经过上面的代码测试，知道 Tab 在 ASCII 码中，编码是 9，而空格是 32。这也就是说，当我们按下一个 Tab 的时候，即使它看起来就是8个空格(或者4个空格，不同的环境下，Tab 可能显示的效果不同），对于电脑来说，却是完全不一样的东西。这也意味着，对于用字符来描述过程的代码来说，极有可能会是决定性的差异。

其实 Python 并没有强制要求你用 Tab 缩进或者用空格缩进，甚至空格按几个都没有强制要求（但在 PEP8 中建议了使用4个空格作为缩进：https://www.python.org/dev/peps/pep-0008/），但是却绝对！绝对不能混用 Tab 和空格，那么这里，是不是空格和 Tab 的区别就显得很大了呢？这个时候有的童鞋就要说了，我用 PyCharm(或者其他IDE) 怎么从来都没有出现这样的问题呢？其实，很多 IDE 对 Tab 键做了各种各样的优化，其中有一条就是，将 Tab 键展开为为空格，也就是说，当你按下 Tab 的时候，IDE 实际上帮你把一个「9」转换成了四个(或者八个)「32」。但是要注意，不是所有的 IDE 都帮你做了这样的工作！同理，对于好纯洁好不做作的编辑器 Vim 来说，肯定也不会帮你做这样的工作了。既然 Tab 在不同的环境下展现不一样，而空格却永远都是一样的。对于一些细致排版缩进来说(比如说想把每一行的注释都对齐)，用空格也更加精确。这样看起来，确实是用空格来写代码要好于用 Tab 呢。

一般情况下，团队开发都要制定一套编码规范， 在大部分团队中，使用4个空格代替 Tab 是大家默认的。所以非常建议大家使用空格代替 Tab， 另外各个IDE（编辑器）都提供了 Tab 自动转换空格的功能，只要大家设置一下，按下 Tab 键就可以出现4个或者多个空格。

在 Python 中，对于类定义、函数定义、流程控制语句，以及异常处理语句等，行尾的冒号和下一行的缩进表示一个代码块的开始，而缩进结束，则表示一个代码块的结束。例如，下面代码中的缩进即为正确的缩进格式：

# -*- coding: UTF-8 -*-
"""
@author:AmoXiang
@file:7-1.比较数字大小(从小到大输出).py
@time:2021/01/18
"""

# 由于题目要求键盘输入，所以要使用input()函数
x = int(input("请输入x的值: ").strip())  # 输入变量x
y = int(input("请输入y的值: ").strip())  # 输入变量y
z = int(input("请输入z的值: ").strip())  # 输入变量z

if x > y:  # 如果x大于y，交换x和y的值
    t = x
    x = y
    y = t

if x > z:  # 如果x大于z，交换x和z的值
    t = z
    z = x
    x = t

if y > z:  # 如果y大于z，交换y和z的值
    t = y
    y = z
    z = t

print(f"三个数的大小顺序是：{x},{y},{z}")  # 经过交换，x、y、z就按从小到大排好序了

Python 对代码的缩进要求非常严格，同一个级别的代码块的缩进量必须相同。如果不采用合理的代码缩进，将显示 SyntaxError 异常。例如，代码中有的缩进量是 4 个空格，还有的是 3 个空格，就会出现 SyntaxError 错误，如图所示。

在 Pycharm 中显示的是 IndentationError 错误，但是错误内容及原因都是一致的。在 Pycharm 中我们可以使用 Tab(Pycharm 中已经对 Tab键做了优化) 键进行缩进，也可以使用 Shift + Tab 反向进行缩进。

1.3 编码规范

在编写代码时，遵循一定的代码编写规则和命名规范可以使代码更加规范化，并对代码的理解与维护起到至关重要的作用。本小节将对 Python 代码的编写规则以及命名规范进行介绍。

(1) 编写规则：Python 中采用 PEP8 作为编码规范，其中 PEP 是 Python Enhancement Proposal 的缩写，翻译过来是 Python 增强建议书；而 PEP 8 表示版本，它是 Python 代码的样式指南。下面给出 PEP 8 编码规范中的一些在编程中应该严格遵守的规则。

1. 每个 import 语句只导入一个模块，尽量避免一次导入多个模块。如图所示：
   
2. 不要在行尾加分号 ;，也不要用分号将两条命令放在同一行。例如，下图所示的代码为不规范的写法。
   
3. 建议每行不超过 80 个字符，如果超过，建议使用小括号 ( 将多行内容隐式地连接起来，而不推荐使用反斜杠 \ 进行连接。例如，如果一个字符串文本在一行上显示不下，那么可以使用小括号 () 将其分行显示，代码如下：
   
4. 使用必要的空行可以增加代码的可读性。一般在顶级定义(如函数或者类的定义) 之间空两行，而在方法(定义在类中的函数)定义之间空一行。另外，在用于分隔某些功能的位置也可以空一行。
5. 通常情况下，运算符两侧、函数参数之间，逗号 , 的两侧建议使用空格进行分隔。
6. 应该避免在循环中使用 + 和 += 运算符累加字符串。这是因为字符串是不可变的，这样做会创建不必要的临时对象。推荐的方法是将每个子字符加入列表，然后在循环结束后使用 join() 方法连接列表。
7. 适当使用异常处理结构提高程序容错性，但不能过多依赖异常处理结构，适当的显示判断还是必要的。

(2) 命名规范

命名规范在编写代码中起到很重要的作用，虽然不遵循命名规范，程序也可以运行，但是使用命名规范可以更加直观地了解代码所代表的含义。本小节将介绍 Python 中常用的一些命名规范。

1. 模块名尽量短小，并且使用全部小写字母，可以使用下划线分隔多个字母。例如，game_main、game_register、bmiexponent 都是推荐使用的模块名称。
2. 包名尽量短小，并且使用全部小写字母，不推荐使用下划线。例如，com.amoxiang、com.amo、com.amo.book 都是推荐使用的包名称，而 com_amoxiang 就是不推荐的。
3. 类名采用单词首字母的大写形式(即 Pascal 风格)。例如，定义一个借书类，可以命名为 BorrowBook。说明：Pascal 是以法国数学家 Blaise Pascal 而命名的一种编程语言，Python 中的 Pascal 命名法就是根据该语言的特点总结出来的一种命名方法。
4. 模块内部的类采用下划线 _ +Pascal 风格的类名组成。例如，在 BorrowBook 类中的内部类，可以使用 _BorrowBook 命名。
5. 函数、类的属性和方法的命名规则同模块类似，也是全部采用小写字母，多个字母间用下划线 _ 分隔。
6. 常量命名时采用全部大写字母，可以使用下划线。在 Python 中没有类似于其他语言中 const 关键字来定义常量。
7. 使用双下划线 __ 开头的实例变量或方法是类私有的。

2. 关键字与标识符

2.1 关键字

关键字是 Python 语言中已经被赋予特定意义的一些单词，在开发程序时，不可以把这些关键字作为变量、函数、类、模块和其他对象的名称来使用。在下图看到的 if 和 and 就是关键字。Python 语言中的关键字如下表所示。

Python 中的所有关键字是区分字母大小写的。例如，if 是关键字，但是 IF 就不属于关键字。Python 中的关键字可以通过 Python Shell 中，输入以下两行代码查看：

保留字是具有特殊含义的标识符，命名模式是以下划线开头或结尾：

1. _*：开头有单下划线，表示模块内私有变量。当以 from module import * 语法格式导入到其文件内时，这些变量不可用。当以 import module 语法格式导入到文件内时，可以使用模块名加点语法(模块名._*) 的方式间接访问。
2. __*__：开头和结尾都有双下划线，表示 Python 预定义的变量，也称为魔法变量或者魔术方法。
3. __*：开头有双下划线，表示类的私有变量，仅能够在类中使用，不能够在类外访问，也不能够继承。

2.2 标识符

标识符可以简单地理解为一个名字，比如每个人都有自己的名字，它主要用来标识变量、函数、类、模块和其他对象的名称。Python 语言的标识符命名规则如下：

1. 由字母、下划线_ 和数字组成，并且第一个字符不能是数字。目前 Python 中只允许使用 ISO-Latin 字符集中的字符 A-Z 和 a~z。

2. 不能使用 Python 中的关键字。例如，下面是合法的标识符：

   USERID
   name
   model2
   user_age
   

   下面是不合法的标识符：

   4word  # 以数字开头
   try  # Python 中的关键字
   $money # 不能使用特殊符号$
   

3. 区分字母大小写：在 Python 中，标识符中的字母是严格区分大小写的，两个同样的单词，如果大小写的格式不一样，所代表的意义是完全不同的。例如，下面的 3 个变量是完全独立、毫无关系的，就像 3 个长得比较像的人，彼此之间都是独立的个体：

   number = 0  # 全部小写
   Number = 1  # 部分大写
   NUMBER = 2  # 全部大写
   

4. Python 中以双下划线开头的标识符有特殊意义，一般应避免使用相似的标识符：

   • 以双下划线开头的标识符 (如 __add) 表示类的私有成员。
   • 以双下划线开头和结尾的是 Python 里专用的标识，例如，__init__() 表示构造函数。

3. 变量

在 Python 中，变量严格意义上应该称为 名字，也可以理解为标签。当把一个值赋给一个名字时(如把值 学会 Python 还可以飞 赋给 python)， python 就称为变量。在大多数编程语言中，都把这称为 把值存储在变量中。意思是在计算机内存中的某个位置，表示字符串序列 学会 Python 还可以飞 已经存在。你不需要准确地知道它们到底在哪里。只需要告诉 Python 这个字符串序列的名字是 python，然后就可以通过这个名字来引用这个字符串序列了。

3.1 变量的定义与使用

在 Python 中，不需要先声明变量名及其类型，直接赋值即可创建各种类型的变量。需要注意的是：对于变量的命名并不是任意的，应遵循以下几条规则：

1. 变量名必须是一个有效的标识符。
2. 变量名不能使用 Python 中的关键字。慎用小写字母 l 和大写字母 O(看着像数字1和0，容易混淆)。
3. 应选择有意义的单词作为变量名，即见名知意。

为变量赋值可以通过等号 = 来实现。语法格式为：

变量名 = value

例如，创建一个整型变量，并为其赋值为 1024，可以使用下面的语句：

number = 1024

这样创建的变量就是数值型的变量。如果直接为变量赋值一个字符串值，那么该变量即为字符串类型。例如下面的语句：

nickname = "碧海苍梧"

另外，Python 是一种动态类型的语言，也就是说，变量的类型可以随时变化。例如，在 IDLE 中，创建变量 nickname，并赋值为字符串 碧海苍梧，然后输出该变量的类型，可以看到该变量为字符串类型，再将变量赋值为数值 1024，并输出该变量的类型，可以看到该变量为整型。执行过程如下：

说明：在 Python 语言中，使用内置函数 type() 可以返回变量类型。常量就是程序运行过程中，值不能改变的量，比如现实生活中的居民身份证号码、数学运算中的 π 值等，这些都是不会发生改变的，它们都可以定义为常量。在 Python 中，并没有提供定义常量的关键字。不过在 PEP8 规范中定义了常量的命名规范为大写字母和下划线组成，但是在实际项目中，在常量首次赋值后，还是可以被其他代码修改的。

4. 基本数据类型

在内存中存储的数据可以有多种类型。例如：一个人的姓名可以用字符串类型存储、年龄可以使用数字类型存储，婚姻状况可以使用布尔类型存储。这里的字符串类型、数字类型、布尔类型都是 Python 语言中提供的基本数据类型。下面分别进行详细介绍。

4.1 数字类型

在生活中，经常使用数字记录比赛得分、公司的销售数据和网站的访问量等信息。在 Python 语言中，提供了数字类型用于保存这些数值，并且它们是不可改变的数据类型。如果修改数字类型变量的值，那么会先把该值存放到内存中，然后修改变量让其指向新的内存地址。在 Python 语言中，数字类型主要包括整数、浮点数和复数。

1. 整数：用来表示整数数值，即没有小数部分的数值。在 Python 语言中，整数包括正整数、负整数和0，并且它的位数是任意的(当超过计算机自身的计算功能时，会自动转用高精度计算)，如果要指定一个非常大的整数，只需要写出其所有的位数即可。整数类型包括十进制整数、八进制整数、十六进制整数和二进制整数。
   • 十进制整数：十进制整数的表现形式大家都很熟悉。例如：2021、314315。
   • 八进制整数：由 0~7 组成，进位规则为 逢八进一，并且以 0o/0O 开头的数，如 0o123(转换成十进制为 83)、-0o123(转换成十进制数为 -83)。
   • 十六进制整数：由 0~9，A-F 组成，进位规则 逢十六进一，并且以 0x/0X 开头的数，如 0x25(转换成十进制数为37)、0Xb01e(转换成十进制数为45086)。
   • 二进制整数，由 0 和 1 两个数组成，进位规则是 逢二进一，如 101(转换成十进制数后为 5)、1010(转换成十进制数后为10)
   • 详解进制转换
2. 浮点数：浮点数由整数部分和小数部分组成，主要用于处理包括小数的数，例如：1.414、0.5、-1.732、3.1415926535897932384626 等。浮点数也可以使用科学记数法表示，例如：2.7e2、-3.14e5和6.16e-2 等。在使用浮点数进行计算时，可能会出现小数位数不确定的情况。
   
   对于这种情况，不止是 Python，其他高级编程语言也都存在这个问题，暂时忽略多余的小数位数即可。使用 JS 语法测试，结果如图所示：
   
3. Python 中的复数与数学中的复数的形式完全一致，都是由实部和虚部组成，并且使用 j 或 J 表示虚部。当表示一个复数时，可以将实部和虚部相加，例如，一个复数，实部为 3.14，虚部为 12.5j，则这个复数为 3.14+12.5j。

4.2 字符串类型

字符串就是连续的字符序列，可以是计算机所能表示的一切字符的集合。在 Python 中，字符串属于不可变序列，通常使用单引号 ''、双引号 "" 或者三引号 '''''' 或 """""" 括起来(三引号就是连续输入三个单引号或者连续输入三个双引号)。这三种引号形式在语义上没有差别，只是在形式上有些差别。其中单引号和双引号中的字符序列必须在一行上，而三引号内的字符序列可以分布在连续的多行上。例如，定义 3 个字符串类型变量，并且应用 print() 函数输出，代码如下：

title = '我喜欢的名言警句'
mot_cn = "命运给予我们的不是失望之酒，而是机会之杯"
mot_en = '''Our destiny offers not the cup of despair,
but the chance of opportunity.
'''
print(title)
print(mot_cn)
print(mot_en)

程序运行结果如下：

字符串开始和结尾使用的引号形式必须一致。 另外当需要表示复杂的字符串时，还可以嵌套使用引号。记住：外单内双，外双内单。

str1 = '在Python中也可以使用双引号("")定义字符串'
str2 = "'(..)'也是字符串"

Python 中的字符串还支持转义字符，所谓转义字符是指使用反斜杠 \ 对一些特殊字符进行转义，常用的转义字符及说明如表所示。

在字符串定界符引号的前面加上字母 r(或R)(原生字符串)，那么该字符串将原样输出，其中的转义字符将不进行转义。例如，输出字符串 “失望之酒\x0a机会之杯” 将输出转义字符换行，而输出字符串 r"失望之酒\x0a机会之杯"，则原样输出，执行结果如图所示。

4.3 布尔类型

布尔类型主要用来表示真值或假值。在 Python 中，标识符 True 和 False 被解释为布尔值。另外，Python 中的布尔值可以转换为数值，True 表示 1， False 为 0。

Python 中的布尔类型的值可以进行数值运算，例如，False+1 的结果为 1。但是不建议对布尔类型的值进行数值运算。在 Python 中，所有的对象都可以进行真值测试。其中，只有下面列出的几种情况得到的值为假，其他对象在 if 或者 while 语句中都表现为真：

1. False 或 None。
2. 数值中的零，包括 0、0.0、虚数 0j。
3. 空序列，包括字符串、空元组、空列表、空字典。
4. 自定义对象的实例，该对象的 __bool__() 方法返回 False，或者 __len__() 方法返回 0。

4.4 数据类型转换

Python 是动态类型的语言(也称为弱类型语言)，不需要像 Java 或者 C 语言一样在使用变量前声明变量的类型。虽然 Python 不需要先声明变量的类型，但有时仍然需要用到类型转换。在 Python 中，提供了下表所示的函数进行数据类型的转换。

使用 round() 函数四舍五入的规则如下：

1. 如果保留位数的后一位是小于 5 的数字，则舍去。例如，3.1415 保留两位小数为 3.14。
2. 如果保留位数的后一位是大于 5 的数字，则入上去。例如，3.1487 保留两位小数为 3.15。
3. 如果保留位数的后一位是 5，且该位数后有数字，则入上去。例如，8.2152 保留两位小数为 8.22；又如 8.2252 保留两位小数为 8.23。
4. 如果保留位数的后一位是 5，且该位数后没有数字。要根据保留位数的那一位来决定是入上去还是舍去：如果是奇数则入上去；如果是偶数则舍去。例如，1.35 保留一位小数为 1.4；又如 1.25 保留一位小数为 1.2。
   

在进行数据类型转换时，如果把一个非数字字符串转换为整型，将产生如图所示的错误。

5. 输入与输出

基本的输入和输出是指我们平时从键盘上输入字符，然后在屏幕上显示。从第一个 Python 程序开始，我们一直在使用 print() 函数向屏幕上输出一些字符，这就是 Python 的基本输出函数。除了 print() 函数，Python 还提供了一个用于进行标准输入的 input() 函数，用于接收用户从键盘上的输入内容。

5.1 使用 input() 函数输入

在 Python 中，使用内置函数 input() 可以接收用户的键盘输入。input() 函数的基本用法如下：

variable = input("提示文字")

其中，variable 为保存输入结果的变量，双引号内的文字用于提示要输入的内容。例如，想要接收用户输入的内容，并保存到变量 tip 中，可以使用下面的代码：

tip = input("请输入文字: ")

在 Python 3.x 中，无论输入的是数字还是字符都将被作为字符串读取。如果想要接收数值，需要把接收到的字符串进行类型转换。例如，想要接收整数类型的数字并保存到变量 age 中，可以使用下面的代码：

age = int(input("请输入数字: "))

5.2 使用 print() 函数输出

默认的情况下，在 Python 中，使用内置的 print() 函数可以将结果输出到 IDLE 或者 Pycharm 或者标准控制台上。其基本语法如下：

print(输出内容)

其中，输出内容可以是数字和字符串(字符串需要使用引号括起来)，此类内容将直接输出，也可以是包含运算符的表达式，此类内容将计算结果输出。例如：

在 Python 中的默认情况下，一条 print() 语句输出后会自动换行，如果想要一次输出多个内容，而且不换行，可以将要输出的内容使用英文半角的逗号分隔。例如，下面的代码将在一行输出变量 a 和 b 的值：

print(a, b)

在 Python 中，每一条 print() 语句占一行，即在输出内容后面会自动换行。如果不想换行，可以在输出内容后面加上 ,end= '分隔符' 。其中的 分隔符 可以是空格或其他字符，也可以省略，如果省略，那么将不使用分隔符，而是直接连接到一起再输出。

在输出时，也可以把结果输出到指定文件，例如，将一个字符串 命运给予我们的不是失望之酒，而是机会之杯。 输出到当前目录下的 mot.txt 文件中，代码如下：

fp = open(r"./mot.txt", "a+")  # 打开文件
print("命令给予我们的不是失望之酒，而是机会之杯。", file=fp)  # 输出到文件中
fp.close()

全网最细 Python 格式化输出用法讲解

二、运算符与表达式

运算符是一些特殊的符号，主要用于数学计算、比较大小和逻辑运算等。Python 中的运算符主要包括算术运算符、赋值运算符、比较(关系)运算符、逻辑运算符和位运算符。使用运算符将不同类型的数据按照一定的规则连接起来的式子，称为表达式。例如，使用算术运算符连接起来的式子称为算术表达式；使用逻辑运算符连接起来的式子称为逻辑表达式。

1. 算术运算符

算术运算符是处理四则运算的符号，在数字的处理中应用得最多。常用的算术运算符如下表所示：

在 Python 中进行数学计算时，与我们学过的数学中的运算符优先级是一致的。

1. 先乘除后加减
2. 同级运算符是从左至右计算
3. 可以使用 () 调整计算的优先级

算术运算符优先级由高到最低顺序排列如下：

1. 第一级：**
2. 第二级：*、/、%、//
3. 第三级：+、-

2. 赋值运算符

赋值运算符主要用来为变量赋值。使用时，可以直接把基本赋值运算符 = 右边的值赋给左边的变量，也可以进行某些运算后再赋值给左边的变量。在 Python 中常用的赋值运算符如下表所示：

混淆 = 和 == 是编程中最常见的错误之一。很多语言(不只是Python)都使用了这两个符号，另外每天都有很多程序员会用错这两个符号，请读者朋友在开发中也要多多注意。

在 Python 中，有一种便利的技巧，即同时给多个变量赋值。例如，定义变量 a、b、c、d，并且赋值为 100，代码如下：

a = b = c = d = 100

在使用多重赋值时，也可以同时为多个变量赋不同的值。例如，定义变量 a、b、c、d，并且分别赋值为 10、100、1000、10000，代码如下：

a, b, c, d = 10, 100, 1000, 10000

多重赋值还有一个很实用的功能，就是交换两个变量的值。例如，定义变量 a 和 b，并且分别为其赋值为 100 和 200，然后通过多重赋值实现将 a 和 b 的值交换。代码如下：

a = 100
b = 200
a, b = b, a  # 多重赋值

交换两个变量的方法如下：

# -*- coding: utf-8 -*-
# @Time    : 2019/12/14 23:30
# @Author  : 我就是任性-Amo
# @FileName: 1.两个变量的交换.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/xw1680


# 需求: 完成两个变量值的交换
# 如:a=20,b=30-->a=30,b=20
a = 20
b = 30
print(f"变量交换之前a的值为{a},b的值为{b}")
# 第一种交换变量的方式: 使用第三方临时变量
temp = a  # 先将a值赋值给一个第三变量 存储a的值
a = b  # 将b的值赋值给a
b = temp  # 将temp的值赋值给b temp存储的值其实为原来变量a存储的值
print(f"变量交换之后a的值为{a},b的值为{b}")

# 第二种交换变量的方式: 使用python特有的方式
a, b = b, a
print(f"变量交换之后a的值为{a},b的值为{b}")

# 第三种交换变量的方式: 使用算术运算符的方式
# 总的来说: 无论a,b如何交换 他们的和都是不变的
a = a + b
b = a - b
a = a - b
print(f"变量交换之后a的值为{a},b的值为{b}")

# 第四种交换变量的方式: 使用位运算符的方式
a = a ^ b
b = a ^ b
a = a ^ b
print(f"变量交换之后a的值为{a},b的值为{b}")

# 在java中还可以使用下面这种方式:
# int a = 10;
# int b = 20;
# System.out.println("交换变量前a的值为:" + a + ",b的值为:" + b);
# a = (a + b) - (b = a);
# System.out.println("交换变量后a的值为:" + a + ",b的值为:" + b);

3. 比较(关系) 运算符

比较运算符，也称为关系运算符，用于对变量或表达式的结果进行大小、真假等比较，如果比较结果为真，则返回 True；如果为假，则返回 False。比较运算符通常用在条件语句中作为判断的依据。Python 中的比较运算符如下表所示。

4. 逻辑运算符

逻辑运算符是对真和假两种布尔值进行运算，运算后的结果仍是一个布尔值，Python 中的逻辑运算符主要包括 and(逻辑与)、or (逻辑或)、not (逻辑非)。下表列出了逻辑运算符的用法和说明。

使用逻辑运算符进行逻辑运算时，其运算结果如下表所示：

5. 位运算符

位运算符是把数字看作二进制数来进行计算的，因此，需要先将要执行运算的数据转换为二进制，然后才能执行运算。Python 中的位运算符有位与 (&)、位或 (|)、位异或 (^)、取反 (~)、左移位 (<<)和右移位 (>>) 等运算符。说明：

整数类型数据在内存中以二进制的形式表示，如 7 的 32位二进制形式如下：
00000000 00000000 00000000 00000111
其中，左边最高位是符号位，最高位是0表示正数；
若为1则表示负数。负数采用补码表示，如 -7 的32位二进制形式如下：
11111111 11111111 11111111 11111001

1. 位与运算。位与运算的运算符为 &，位与运算的运算法则是：两个操作数据的二进制表示，只有对应数位都是 1 时，结果数位才是 1；否则为 0。如果两个操作数的精度不同，则结果的精度与精度高的操作数相同，如下图所示。
   

2. 位或运算。位或运算的运算符为 |，位或运算的运算法则是：两个操作数据的二进制表示，只有对应数位都是 0 时，结果数位才是 0；否则为 1。如果两个操作数的精度不同，则结果的精度与精度高的操作数相同。

3. 位异或运算。位异或运算的运算符 ^，位异或运算的运算法则是：当两个操作数的二进制表示相同(同时为 0 或同时为 1)时，结果为 0；否则为 1。若两个操作数的精度不同，则结果数的精度与精度高的操作数相同。

4. 位取反运算。位取反运算也称位非运算，运算符为 ~。位取反运算就是将操作数中对应的二进制数 1 修改为 0，0 修改为 1。
   

5. 示例代码如下：

   print(f"12&8 = {12 & 8}")  # 位与计算整数的结果
   print(f"4|8 = {4 | 8}")  # 位或计算整数的结果
   print(f"31^22 = {31 ^ 22}")  # 位异或计算整数的结果
   print(f"~123 = {~123}")  # 位取反计算整数的结果
   

   程序运行结果如下图所示：
   

6. 左移位运算符。左移位运算符 << 是将一个二进制操作数向左移动指定的位数，左边(高位端)溢出的位被丢弃，右边(低位端)的空位用 0 补充。左移位运算相当于乘以 2 的 n 次幂。例如，int 类型数据 48 对应的二进制数为 00110000，将其左移 1 位，根据左移位运算符的运算规则可以得出 (00110000<<1)=01100000，所以转换为十进制数就是 96(48×2)；将其左移 2 位，根据左移位运算符的运算规则可以得出 (00110000<<2)=11000000，所以转换为十进制数就是192(48×2²)。

7. 右移位运算符。右移位运算符 >> 是将一个二进制操作数向右移动指定的位数，右边(低位端)溢出的位被丢弃，而在填充左边(高位端)的空位时，如果最高位是 0(正数)，左侧空位填入 0；如果最高位是 1(负数) 左侧空位填入 1。右移位运算相当于除以 2 的 n 次幂。
   

6. 赋值表达式

在 Python 3.8 中新增了赋值表达式，使用 := 运算符实现，用于在表达式内部为变量赋值，它被称为 海象运算符，因为它很像海象的眼睛和长牙。赋值表达式主要用于降低程序的复杂性，并提升可读性。例如，在进行用户注册时，需要判断输入的用户名的长度，当长度超出指定范围时，给出提示(要求提示输入的用户名的长度)。在不使用赋值表达式时，代码如下：

name = "问渠哪得清如许，为有源头活水来。"
n = len(name)
if n > 10:
    print("当前字符串的字数为", n, "已经超出限制字数10个。")

而使用赋值表达式时，可以将赋值和条件判断合为一行代码实现。具体代码如下：

name = "问渠哪得清如许，为有源头活水来。"
if (n := len(name)) > 10:
    print("当前字符串的字数为", n, "已经超出限制字数10个。")

上面两段的代码的运行结果是一样的，都将显示以下内容：

7. 运算符的优先级

所谓运算符的优先级，是指在应用中哪一个运算符先计算，哪一个后计算，与数学的四则运算应遵循的 先乘除，后加减 是一个道理。

Python 的运算符的运算规则是：优先级高的运算先执行，优先级低的运算后执行，同一优先级的运算按照从左到右的顺序进行。也可以像四则运算那样使用小括号，括号内的运算最先执行。下表按照从高到低的顺序列出了运算符的优先级。同一行中的运算符具有相同优先级，此时它们的结合方向决定求值顺序。

续表：

任务一：看下图说出程序的执行结果为：

任务二：计算花园围栏的周长

Amo 打算更换自家的花园围栏，现在想要算出一共需要多长的栅栏，也就是算一个矩形花园的周长。我们知道计算矩形周长的公式为 (长+宽)×2。学习 Python 不久的 Amo，编写了下面这段代码，实现输入花园的长和宽，自动算出周长：

任务三：Python 解答数学智力题

记得小时候在做寒/暑假作业时，经常会有数学智力题。例如下面这道题目：

在以下数字中填上＋、-、×、÷和()，使等式成立。
1 2 3 4 5 = 10
1 2 3 4 5 = 10
1 2 3 4 5 = 10
那么针对这道智力题，该如何编写 Python 代码实现呢?（提示：主要使用 Python 的算术运算符实现）

欢迎大家在评论区讨论作答。

三、程序的控制结构

做任何事情都要遵循一定的原则。例如，到图书馆去借书，就必须有借书证，并且借书证不能过期，这两个条件缺一不可。程序设计也是如此，需要利用流程控制实现与用户的交流，并根据用户的需求决定程序 做什么/怎么做。

程序控制对于任何一门编程语言来说都是至关重要的，它提供了控制程序如何执行的方法。如果没有程序结构，整个程序则将按照线性顺序来执行，而不能根据用户的需求决定程序执行的顺序。本节将对在 Python 中如何进行程序结构控制进行详细讲解。

1. 程序结构

计算机在解决某个具体问题时，主要有 3 种情形，分别是顺序执行所有的语句、选择执行部分语句和循环执行部分语句。程序设计中的 3 种基本结构为顺序结构、选择结构和循环结构。这 3 种结构的执行流程如图所示。

其中，第一幅图是顺序结构的流程图，编写完毕的语句按照编写顺序依次被执行；第二幅图是选择结构的流程图，它主要根据条件语句的结果选择执行不同的语句；第三幅图是循环结构的流程图，它是在一定条件下反复执行某段程序的流程结构，其中，被反复执行的语句称为循环体，决定循环是否终止的判断条件称为循环条件。

本节之前编写的多数实例采用的都是顺序结构。例如，定义一个字符串类型的变量，然后输出该变量，代码如下：

mot_cn = '命运给予我们的不是失望之酒，而是机会之杯。'
print(mot_cn)

选择结构和循环结构的应用场景：看过金庸的小说《射雕英雄传》的人，可能会记得，在黄蓉与瑛姑见面时，曾出过这样一道数学题：“今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二，问几何?” 解决这道题，有以下两个要素：

1. 需要满足的条件是一个数，除以三余二，除以五余三，除以七余二。这就涉及条件判断，需要通过选择语句实现。
2. 依次尝试符合条件的数。这就需要循环执行，通过循环语句实现。

2. 选择语句

在生活中，我们总是要做出许多选择，程序也是一样。下面给出几个常见的例子：

1. 如果购买成功，用户余额减少，用户积分增多。
2. 如果输入的用户名和密码正确，提示登录成功，进入网站；否则，提示登录失败。
3. 如果用户使用微信登录，则使用微信扫一扫；如果使用 QQ 登录，则输入 QQ 号和密码；如果使用微博登录，则输入微博账号和密码；如果使用手机号登录，则输入手机号和密码。

以上例子中的判断，就是程序中的选择语句，也称为条件语句。即按照条件选择执行不同的代码片段。Python 中的选择语旬主要有 3 种形式，分别为 if 语句、if…else 语句和 if…elif…else 多分支语句，下面将分别对它们进行详细讲解。

说明：在其他语言中(例如，C、C++、Java 等)，选择语句还包括 switch 语句，也可以实现多重选择。但是，在 Python 中，却没有 switch 语句，所以在实现多重选择的功能时，只能使用 if…elif…else 多分支语句或者 if 语句的嵌套。

1. 最简单的 if 语句

Python 中使用 if 保留字来组成选择语句，简单的语法如下：

if 表达式:
	语句块

其中，表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式(例如：a > b and a !=c)，如果表达式为真，则执行语句块。如果表达式的值为假，就跳过语句块，继续执行后面的语句，这种形式的 if 语句相当于汉语里的关联词语 如果......就......，其流程如图所示。

2. if…else 语句

如果遇到只能二选一的条件，例如，某大学毕业生到知名企业实习期满后留用，现在需要选择 Python 开发的方向，示意图如图所示。

针对类似的问题，Python 提供了 if…else 语句，语法如下：

if 表达式:
    语句块1
else:
    语句块2

使用 if…else 语句时，表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式，如果满足条件，则执行 if 后面的语句块；否则，执行 else 后面的语句块，这种形式的选择语句相当于汉语里的关联词语 如果......否则......，其流程如图所示。

if…else 语句可以使用条件表达式进行简化，如下面的代码：

a = -3
if a > 0:
    b = a
else:
    b = -a
print(b)

可以简写成：

a = -3
b = a if a > 0 else -a
print(b)

上段代码主要实现求绝对值的功能，如果 a>0，就把 a 的值赋值给变量 b，否则将 -a 赋值给变量b。使用条件表达式的好处是可以使代码简洁，并且有一个返回值。

3. if…elif…else 语句

大家平时在网上购物时，通常都有多种付款方式供大家选择，如图所示。

上图中提供了 5 种付款方式，这时用户就需要从多个选项中选择一个。在开发程序时，如果遇到多选一的情况，则可以使用 if…elif…else 语句，该语句是一个多分支选择语句，通常表现为 如果满足某种条件，就会进行某种处理，否则，如果满足另一种条件，则执行另一种处理......。if…elif…else 语句的语法格式如下：

if 表达式1:
    语句块1
elif 表达式2:
    语句块2
elif 表达式3:
    语句块3
...
else:
    语句块n

使用 if…elif…else 语句时，表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式，如果表达式为真，执行语句；而如果表达式为假，则跳过该语句，进行下一个 elif 的判断，只有在所有表达式都为假的情况下，才会执行 else 中的语句。if…elif…else 语句的流程如图所示。

注意：if 和 elif 都需要判断表达式的真假，而 else 则不需要判断；另外，elif 和 else 都必须与 if 一起使用，不能单独使用。

使用 if…elif…else 多分支语句实现根据用户输入的玫瑰花的朵数输出其代表的含义，代码如下：

print("在古希腊神话中，玫瑰集爱情与美丽于一身，所以人们常用玫瑰来表达爱情。")
print("但是不同朵数的玫瑰花代表的含义是不同的。\n")
# 获取用户输入的朵数，并转换为整型
number = int(input("输入您想送几朵玫瑰花，Amo会告诉您含义：").strip())
if number == 1:  # 判断输入的数是否为1，代表1朵
    # 如果等于1则输出提示信息
    print("1朵，你是我的唯一！")
elif number == 3:  # 判断是否为3朵
    print("3朵，I Love You！")
elif number == 10:  # 判断是否为10朵
    print("10朵，十全十美！")
elif number == 99:  # 判断是否为99朵
    print("99朵，天长地久！")
elif number == 108:  # 判断是否为108朵
    print("108朵，求婚！")
else:
    print("Amo也不知道了！可以考虑送1朵、3朵、10朵、99朵或108朵哟！")

使用 if 选择语句时，尽量遵循以下原则：

1. 当使用布尔类型的变量作为判断条件时，假设布尔型变量为 flag，较为规范的格式如下：

   if flag: # 表示为真
   if not flag: # 表示为假
   不符合规范的格式如下:
   if flag == True:
   if flag == False:
   

2. 使用 if 1==a 这样的书写格式可以防止错写成 if a=1: 这种形式，从而避免逻辑上的错误。

4. if 语句的嵌套

在前面介绍了 3 种形式的 if 选择语句，这 3 种形式的选择语句之间都可以互相嵌套。在最简单的 if 语句中嵌套 if…else 语句，形式如下：

在 if…else 语句中嵌套 if…else 语句，形式如下：

if 选择语句可以有多种嵌套方式，在开发程序时，可以根据自身需要选择合适的嵌套方式，但一定要严格控制好不同级别代码块的缩进量。

国家质量监督检验检疫局发布的《车辆驾驶人员血液、呼气酒精含量阈值与检验》中规定：车辆驾驶人员血液中的酒精含量小于 20mg/100ml 不构成饮酒驾驶行为；酒精含量大于或等于 20mg/100ml、小于 80mg/100ml 为饮酒驾车；酒精含量大于或等于 80mg/100ml 为醉酒驾车。现在编写一段 Python 代码，通过使用嵌套的 if 语句实现根据输入的酒精含量值判断是否为酒后驾车的功能，代码如下：

print("\n为了您和他人的安全，严禁酒后开车！\n")
proof = int(input("请输入每100毫升血液的酒精含量："))  # 获取用户输入的酒精含量，并转换为整型
if proof < 20:  # 酒精含量小于20毫克，不构成饮酒行为
    print("\n您还不构成饮酒行为，可以开车，但要注意安全!")
else:  # 酒精含量大于或等于20毫克，已经构成饮酒驾车行为
    if proof < 80:  # 酒精含量小于80毫克，达到饮酒驾驶标准
        print("\n已经达到酒后驾驶标准，请不要开车！")
    else:  # 酒精含量大于或等于80毫克，已经达到醉酒驾驶标准
        print("\n已经达到醉酒驾驶标准，千万不要开车！")

在上面的代码中，应用了 if 语句的嵌套，其具体执行流程如图所示：

任务：求三角形的周长并判断其是何种三角形

在数学中，三角形是由同一平面内不在同一直线上的三条线段首尾顺次连接所组成的封闭图形。如果设置三条线段(也称三条边)分别为a，b，c，那么它将有以下规律：

1. 三条边的关系为 a+b>c 且 a+c>b 且 b+c>a。
2. 周长p就是三条线段(也称三条边a， b，c)的和，即 p=a+b+c。
3. 构成等边三角形的条件为 a=b=c。
4. 构成等腰三角形的条件为 a=b 或者 a=c或者 b=c。
5. 构成直角三角形的条件为 a*a+b*b=c*c 或者 a*a+c*c=b*b 或者 b*b+c*c=a*a。

请根据以上规律编写一个 Python 程序，实现以下功能：

1. 输入三角形的三条边长，求三角形的周长，若不能构成三角形，则输出提示。
2. 根据用户输入的三角形的三条边长判定是何种三角形(一般为三角形、正三角形、等腰三角形、直角三角形)。

3. 条件表达式

在程序开发时，经常会根据表达式的结果，有条件地进行赋值。例如，要返回两个数中较大的数，可以使用下面的 if 语句：

a = 10
b = 6
r = a if a > b else b

使用条件表达式时，先计算中间的条件(a>b)，如果结果为 True，返回 if 语句左边的值；否则返回 else 右边的值，例如，上面表达式中 r 的值为 10。说明：Python 中提供的条件表达式，可以根据表达式的结果进行有条件的赋值。

4. 循环语句

在日常生活中有很多问题都无法一次性解决，如盖楼，所有高楼都是一层一层垒起来的。再或者有些事物必须周而复始地运转才能保证其存在的意义，例如，公交车、地铁等交通工具必须每天在同样的时间往返于始发站和终点站之间。类似这样反复做同一件事的情况，称为循环。在 Python 中，提供了两个实现循环的语句，分别是 while 语句和 for 语句，下面分别进行介绍。

4.1 while 循环语句

while 循环是通过一个条件来控制是否要继续反复执行循环体中的语句。语法如下：

while 条件表达式:
	循环体  # 一组被重复执行的语句

当条件表达式的返回值为真时，则执行循环体中的语句，执行完毕后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，退出循环。while 循环语句的执行流程如图所示。

我们用现实生活中的例子来理解 while 循环的执行流程。在体育课上，体育老师要求同学们沿着环形操场跑圈，要求当听到老师吹的哨子声时就停下来。同学们每跑一圈，可能会请求一次老师吹哨子。如果老师吹哨子，则停下来，即循环结束，否则继续跑步，即执行循环。

4.2 for 循环语句

for 循环是一个依次重复执行的循环。通常适用于枚举或遍历序列，以及迭代对象中的元素。语法如下：

for 迭代变量 in 对象:
	循环体

其中，迭代变量用于保存读取出的值：对象为要遍历或迭代的对象，该对象可以是任何有序的序列对象，如字符串、列表和元组等；循环体为一组被重复执行的语句。for 循环语句的执行流程如图所示。

我们用现实生活中的例子来理解 for 循环的执行流程。在体育课上，体育老师要求同学们排队进行踢犍球测试，每个同学一次机会，键球落地则换另一个同学，直到全部同学都测试完毕，即循环结束。在使用 for 循环时，最基本的应用就是进行数值循环。例如，想要实现从 1 到 100 的累加，可以通过下面的代码实现：

print("计算1+2+3+....+100的结果为: ")
result = 0  # 保存累加结果的变量
for i in range(101):
    result += i  # 实现累加功能
print(result)

在上面的代码中，使用了range() 函数，该函数是 Python 内置的函数，用于生成一系列连续的整数，多用于 for 循环语句中。语法如下：

range(start, end, step)

参数说明：

1. start：用于指定计数的起始值，可以省略，如果省略则从 0 开始。
2. end：用于指定计数的结束值(但不包括该值，如 range(7)，则得到的值为 0-6，不包括7)，不能省略。当 range() 函数中只有一个参数时，即表示指定计数的结束值。
3. step：用于指定步长，即两个数之间的间隔，可以省略，如果省略则表示步长为 1。例如，range(1,7) 将得到1、2、3、4、5、6。
4. 在使用 range() 函数时，如果只有一个参数，那么表示指定的是 end；如果有两个参数，则表示指定的是 start 和end；当 3 个参数都存在时，最后一个参数才表示步长。

使用 for 循环语句除了可以循环数值，还可以逐个遍历字符串，例如，下面的代码可以将横向显示的字符串转换为纵向显示：

str1 = "腹有读书气自华"
print(str1)  # 横向显示
for ch in str1:  # 纵向显示
    print(ch)

注意：在其他语言中（例如，C、C++、Java等)，条件循环还包括 do…while 循环，但是，在 Python 中没有 do…while 循环。

4.3 循环嵌套

在 Python 中，允许在一个循环体中嵌入另一个循环，这称为循环嵌套。例如，在电影院找座位号，需要知道第几排第几列才能准确找到自己的座位号，假如寻找如下图所示的第二排第三列座位号，首先寻找第二排，然后在第二排的基础上再寻找第三列，这个寻找座位的过程就类似于循环嵌套。

在 Python 中，for 循环和 while 循环都可以进行循环嵌套。例如，在 while 循环中套用 while 循环的格式如下：

在 for 循环中套用 for 循环的格式如下：

在 while 循环中套用 for 循环的格式如下：

在 for 循环中套用 while 循环的格式如下：

除了上面介绍的 4 种嵌套格式外，还可以实现更多层的嵌套，因为与上面的嵌套方法类似，这里就不再一一列出了。

4.4 跳转语句

当循环条件一直满足时，程序将会一直执行下去，就像一辆迷路的车，在某个地方不停地转圈。如果希望在中间离开循环，也就是 for 循环结束重复之前，或者 while 循环找到结束条件之前，可以有两种方法来做到：

1. 使用 continue 语句直接跳到循环的下一次迭代。
2. 使用 break 语句完全中止循环。

break 语句可以终止当前的循环，包括 while 和 for 在内的所有控制语句。以独自一人沿着操场跑步为例，原计划跑 10 圈。可是在跑到第 2 圈的时候，遇到自己的女神或者男神，于是果断停下来，终止跑步，这就相当于使用了 break 语句提前终止了循环。break 语句的语法比较简单，只需要在相应的 while 或 for 语句中加入即可。break 语句一般会与 if 语句搭配使用，表示在某种条件下，跳出循环。如果使用嵌套循环，break 语句将跳出其所在层的循环。在 while 语句中使用 break 语句的形式如下：

while 条件表达式1:
	执行代码
	if 条件表达式2:
		break

其中表达式2用于判断何时调用 break 语句跳出循环。在 while 语句中使用 break 语句的流程如图所示：

在 for 语句中使用 break 语句的形式如下：

for 迭代变量 in 对象:
	if 条件表达式:
		break

其中，条件表达式用于判断何时调用 break 语句跳出循环。在 for 语句中使用 break 语句的流程如图所示。

continue 语句的作用没有 break 语句强大，它只能终止本次循环而提前进入到下一次循环中。仍然以独自一人沿着操场跑步为例，原计划跑步 10 圈。当跑到第 2 圈的一半处的时候，遇到自己的女神或者男神也在跑步，于是果断停下来，跑回起点等待，制造一次完美邂逅，然后从第 3 圈开始继续。continue 语句的语法比较简单，只需要在相应的 while 或 for 语句中加入即可。continue 语句一般会与 if 语句搭配使用，表示在某种条件下，跳过当前循环的剩余语句，然后继续进行下一轮循环。如果使用嵌套循环，continue 语句将只跳过其所在层循环中的剩余语句。在 while 语句中使用 continue 语句的形式如下：

while 条件表达式1:
	执行代码
	if 条件表达式2:
		continue

其中，条件表达式2用于判断何时调用 continue 语句跳出循环。在 while 语句中使用 continue 语句的流程如图所示。

在 for 语句中使用 continue 语句的形式如下：

for 迭代变量 in 对象:
	if 条件表达式:
		continue

其中，条件表达式用于判断何时调用 continue 语句跳出循环。在 for 语句中使用 continue 语句的流程如图所示。

5. pass 空语句

在 Python 中还有一个 pass 语句，表示空语句，它将不做任何事情，一般起到占位作用。例如，在应用 for 循环输出 1~10之间(不包括10)的偶数时，在不是偶数时，应用 pass 语句占个位置，方便以后对不是偶数的数进行处理。代码如下：

for i in range(1, 10):
    if i % 2 == 0:  # 判断是否为偶数
        print(i, end="")
    else:  # 不是偶数
        pass  # 占位符，不做任何事情