（六）Python流程控制
和其它编程语言一样，按照执行流程划分，Python 程序也可分为 3 大结构，即顺序结构、选择（分支）结构和循环结构：
- Python 顺序结构就是让程序按照从头到尾的顺序依次执行每一条 Python 代码，不重复执行任何代码，也不跳过任何代码。
- Python 选择结构也称分支结构，就是让程序“拐弯”，有选择性的执行代码；换句话说，可以跳过没用的代码，只执行有用的代码。
- Python 循环结构就是让程序“杀个回马枪”，不断地重复执行同一段代码。
顺序结构很好理解，无需多说，本章重点讲解选择结构和循环结构。
一、Python if else条件语句详解
前面我们看到的代码都是顺序执行的，也就是先执行第1条语句，然后是第2条、第3条……一直到最后一条语句，这称为顺序结构。
但是对于很多情况，顺序结构的代码是远远不够的，比如一个程序限制了只能成年人使用，儿童因为年龄不够，没有权限使用。这时候程序就需要做出判断，看用户是否是成年人，并给出提示。
在 Python 中，可以使用 if else 语句对条件进行判断，然后根据不同的结果执行不同的代码，这称为选择结构或者分支结构。
Python 中的 if else 语句可以细分为三种形式，分别是 if 语句、if else 语句和 if elif else 语句，它们的语法和执行流程如表1所示。
| 语法格式 | 执行流程 |
|---|---|
| if 表达式： 代码块 |
|
| if 表达式： 代码块 1 else： 代码块 2 |
|
| if 表达式 1： 代码块 1 elif 表达式 2： 代码块 2 elif 表达式 3： 代码块 3 ...//其它elif语句 else： 代码块 n |
|
以上三种形式中，第二种和第三种形式是相通的，如果第三种形式中的 elif 块不出现，就变成了第二种形式。另外，elif 和 else 都不能单独使用，必须和 if 一起出现，并且要正确配对。
对语法格式的说明：
- “表达式”可以是一个单一的值或者变量，也可以是由运算符组成的复杂语句，形式不限，只要它能得到一个值就行。不管“表达式”的结果是什么类型，if else 都能判断它是否成立（真或者假）。
- “代码块”由具由相同缩进量的若干条语句组成。
- if、elif、else 语句的最后都有冒号
:，不要忘记。
一旦某个表达式成立，Python 就会执行它后面对应的代码块；如果所有表达式都不成立，那就执行 else 后面的代码块；如果没有 else 部分，那就什么也不执行。
执行过程最简单的就是第一种形式——只有一个 if 部分。如果表达式成立（真），就执行后面的代码块；如果表达式不成立（假），就什么也不执行。
对于第二种形式，如果表达式成立，就执行 if 后面紧跟的代码块1；如果表达式不成立，就执行 else 后面紧跟的代码块2。
对于第三种形式，Python 会从上到下逐个判断表达式是否成立，一旦遇到某个成立的表达式，就执行后面紧跟的语句块；此时，剩下的代码就不再执行了，不管后面的表达式是否成立。如果所有的表达式都不成立，就执行 else 后面的代码块。
总起来说，不管有多少个分支，都只能执行一个分支，或者一个也不执行，不能同时执行多个分支。
【实例1】使用第一种选择结构判断用户是否符合条件：
age = int( input("请输入你的年龄：") )
if age < 18 :
print("你还未成年，建议在家人陪同下使用该软件！")
print("如果你已经得到了家长的同意，请忽略以上提示。")
#该语句不属于if的代码块
print("软件正在使用中...")运行结果1：
请输入你的年龄：16↙
你还未成年，建议在家人陪同下使用该软件！
如果你已经得到了家长的同意，请忽略以上提示。
软件正在使用中...运行结果2：
请输入你的年龄：24↙
软件正在使用中...从运行结果可以看出，如果输入的年龄小于 18，就执行 if 后面的语句块；如果输入的年龄大于等于 18，就不执行 if 后面的语句块。这里的语句块就是缩进四个空格的两个 print() 语句。
【实例2】改进上面的代码，年龄不符合时退出程序：
import sys
age = int( input("请输入你的年龄：") )
if age < 18 :
print("警告：你还未成年，不能使用该软件！")
print("未成年人应该好好学习，读个好大学，报效祖国。")
sys.exit()
else:
print("你已经成年，可以使用该软件。")
print("时间宝贵，请不要在该软件上浪费太多时间。")
print("软件正在使用中...")运行结果1：
请输入你的年龄：16↙
警告：你还未成年，不能使用该软件！
未成年人应该好好学习，读个好大学，报效祖国。运行结果2：
请输入你的年龄：20↙
你已经成年，可以使用该软件。
时间宝贵，请不要在该软件上浪费太多时间。
软件正在使用中...sys 模块的 exit() 函数用于退出程序。
【实例3】判断一个人的身材是否合理：
height = float(input("输入身高（米）："))
weight = float(input("输入体重（千克）："))
bmi = weight / (height * height) #计算BMI指数
if bmi<18.5:
print("BMI指数为："+str(bmi))
print("体重过轻")
elif bmi>=18.5 and bmi<24.9:
print("BMI指数为："+str(bmi))
print("正常范围，注意保持")
elif bmi>=24.9 and bmi<29.9:
print("BMI指数为："+str(bmi))
print("体重过重")
else:
print("BMI指数为："+str(bmi))
print("肥胖")运行结果：
输入身高（米）：1.7↙
输入体重（千克）：70↙
BMI指数为：24.221453287197235
正常范围，注意保持需要强调的是，Python 是一门非常独特的编程语言，它通过缩进来识别代码块，具有相同缩进量的若干行代码属于同一个代码块，所以你不能胡乱缩进，这样很容易导致语法错误。更多关于缩进的内容请转到《Python if else对缩进的要求》。
在其他语言中（如 C语言、C++、Java 等），选择结构还包括 switch 语句，也可以实现多重选择，但是在 Python 中没有 switch 语句，所以当要实现多重选择的功能时，只能使用 if else 分支语句。
if else 如何判断表达式是否成立
上面说过，if 和 elif 后面的“表达式”的形式是很自由的，只要表达式有一个结果，不管这个结果是什么类型，Python 都能判断它是“真”还是“假”。
布尔类型（bool）只有两个值，分别是 True 和 False，Python 会把 True 当做“真”，把 False 当做“假”。
对于数字，Python 会把 0 和 0.0 当做“假”，把其它值当做“真”。
对于其它类型，当对象为空或者为 None 时，Python 会把它们当做“假”，其它情况当做真。比如，下面的表达式都是不成立的：
"" #空字符串
[ ] #空列表
( ) #空元组
{ } #空字典
None #空值【实例】if elif 判断各种类型的表达式：
b = False
if b:
print('b是True')
else:
print('b是False')
n = 0
if n:
print('n不是零值')
else:
print('n是零值')
s = ""
if s:
print('s不是空字符串')
else:
print('s是空字符串')
l = []
if l:
print('l不是空列表')
else:
print('l是空列表')
d = {}
if d:
print('d不是空字典')
else:
print('d是空字典')
def func():
print("函数被调用")
if func():
print('func()返回值不是空')
else:
print('func()返回值为空')运行结果：
b是False
n是零值
s是空字符串
l是空列表
d是空字典
函数被调用
func()返回值为空说明：对于没有 return 语句的函数，返回值为空，也即 None。
二、Python if else对缩进的要求
前面的《Python if else》一节展示了选择结构的三种基本形式，并给出了实例演示，但是大家在编写代码过程中仍然要注意一些细节，尤其是代码块的缩进，这对 if else 选择结构极其重要。
Python 是以缩进来标记代码块的，代码块一定要有缩进，没有缩进的不是代码块。另外，同一个代码块的缩进量要相同，缩进量不同的不属于同一个代码块。
1、不要忘记缩进
if、elif 和 else 后面的代码块一定要缩进，而且缩进量要大于 if、elif 和 else 本身。例如，下面的代码就是一个反面教材：
age = int( input("请输入你的年龄：") )
if age < 18 :
print("警告：你还未成年，不能使用该软件！")
else:
print("你已经成年，可以使用该软件。")本例中的 print() 函数和 if、else 语句是对齐的，在同一条竖线上，都没有缩进，所以 print() 就不是 if、else 的代码块了，这会导致 Python 解释器找不到 if、else 的代码块，从而报出如下错误：
SyntaxError: expected an indented block翻译过来就是：
语法错误：需要一个缩进的代码块
总之，if、else 后面的代码一定要缩进，否则就不能构成 if、else 的执行体。
2、缩进多少合适？
Python 要求代码块必须缩进，但是却没有要求缩进量，你可以缩进 n 个空格，也可以缩进 n 个 Tab 键的位置。
但是从编程习惯的角度看，我建议缩进 1 个 Tab 键的位置，或者缩进 4 个空格；它们两者其实是等价的，很多编辑器都可以将 Tab 键设置为 4 个空格，比如，IDLE 中默认 Tab 键就是 4 个空格。
3、所有语句都要缩进
一个代码块的所有语句都要缩进，而且缩进量必须相同。如果某个语句忘记缩进了，Python 解释器并不一定会报错，但是程序的运行逻辑往往会有问题。请看下面的代码：
age = int( input("请输入你的年龄：") )
if age < 18 :
print("你还未成年，建议在家人陪同下使用该软件！")
print("未成年人如果得到了家长的同意，请忽略以上提示。") #忘记缩进这段代码并没有语法错误，但是它的运行逻辑是不对的，比如，输入 24 的运行结果如下：
请输入你的年龄：24↙
未成年人如果得到了家长的同意，请忽略以上提示。用户的年龄分明大于 18，但是却出现了“未成年人”的提示，画面非常尴尬，这是因为第二个 print() 语句没有缩进，if 没有把它和第一个 print() 语句当做同一个代码块，所以它不是 if 执行体的一部分。解决这个错误也很容易，让第二个 print() 缩进 4 个空格即可。
3、同一代码块缩进量要相同
Python 虽然不限制代码块的缩进量，你可以随意缩进 n 个空格，但是，同一个代码块内的所有语句都必须拥有相同的缩进量，不能一会缩进 2 个空格，一会缩进 4 个空格。下面的代码是一个反面教材：
age = int( input("请输入你的年龄：") )
if age < 18 :
print("你还未成年，建议在家人陪同下使用该软件！")
print("未成年人如果得到了家长的同意，请忽略以上提示。") #缩进量不对运行这段代码，Python 解释器会报出语法错误：
SyntaxError: unexpected indent翻译过来就是：
语法错误：意外的缩进
这段代码中，第一个 print() 语句缩进了 4 个空格，第二个 print() 语句缩进了 6 个空格，缩进量不同导致它们不是同一个代码块。Python 会认为第一个 print() 语句是 if 的执行体，而第二个 print() 是一个意外的存在，不知道该把它当做谁的代码块，所以解析失败，报错。
总之，位于同一个代码块中的所有语句必须拥有相同的缩进量，多一个空格或者少一个空格都不行。
4、不要随便缩进
另外需要注意的是，不需要使用代码块的地方千万不要缩进，一旦缩进就会产生一个代码块。下面的代码是一个反面教材：
info = "Python教程的网址是：http://c.biancheng.net/python/"
print(info)这两条简单的语句没有包含分支、循环、函数、类等结构，不应该使用缩进。
三、Python if语句嵌套（入门必读）
前面章节中，详细介绍了 3 种形式的条件语句，即 if、if else 和 if elif else，这 3 种条件语句之间可以相互嵌套。
例如，在最简单的 if 语句中嵌套 if else 语句，形式如下：
if 表达式 1：
if 表示式 2：
代码块 1
else：
代码块 2再比如，在 if else 语句中嵌套 if else 语句，形式如下：
if 表示式 1：
if 表达式 2：
代码块 1
else：
代码块 2
else：
if 表达式 3：
代码块 3
else：
代码块 4Python 中，if、if else 和 if elif else 之间可以相互嵌套。因此，在开发程序时，需要根据场景需要，选择合适的嵌套方案。需要注意的是，在相互嵌套时，一定要严格遵守不同级别代码块的缩进规范。
【实例】判断是否为酒后驾车
如果规定，车辆驾驶员的血液酒精含量小于 20mg/100ml 不构成酒驾；酒精含量大于或等于 20mg/100ml 为酒驾；酒精含量大于或等于 80mg/100ml 为醉驾。先编写 Python 程序判断是否为酒后驾车。
通过梳理思路，是否构成酒驾的界限值为 20mg/100ml；而在已确定为酒驾的范围（大于20mg/100ml）中，是否构成醉驾的界限值为 80mg/100ml，整个代码执行流程应如图 1 所示。
图 1 执行流程示意图
由此，我们可以使用两个 if else 语句嵌套来实现：
proof = int(input("输入驾驶员每 100ml 血液酒精的含量："))
if proof < 20:
print("驾驶员不构成酒驾")
else:
if proof < 80:
print("驾驶员已构成酒驾")
else:
print("驾驶员已构成醉驾")运行结果为：
输入驾驶员每 100ml 血液酒精的含量：10
驾驶员不构成酒驾当然，这个例题单独使用 if elif else 也可以实现，这里只是为了让初学者熟悉 if 分支嵌套的用法而已。
除此之外，if分支结构中还可以嵌套循环结构，同样，循环结构中也可以嵌套分支结构。不过，由于目前尚未系统学习循环结构，因此这部分知识会放到后续章节中作详细讲解。
四、Python pass语句及其作用
在实际开发中，有时候我们会先搭建起程序的整体逻辑结构，但是暂时不去实现某些细节，而是在这些地方加一些注释，方面以后再添加代码，请看下面的例子：
age = int( input("请输入你的年龄：") )
if age < 12 :
print("婴幼儿")
elif age >= 12 and age < 18:
print("青少年")
elif age >= 18 and age < 30:
print("成年人")
elif age >= 30 and age < 50:
#TODO: 成年人
else:
print("老年人")当年龄大于等于 30 并且小于 50 时，我们没有使用 print() 语句，而是使用了一个注释，希望以后再处理成年人的情况。当 Python 执行到该 elif 分支时，会跳过注释，什么都不执行。
但是 Python 提供了一种更加专业的做法，就是空语句 pass。pass 是 Python 中的关键字，用来让解释器跳过此处，什么都不做。
就像上面的情况，有时候程序需要占一个位置，或者放一条语句，但又不希望这条语句做任何事情，此时就可以通过 pass 语句来实现。使用 pass 语句比使用注释更加优雅。
使用 pass 语句更改上面的代码：
age = int( input("请输入你的年龄：") )
if age < 12 :
print("婴幼儿")
elif age >= 12 and age < 18:
print("青少年")
elif age >= 18 and age < 30:
print("成年人")
elif age >= 30 and age < 50:
pass
else:
print("老年人")运行结果：
请输入你的年龄：40↙从运行结果可以看出，程序虽然执行到第 10 行代码，但是并没有进行什么操作。
五、Python assert断言函数及用法
Python assert 语句，又称断言语句，可以看做是功能缩小版的 if 语句，它用于判断某个表达式的值，如果值为真，则程序可以继续往下执行；反之，Python 解释器会报 AssertionError 错误。
assert 语句的语法结构为：
assert 表达式assert 语句的执行流程可以用 if 判断语句表示，如下所示：
if 表达式==True:
程序继续执行
else:
程序报 AssertionError 错误有读者可能会问，明明 assert 会令程序崩溃，为什么还要使用它呢？这是因为，与其让程序在晚些时候崩溃，不如在错误条件出现时，就直接让程序崩溃，这有利于我们对程序排错，提高程序的健壮性。
因此，assert 语句通常用于检查用户的输入是否符合规定，还经常用作程序初期测试和调试过程中的辅助工具。
下面的程序演示了 assert 语句的用法：
mathmark = int(input())
#断言数学考试分数是否位于正常范围内
assert 0 <= mathmark <= 100
#只有当 mathmark 位于 [0,100]范围内，程序才会继续执行
print("数学考试分数为：",mathmark)运行该程序，测试数据如下：
90
数学考试分数为： 90再次执行该程序，测试数据为：
159
Traceback (most recent call last):
File "C:\Users\mengma\Desktop\file.py", line 3, in
assert 0 <= mathmark <= 100
AssertionError 可以看到，当 assert 语句后的表达式值为真时，程序继续执行；反之，程序停止执行，并报 AssertionError 错误。
六、Python如何合理使用assert，千万不要和if混用
讲完了 assert 的基本语法之后，本节通过一些实际应用的例子，给大家演示一下 assert 在 Python 中的用法，并明确 assert 的使用场景。
第一个例子，假设 C 语言中文网想做 VIP 促销活动，准备进行打折，现需要写一个 apply_discount() 函数，要求是，向该函数传入原来的价格和折扣力度，该函数返回打折后的价格。
apply_discount() 大致应该写成如下这样：
#price 为原价，discount 为折扣力度
def apply_discount(price, discount):
updated_price = price * (1 - discount)
assert 0 <= updated_price <= price, '折扣价应在 0 和原价之间'
return updated_price可以看到，在计算新价格的后面，添加了一个 assert 语句，用来检查折后价格，这里要求新折扣价格必须大于等于 0、小于等于原来的价格，否则就抛出异常。
我们可以试着输入几组数，来验证一下这个功能：
print(apply_discount(100,0.2))
print(apply_discount(100,1.1))运行结果为：
80.0
Traceback (most recent call last):
File "C:\Users\mengma\Desktop\demo.py", line 7, in
print(apply_discount(100,1.1))
File "C:\Users\mengma\Desktop\demo.py", line 4, in apply_discount
assert 0 <= updated_price <= price, '折扣价应在 0 和原价之间'
AssertionError: 折扣价应在 0 和原价之间 可以看到，当 discount 是 0.2 时，输出 80 没有问题，但是当 discount 为 1.1 时，程序便抛出下面 AssertionError 异常。
这样一来，如果开发人员修改相关的代码，或者是加入新的功能，导致 discount 数值异常时，只要运行程序就很容易能发现问题，这也从侧面印证了前面多讲的，assert 的加入可以有效预防程序漏洞，提高程序的健壮性。
另外，在实际工作中，assert 还有一些很常见的用法，例如：
def func(input):
assert isinstance(input, list), '输入内容必须是列表'
# 下面的操作都是基于前提：input 必须是 list
if len(input) == 1:
...
elif len(input) == 2:
...
else:
...上面代码中，func() 函数中的所有操作都基于输入必须是列表这个前提。所以很有必要在开头加一句 assert 的检查，防止程序出错。
以上给大家介绍了 2 个有关 assert 的使用场景，很多读者可能觉得，assert 的作用和 if 语句非常接近，那么他们之间是否可以相互替代呢？
要注意，前面讲过，assert 的检查是可以被关闭的，比如在命令行模式下运行 Python 程序时，加入 -O 选项就可以使程序中的 assert 失效。一旦 assert 失效，其包含的语句也就不会被执行。
还是拿 C 语言中文网用户来说，只有 VIP 用户才可以阅读 VIP 文章，我们可以设计如下这个函数来模式判断用户身份的功能：
def login_user_identity(user_id):
#凭借用户 id 判断该用户是否为 VIP 用户
assert user_is_Vip(user_id) "用户必须是VIP用户，才能阅读VIP文章"
read()此代码从代码功能角度上看，并没有问题，但在实际场景中，基本上没人会这么写，因为一旦 assert 失效，则就造成任何用户都可以阅读 VIP 文章，这显然是不合理的。
所以正确的做法是，使用 if 条件语句替代 assert 语句进行相关的检查，并合理抛出异常：
def login_user_identity(user_id):
#凭借用户 id 判断该用户是否为 VIP 用户
if not user_is_Vip(user_id):
raise Exception("用户必须是VIP用户，才能阅读VIP文章")
read()总之，不能滥用 assert，很多情况下，程序中出现的不同情况都是意料之中的，需要用不同的方案去处理，有时用条件语句进行判断更为合适，而对于程序中可能出现的一些异常，要记得用 try except 语句处理（后续章节会做详细介绍）。
七、Python while循环语句详解
Python 中，while 循环和 if 条件分支语句类似，即在条件（表达式）为真的情况下，会执行相应的代码块。不同之处在于，只要条件为真，while 就会一直重复执行那段代码块。
while 语句的语法格式如下：
while 条件表达式：
代码块这里的代码块，指的是缩进格式相同的多行代码，不过在循环结构中，它又称为循环体。
while 语句执行的具体流程为：首先判断条件表达式的值，其值为真（True）时，则执行代码块中的语句，当执行完毕后，再回过头来重新判断条件表达式的值是否为真，若仍为真，则继续重新执行代码块...如此循环，直到条件表达式的值为假（False），才终止循环。
while 循环结构的执行流程如图 1 所示。
图 1 while 循环语句执行流程示意图
例如，打印 1~100 的所有数字，就可以使用 while 循环，实现代码如下：
# 循环的初始化条件
num = 1
# 当 num 小于100时，会一直执行循环体
while num < 100 :
print("num=", num)
# 迭代语句
num += 1
print("循环结束!")运行程序会发现，程序只输出了 1~99，却没有输出 100。这是因为，当循环至 num 的值为 100 时，此时条件表达式为假（100<100），当然就不会再去执行代码块中的语句，因此不会输出 100。
注意，在使用 while 循环时，一定要保证循环条件有变成假的时候，否则这个循环将成为一个死循环。所谓死循环，指的是无法结束循环的循环结构，例如将上面 while 循环中的num += 1代码注释掉，再运行程序你会发现，Python 解释器一直在输出"num= 1"，永远不会结束（因为 num<100 一直为 True），除非我们强制关闭解释器。
再次强调，只要位于 while 循环体中的代码，其必须使用相同的缩进格式（通常缩进 4 个空格），否则 Python 解释器会报 SyntaxError 错误（语法错误）。例如，将上面程序中num+=1语句前移一个空格，再次执行该程序，此时 Python 解释器就会报 SyntaxError 错误。
除此之外，while 循环还常用来遍历列表、元组和字符串，因为它们都支持通过下标索引获取指定位置的元素。例如，下面程序演示了如何使用 while 循环遍历一个字符串变量：
my_char="http://c.biancheng.net/python/"
i = 0;
while i程序执行结果为：
http://c.biancheng.net/python/八、Python for循环及用法详解
Python 中的循环语句有 2 种，分别是 while 循环和 for 循环，前面章节已经对 while 做了详细的讲解，本节给大家介绍 for 循环，它常用于遍历字符串、列表、元组、字典、集合等序列类型，逐个获取序列中的各个元素。
for 循环的语法格式如下：
for 迭代变量 in 字符串|列表|元组|字典|集合：
代码块格式中，迭代变量用于存放从序列类型变量中读取出来的元素，所以一般不会在循环中对迭代变量手动赋值；代码块指的是具有相同缩进格式的多行代码（和 while 一样），由于和循环结构联用，因此代码块又称为循环体。
for 循环语句的执行流程如图 1 所示。
图 1 for 循环语句的执行流程图
下面的程序演示了 for 循环的具体用法：
add = "http://c.biancheng.net/python/"
#for循环，遍历 add 字符串
for ch in add:
print(ch,end="")运行结果为：
http://c.biancheng.net/python/可以看到，使用 for 循环遍历 add 字符串的过程中，迭代变量 ch 会先后被赋值为 add 字符串中的每个字符，并代入循环体中使用。只不过例子中的循环体比较简单，只有一行输出语句。
Python for循环的具体应用
（1）for 循环进行数值循环
在使用 for 循环时，最基本的应用就是进行数值循环。比如说，想要实现从 1 到 100 的累加，可以执行如下代码：
print("计算 1+2+...+100 的结果为：")
#保存累加结果的变量
result = 0
#逐个获取从 1 到 100 这些值，并做累加操作
for i in range(101):
result += i
print(result)运行结果为：
计算 1+2+...+100 的结果为：
5050上面代码中，使用了 range() 函数，此函数是 Python 内置函数，用于生成一系列连续整数，多用于 for 循环中。
有关 range() 函数的具体用法，可阅读《Python range()》一节，值得一提的是，Python 2.x 中除提供 range() 函数外，还提供了一个 xrange() 函数，它可以解决 range() 函数不经意间耗掉所有可用内存的问题。但在 Python 3.x 中，已经将 xrange() 更名为 range() 函数，并删除了老的 xrange() 函数。
（2）for循环遍历列表和元组
当用 for 循环遍历 list 列表或者 tuple 元组时，其迭代变量会先后被赋值为列表或元组中的每个元素并执行一次循环体。
下面程序使用 for 循环对列表进行了遍历：
my_list = [1,2,3,4,5]
for ele in my_list:
print('ele =', ele)程序执行结果为：
ele = 1
ele = 2
ele = 3
ele = 4
ele = 5感兴趣的读者，可自行尝试用 for 循环遍历 tuple 元组，这里不再给出具体实例。
（3）for 循环遍历字典
在使用 for 循环遍历字典时，经常会用到和字典相关的 3 个方法，即 items()、keys() 以及 values()，它们各自的用法已经在前面章节中讲过，这里不再赘述。当然，如果使用 for 循环直接遍历字典，则迭代变量会被先后赋值为每个键值对中的键。
例如：
my_dic = {'python教程':"http://c.biancheng.net/python/",\
'shell教程':"http://c.biancheng.net/shell/",\
'java教程':"http://c.biancheng.net/java/"}
for ele in my_dic:
print('ele =', ele)程序执行结果为：
ele = python教程
ele = shell教程
ele = java教程因此，直接遍历字典，和遍历字典 keys() 方法的返回值是相同的。
除此之外，我们还可以遍历字典 values()、items() 方法的返回值。例如：
my_dic = {'python教程':"http://c.biancheng.net/python/",\
'shell教程':"http://c.biancheng.net/shell/",\
'java教程':"http://c.biancheng.net/java/"}
for ele in my_dic.items():
print('ele =', ele)程序执行结果为：
ele = ('python教程', 'http://c.biancheng.net/python/')
ele = ('shell教程', 'http://c.biancheng.net/shell/')
ele = ('java教程', 'http://c.biancheng.net/java/')九、Python循环结构中else用法（入门必读）
Python 中，无论是 while 循环还是 for 循环，其后都可以紧跟着一个 else 代码块，它的作用是当循环条件为 False 跳出循环时，程序会最先执行 else 代码块中的代码。
以 while 循环为例，下面程序演示了如何为 while 循环添加一个 else 代码块：
add = "http://c.biancheng.net/python/"
i = 0
while i < len(add):
print(add[i],end="")
i = i + 1
else:
print("\n执行 else 代码块")程序执行结果为：
http://c.biancheng.net/python/
执行 else 代码块上面程序中，当i==len(add)结束循环时（确切的说，是在结束循环之前），Python 解释器会执行 while 循环后的 else 代码块。
有读者可能会觉得，else 代码块并没有什么具体作用，因为 while 循环之后的代码，即便不位于 else 代码块中，也会被执行。例如，修改上面程序，去掉 else 代码块：
add = "http://c.biancheng.net/python/"
i = 0
while i < len(add):
print(add[i],end="")
i = i + 1
#原本位于 else 代码块中的代码
print("\n执行 else 代码块")程序执行结果为：
http://c.biancheng.net/python/
执行 else 代码块那么，else 代码块真的没有用吗？当然不是。后续章节介绍 break 语句时，会具体介绍 else 代码块的用法。
当然，我们也可以为 for 循环添加一个 else 代码块，例如：
add = "http://c.biancheng.net/python/"
for i in add:
print(i,end="")
else:
print("\n执行 else 代码块")程序执行结果为：
http://c.biancheng.net/python/
执行 else 代码块十、Python（for和while）循环嵌套及用法
Python 不仅支持 if 语句相互嵌套，while 和 for 循环结构也支持嵌套。所谓嵌套（Nest），就是一条语句里面还有另一条语句，例如 for 里面还有 for，while 里面还有 while，甚至 while 中有 for 或者 for 中有 while 也都是允许的。
当 2 个（甚至多个）循环结构相互嵌套时，位于外层的循环结构常简称为外层循环或外循环，位于内层的循环结构常简称为内层循环或内循环。
循环嵌套结构的代码，Python 解释器执行的流程为：
- 当外层循环条件为 True 时，则执行外层循环结构中的循环体；
- 外层循环体中包含了普通程序和内循环，当内层循环的循环条件为 True 时会执行此循环中的循环体，直到内层循环条件为 False，跳出内循环；
- 如果此时外层循环的条件仍为 True，则返回第 2 步，继续执行外层循环体，直到外层循环的循环条件为 False；
- 当内层循环的循环条件为 False，且外层循环的循环条件也为 False，则整个嵌套循环才算执行完毕。
循环嵌套的执行流程图如图 1 所示：
图 1 循环嵌套的执行流程图
下面程序演示了 while-for 嵌套结构：
i = 0
while i<10:
for j in range(10):
print("i=",i," j=",j)
i=i+1由于程序输出结果篇幅太长，读者可自行拷贝代码并执行，观察其执行结果。
可以看到，此程序中运用了嵌套循环结构，其中外循环使用的是 while 语句，而内循环使用的是 for 语句。程序执行的流程是：
- 一开始 i=0，循环条件 i<10 成立，进入 while 外循环执行其外层循环体；
- 从 j=0 开始，由于 j <10 成立，因此进入 for 内循环执行内层循环体，直到 j=10 不满足循环条件，跳出 for 循环体，继续执行 while 外循环的循环体；
- 执行 i=i+1 语句，如果 i<10 依旧成立，则从第 2 步继续执行。直到 i<10 不成立，则此循环嵌套结构才执行完毕。
根据上面的分析，此程序中外层循环将循环 10 次（从 i=0 到 i=9），而每次执行外层循环时，内层循环都从 j=0 循环执行到 j=9。因此，该嵌套循环结构将执行 10*10 = 100 次。
嵌套循环执行的总次数 = 外循环执行次数 * 内循环执行次数
事实上，if 语句和循环（while、for）结构之间，也可以相互嵌套，举个例子：
i = 0
if i<10:
for j in range(5):
print("i=",i," j=",j)程序执行结果为：
i= 0 j= 0
i= 0 j= 1
i= 0 j= 2
i= 0 j= 3
i= 0 j= 4需要指明的是，上面程序演示的仅是 2 层嵌套结构，其实 if、while、for 之间完全支持多层（ ≥3 ）嵌套。例如：
if ...:
while ...:
for ...:
if ...:
...也就是说，只要场景需要，判断结构和循环结构之间完全可以相互嵌套，甚至可以多层嵌套。
十一、Python嵌套循环实现冒泡排序
冒泡排序是数据结构中的经典算法，手动实现冒泡排序，对初学者锻炼自己的编程逻辑有很大帮助，本节就带领大家使用循环结构实现冒泡排序算法。
冒泡排序算法的实现思想遵循以下几步：
- 比较相邻的元素，如果第一个比第二个大，就交换它们两个。
- 从最开始的第一对到结尾的最后一对，对每一对相邻元素做步骤 1 所描述的比较工作，并将最大的元素放在后面。这样，当从最开始的第一对到结尾的最后一对都执行完后，整个序列中的最后一个元素便是最大的数。
- 将循环缩短，除去最后一个数（因为最后一个已经是最大的了），再重复步骤 2 的操作，得到倒数第二大的数。
- 持续做步骤 3 的操作，每次将循环缩短一位，并得到本次循环中的最大数。直到循环个数缩短为 1，即没有任何一对数字需要比较，此时便得到了一个从小到大排序的序列。
通过分析冒泡排序算法的实现原理，要想实现该算法，需要借助循环结构，更确切地说，需要使用嵌套循环结构，使用 for 循环或者 while 循环都可以。
例如，使用 for 循环实现用冒泡排序算法对 [5,8,4,1] 进行排序：
data = [5,8,4,1]
#实现冒泡排序
for i in range(len(data)-1):
for j in range(len(data)-i-1):
if(data[j]>data[j+1]):
data[j],data[j+1] = data[j+1],data[j]
print("排序后：",data)运行结果为：
排序后： [1, 4, 5, 8]可以看到，实现冒泡排序使用了 2 层循环，其中外层循环负责冒泡排序进行的次数，而内层循环负责将列表中相邻的两个元素进行比较，并调整顺序，即将较小的放在前面，较大的放在后面。
十二、Python break用法 跳出当前循环体
我们知道，在执行 while 循环或者 for 循环时，只要循环条件满足，程序将会一直执行循环体，不停地转圈。但在某些场景，我们可能希望在循环结束前就强制结束循环，Python 提供了 2 种强制离开当前循环体的办法：
- 使用 continue 语句，可以跳过执行本次循环体中剩余的代码，转而执行下一次的循环。
- 只用 break 语句，可以完全终止当前循环。
本节先讲解 break 的用法，continue 语句放到下节做详细介绍。
break 语句可以立即终止当前循环的执行，跳出当前所在的循环结构。无论是 while 循环还是 for 循环，只要执行 break 语句，就会直接结束当前正在执行的循环体。
这就好比在操场上跑步，原计划跑 10 圈，可是当跑到第 2 圈的时候，突然想起有急事要办，于是果断停止跑步并离开操场，这就相当于使用了 break 语句提前终止了循环。
break 语句的语法非常简单，只需要在相应 while 或 for 语句中直接加入即可。例如如下程序：
add = "http://c.biancheng.net/python/,http://c.biancheng.net/shell/"
# 一个简单的for循环
for i in add:
if i == ',' :
#终止循环
break
print(i,end="")
print("\n执行循环体外的代码")运行结果为：
http://c.biancheng.net/python/
执行循环体外的代码分析上面程序不难看出，当循环至 add 字符串中的逗号（ , ）时，程序执行 break 语句，其会直接终止当前的循环，跳出循环体。
break 语句一般会结合 if 语句进行搭配使用，表示在某种条件下跳出循环体。
注意，通过前面的学习我们知道，for 循环后也可以配备一个 else 语句。这种情况下，如果使用 break 语句跳出循环体，不会执行 else 中包含的代码。举个例子：
add = "http://c.biancheng.net/python/,http://c.biancheng.net/shell/"
for i in add:
if i == ',' :
#终止循环
break
print(i,end="")
else:
print("执行 else 语句中的代码")
print("\n执行循环体外的代码")程序执行结果为：
http://c.biancheng.net/python/
执行循环体外的代码从输出结果可以看出，使用 break 跳出当前循环体之后，该循环后的 else 代码块也不会被执行。但是，如果将 else 代码块中的代码直接放在循环体的后面，则该部分代码将会被执行。
另外，对于嵌套的循环结构来说，break 语句只会终止所在循环体的执行，而不会作用于所有的循环体。举个例子：
add = "http://c.biancheng.net/python/,http://c.biancheng.net/shell/"
for i in range(3):
for j in add:
if j == ',':
break
print(j,end="")
print("\n跳出内循环")程序执行结果为：
http://c.biancheng.net/python/
跳出内循环
http://c.biancheng.net/python/
跳出内循环
http://c.biancheng.net/python/
跳出内循环分析上面程序，每当执行内层循环时，只要循环至 add 字符串中的逗号（ , ）就会执行 break 语句，它会立即停止执行当前所在的内存循环体，转而继续执行外层循环。
那么读者可能会问，在嵌套循环结构中，如何同时跳出内层循环和外层循环呢？最简单的方法就是借用一个 bool 类型的变量。
修改上面的程序：
add = "http://c.biancheng.net/python/,http://c.biancheng.net/shell/"
#提前定义一个 bool 变量，并为其赋初值
flag = False
for i in range(3):
for j in add:
if j == ',':
#在 break 前，修改 flag 的值
flag = True
break
print(j,end="")
print("\n跳出内循环")
#在外层循环体中再次使用 break
if flag == True:
print("跳出外层循环")
break可以看到，通过借助一个 bool 类型的变量 flag，在跳出内循环时更改 flag 的值，同时在外层循环体中，判断 flag 的值是否发生改动，如有改动，则再次执行 break 跳出外层循环；反之，则继续执行外层循环。
因此，上面程序的执行结果为：
http://c.biancheng.net/python/
跳出内循环
跳出外层循环当然，这里仅跳出了 2 层嵌套循环，此方法支持跳出多层嵌套循环。
十三、Python continue用法 直接执行下次循环
和 break 语句相比，continue 语句的作用则没有那么强大，它只会终止执行本次循环中剩下的代码，直接从下一次循环继续执行。
仍然以在操作跑步为例，原计划跑 10 圈，但当跑到 2 圈半的时候突然接到一个电话，此时停止了跑步，当挂断电话后，并没有继续跑剩下的半圈，而是直接从第 3 圈开始跑。
continue 语句的用法和 break 语句一样，只要 while 或 for 语句中的相应位置加入即可。例如：
add = "http://c.biancheng.net/python/,http://c.biancheng.net/shell/"
# 一个简单的for循环
for i in add:
if i == ',' :
# 忽略本次循环的剩下语句
print('\n')
continue
print(i,end="")运行上面程序，将看到如下运行结果：
http://c.biancheng.net/python/
http://c.biancheng.net/shell/可以看到，当遍历 add 字符串至逗号（ , ）时，会进入 if 判断语句执行 print() 语句和 continue 语句。其中，print() 语句起到换行的作用，而 continue 语句会使 Python 解释器忽略执行第 8 行代码，直接从下一次循环开始执行。
十四、怎么避免Python程序出现死循环（无限循环）？
要知道，每个循环结构（while 或 for）都必须有停止运行的途径，这样才不会没完没了地执行下去。
例如，下面的循环从1数到5：
x = 1
while x <= 5:
print(x)
x += 1运行结果为：
1
2
3
4
5但如果像下面这样不小心遗漏了代码行x += 1，那么这个循环将没完没了地运行：
#这个循环将没完没了地运行
x = 1
while x <= 5:
print(x)在这里，x 的初始值为 1，但根本不会变，因此条件测试x <= 5始终为 True，导致 while 循环没完没了地打印 1，运行结果如下所示：
1
1
1
1
--snip--每个程序员都会偶尔因为不小心而编写出无限（死）循环，在循环的退出条件比较微妙时尤其如此。
如果程序陷入无限循环，可按组合键Ctrl+C，也可关闭显示程序输出的终端窗口，如果前 2 种方式都无效，比如有些编辑器（如 Sublime Text）内嵌了输出窗口，这可能导致难以结束无限循环，因此不得不关闭编辑器来结束无限循环。
读者可能会问，怎样才能有效避免编写出包含无限循环的程序呢？
要避免编写无限（死）循环，应务必对每个 while 循环（或 for 循环）进行测试，确保它按预期那样结束。如果希望程序在用户输入特定值时结束，可运行程序并输入这样的值，如果此时程序没有结束，则说明该循环结构会无限循环，应检查程序处理这个值的方式。
总之，解决无限（死）循环的方法只有一个，即确认循环结构中至少有一个位置能让循环条件为 False 或让 break 语句得以执行。
十五、Python推导式，快速初始化各种序列
Python推导式（列表推导式、元组推导式、字典推导式和集合推导式）详解
推导式（又称解析器），是 Python 独有的一种特性。使用推导式可以快速生成列表、元组、字典以及集合类型的数据，因此推导式又可细分为列表推导式、元组推导式、字典推导式以及集合推导式。
1、Python列表推导式
列表推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的列表。
列表推导式的语法格式如下：
[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]此格式中，[if 条件表达式] 不是必须的，可以使用，也可以省略。
通过列表推导式的语法格式，明显会感觉到它和 for 循环存在某些关联。其实，除去 [if 条件表达式] 部分，其余各部分的含义以及执行顺序和 for 循环是完全一样的（表达式其实就是 for 循环中的循环体），即它的执行顺序如下所示：
for 迭代变量 in 可迭代对象
表达式初学者可以这样认为，它只是对 for 循环语句的格式做了一下简单的变形，并用 [] 括起来而已，只不过最大的不同之处在于，列表推导式最终会将循环过程中，计算表达式得到的一系列值组成一个列表。
例如如下代码（程序一）：
a_range = range(10)
# 对a_range执行for表达式
a_list = [x * x for x in a_range]
# a_list集合包含10个元素
print(a_list)上面代码的第 3 行会对 a_range 执行迭代，由于 a_range 相当于包含 10 个元素，因此程序生成的 a_list 同样包含 10 个元素，且每个元素都是 a_range 中每个元素的平方（由表达式 x*x 控制）。
运行上面代码，可以看到如下输出结果：
[0 , 1 , 4 , 9 , 16 , 25 , 36 , 49 , 64, 81]不仅如此，我们还可以在列表推导式中添加 if 条件语句，这样列表推导式将只迭代那些符合条件的元素。例如如下代码：
b_list = [x * x for x in a_range if x % 2 == 0]
# a_list集合包含5个元素
print(b_list)第一行代码与程序一中第 3 行代码大致相同，只是为这里给列表推导式增加了 if 条件语句，这会导致推导式只处理 range 区间的偶数，因此程序生成的 b_list 只包含 5 个元素。
运行上面代码，可以看到如下输出结果：
[0 ,4 , 16, 36, 64]另外，以上所看到的列表推导式都只有一个循环，实际上它可使用多个循环，就像嵌套循环一样。例如如下代码：
d_list = [(x, y) for x in range(5) for y in range(4)]
# d_list列表包含20个元素
print(d_list)上面代码中，x 是遍历 range(5) 的迭代变量（计数器），因此该 x 可迭代 5 次；y 是遍历 range(4) 的计数器，因此该 y 可迭代 4 次。因此，该（x,y）表达式一共会迭代 20 次。上面的 for 表达式相当于如下嵌套循环：
dd_list = []
for x in range(5):
for y in range(4):
dd_list.append((x, y))运行上面代码，可以看到如下输出结果：
[(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (4, 3)]当然，也支持类似于三层嵌套的 for 表达式，例如如下代码：
e_list = [[x, y, z] for x in range(5) for y in range(4) for z in range(6)]
# e_list列表包含120个元素
print(e_list)对于包含多个循环的 for 表达式，同样可指定 if 条件。假如我们有一个需求：程序要将两个列表中的数值按“能否整除”的关系配对在一起。比如 src_a 列表中包含 30，src_b 列表中包含 5，其中 30 可以整除 5，那么就将 30 和 5 配对在一起。对于上面的需求使用 for 表达式来实现非常简单，例如如下代码：
src_a = [30, 12, 66, 34, 39, 78, 36, 57, 121]
src_b = [3, 5, 7, 11]
# 只要y能整除x，就将它们配对在一起
result = [(x, y) for x in src_b for y in src_a if y % x == 0]
print(result)运行上面代码，可以看到如下输出结果：
[(3, 30), (3, 12), (3, 66), (3, 39), (3, 78), (3, 36), (3, 57), (5, 30), (11, 66), (11, 121)]2、Python元组推导式
元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。
元组推导式的语法格式如下：
(表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] )其中，用 [] 括起来的部分，可以使用，也可以省略。
通过和列表推导式做对比，你会发现，除了元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是 []，其它完全相同。不仅如此，元组推导式和列表推导式的用法也完全相同。
例如，我们可以使用下面的代码生成一个包含数字 1~9 的元组：
a = (x for x in range(1,10))
print(a)运行结果为：
at 0x0000020BAD136620> 从上面的执行结果可以看出，使用元组推导式生成的结果并不是一个元组，而是一个生成器对象（后续会介绍），这一点和列表推导式是不同的。
如果我们想要使用元组推导式获得新元组或新元组中的元素，有以下三种方式：
- 使用 tuple() 函数，可以直接将生成器对象转换成元组，例如：
a = (x for x in range(1,10)) print(tuple(a)) 运行结果为： (1, 2, 3, 4, 5, 6, 7, 8, 9) - 直接使用 for 循环遍历生成器对象，可以获得各个元素，例如：
运行结果为：a = (x for x in range(1,10)) for i in a: print(i,end=' ') print(tuple(a))(1 2 3 4 5 6 7 8 9 ) - 使用 __next__() 方法遍历生成器对象，也可以获得各个元素，例如：
运行结果为：a = (x for x in range(3)) print(a.__next__()) print(a.__next__()) print(a.__next__()) a = tuple(a) print("转换后的元组：",a)0 1 2 转换后的元组： ()
注意，无论是使用 for 循环遍历生成器对象，还是使用 __next__() 方法遍历生成器对象，遍历后原生成器对象将不复存在，这就是遍历后转换原生成器对象却得到空元组的原因。
3、Python字典推导式
Python 中，使用字典推导式可以借助列表、元组、字典、集合以及 range 区间，快速生成符合需求的字典。
字典推导式的语法格式如下：
{表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]}其中，用 [] 括起来的部分，可以使用，也可以省略。
可以看到，和其它推导式的语法格式相比，唯一不同在于，字典推导式用的是大括号{}。
【例 1】
listdemo = ['C语言中文网','c.biancheng.net']
#将列表中各字符串值为键，各字符串的长度为值，组成键值对
newdict = {key:len(key) for key in listdemo}
print(newdict)运行结果为：
{'C语言中文网': 6, 'c.biancheng.net': 15}【例 2】交换现有字典中各键值对的键和值。
olddict={'C语言中文网': 6, 'c.biancheng.net': 15}
newdict = {v: k for k, v in olddict.items()}
print(newdict)运行结果为：
{6: 'C语言中文网', 15: 'c.biancheng.net'}【例 3】使用 if 表达式筛选符合条件的键值对。
olddict={'C语言中文网': 6, 'c.biancheng.net': 15}
newdict = {v: k for k, v in olddict.items() if v>10}
print(newdict)运行结果为：
{15: 'c.biancheng.net'}4、Python集合推导式
Python中，使用集合推导式可以借助列表、元组、字典、集合以及 range 区间，快速生成符合需求的集合。
集合推导式的语法格式和字典推导式完全相同，如下所示：
{ 表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] }其中，用 [] 括起来的部分，可以使用，也可以省略。
有读者可能会问，集合推导式和字典推导式的格式完全相同，那么给定一个类似的推导式，如何判断是哪种推导式呢？最简单直接的方式，就是根据表达式进行判断，如果表达式以键值对（key：value）的形式，则证明此推导式是字典推导式；反之，则是集合推导式。
【例 1】
setnew = {i**2 for i in range(3)}
print(setnew)运行结果为：
{0, 1, 4}【例 2】既然生成的是集合，那么其保存的元素必须是唯一的。
tupledemo = (1,1,2,3,4,5,6,6)
setnew = {x**2 for x in tupledemo if x%2==0}
print(setnew)运行结果为:
{16, 4, 36}【例 3】
dictdemo = {'1':1,'2':2,'3':3}
setnew = {x for x in dictdemo.keys()}
print(setnew)运行结果为：
{'2', '1', '3'}十六、Python zip函数及用法
zip() 函数是 Python 内置函数之一，它可以将多个序列（列表、元组、字典、集合、字符串以及 range() 区间构成的列表）“压缩”成一个 zip 对象。所谓“压缩”，其实就是将这些序列中对应位置的元素重新组合，生成一个个新的元组。
和 Python 3.x 版本不同，Python 2.x 版本中的 zip() 函数会直接返回列表，而不是返回 zip 对象。但是，返回的列表或者 zip 对象，其包含的元素（都是元组）是相同的。
zip() 函数的语法格式为：
zip(iterable, ...)其中 iterable,... 表示多个列表、元组、字典、集合、字符串，甚至还可以为 range() 区间。
下面程序演示了 zip() 函数的基本用法：
my_list = [11,12,13]
my_tuple = (21,22,23)
print([x for x in zip(my_list,my_tuple)])
my_dic = {31:2,32:4,33:5}
my_set = {41,42,43,44}
print([x for x in zip(my_dic)])
my_pychar = "python"
my_shechar = "shell"
print([x for x in zip(my_pychar,my_shechar)])程序执行结果为：
[(11, 21), (12, 22), (13, 23)]
[(31,), (32,), (33,)]
[('p', 's'), ('y', 'h'), ('t', 'e'), ('h', 'l'), ('o', 'l')]如果读者分析以上的程序和相应的输出结果不难发现，在使用 zip() 函数“压缩”多个序列时，它会分别取各序列中第 1 个元素、第 2 个元素、... 第 n 个元素，各自组成新的元组。需要注意的是，当多个序列中元素个数不一致时，会以最短的序列为准进行压缩。
另外，对于 zip() 函数返回的 zip 对象，既可以像上面程序那样，通过遍历提取其存储的元组，也可以向下面程序这样，通过调用 list() 函数将 zip() 对象强制转换成列表：
my_list = [11,12,13]
my_tuple = (21,22,23)
print(list(zip(my_list,my_tuple)))程序执行结果为：
[(11, 21), (12, 22), (13, 23)]十七、Python reversed函数及用法
reserved() 是 Pyton 内置函数之一，其功能是对于给定的序列（包括列表、元组、字符串以及 range(n) 区间），该函数可以返回一个逆序序列的迭代器（用于遍历该逆序序列）。
reserved() 函数的语法格式如下：
reversed(seq)其中，seq 可以是列表，元素，字符串以及 range() 生成的区间列表。
下面程序演示了 reversed() 函数的基本用法：
#将列表进行逆序
print([x for x in reversed([1,2,3,4,5])])
#将元组进行逆序
print([x for x in reversed((1,2,3,4,5))])
#将字符串进行逆序
print([x for x in reversed("abcdefg")])
#将 range() 生成的区间列表进行逆序
print([x for x in reversed(range(10))])程序执行结果为：
[5, 4, 3, 2, 1]
[5, 4, 3, 2, 1]
['g', 'f', 'e', 'd', 'c', 'b', 'a']
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]除了使用列表推导式的方式，还可以使用 list() 函数，将 reversed() 函数逆序返回的迭代器，直接转换成列表。例如：
#将列表进行逆序
print(list(reversed([1,2,3,4,5])))程序执行结果为：
[5, 4, 3, 2, 1]再次强调，使用 reversed() 函数进行逆序操作，并不会修改原来序列中元素的顺序，例如：
a = [1,2,3,4,5]
#将列表进行逆序
print(list(reversed(a)))
print("a=",a)程序执行结果为：
[5, 4, 3, 2, 1]
a= [1, 2, 3, 4, 5]十八、Python sorted函数及用法
sorted() 作为 Python 内置函数之一，其功能是对序列（列表、元组、字典、集合、还包括字符串）进行排序。（默认升序）
sorted() 函数的基本语法格式如下：
list = sorted(iterable, key=None, reverse=False) 其中，iterable 表示指定的序列，key 参数可以自定义排序规则；reverse 参数指定以升序（False，默认）还是降序（True）进行排序。sorted() 函数会返回一个排好序的列表。
注意，key 参数和 reverse 参数是可选参数，即可以使用，也可以忽略。
下面程序演示了 sorted() 函数的基本用法：
#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a))
#对元组进行排序
a = (5,4,3,1,2)
print(sorted(a))
#字典默认按照key进行排序
a = {4:1,\
5:2,\
3:3,\
2:6,\
1:8}
print(sorted(a.items()))
#对集合进行排序
a = {1,5,3,2,4}
print(sorted(a))
#对字符串进行排序
a = "51423"
print(sorted(a))程序执行结果为：
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[(1, 8), (2, 6), (3, 3), (4, 1), (5, 2)]
[1, 2, 3, 4, 5]
['1', '2', '3', '4', '5']再次强调，使用 sorted() 函数对序列进行排序， 并不会在原序列的基础进行修改，而是会重新生成一个排好序的列表。例如：
#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a))
#再次输出原来的列表 a
print(a)程序执行结果为：
[1, 2, 3, 4, 5]
[5, 3, 4, 2, 1]显然，sorted() 函数不会改变所传入的序列，而是返回一个新的、排序好的列表。
除此之外，sorted(）函数默认对序列中元素进行升序排序，通过手动将其 reverse 参数值改为 True，可实现降序排序。例如：
#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a,reverse=True))程序执行结果为：
[5, 4, 3, 2, 1]另外在调用 sorted() 函数时，还可传入一个 key 参数，它可以接受一个函数，该函数的功能是指定 sorted() 函数按照什么标准进行排序。例如：
chars=['http://c.biancheng.net',\
'http://c.biancheng.net/python/',\
'http://c.biancheng.net/shell/',\
'http://c.biancheng.net/java/',\
'http://c.biancheng.net/golang/']
#默认排序
print(sorted(chars))
#自定义按照字符串长度排序
print(sorted(chars,key=lambda x:len(x)))程序执行结果为：
['http://c.biancheng.net',
'http://c.biancheng.net/golang/',
'http://c.biancheng.net/java/',
'http://c.biancheng.net/python/',
'http://c.biancheng.net/shell/']
['http://c.biancheng.net',
'http://c.biancheng.net/java/',
'http://c.biancheng.net/shell/',
'http://c.biancheng.net/python/',
'http://c.biancheng.net/golang/']此程序中，使用了 lambda 表示式，其用法会在后续章节进行详细介绍。