Python 流程控制（判断&循环）

程序，都只是从第一行代码开始逐条执行，但这远远不能满足开发的需求，因为在很多场景中，我们需要选择性地执行一部分语句。

Python 条件控制语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。

比如说，编程实现“只有当用户输入用户名和密码正确时，才能成功登陆系统；反之则登陆失败，无法进入系统”，要实现这样地功能，只凭借前面所学的知识是做不到的，需要使用本节所讲的选择（条件）语句才能实现。

Python 中，选择（条件）语句可细分为 3 种形式，分别是 if 语句、if else 语句和 if elif else 语句。

选择结构

选择结构通过判断条件是否成立，来决定执行哪个分支。选择结构有多种形式，分为：单分支、双分支、多分支。流程图如下：

单分支选择结构

单分支结构

if 语句单分支结构的语法形式如下：

if 条件表达式:
    语句/语句块

其中：
1 ．条件表达式：可以是逻辑表达式、关系表达式、算术表达式等等。
2 ．语句/语句块：可以是一条语句，也可以是多条语句。多条语句，缩进必须对齐一致。

【操作】输入一个数字，小于 10，则打印这个数字

num = input("输入一个数字：") 
if int(num)<10: 
    print(num)

条件表达式详解

在选择和循环结构中，条件表达式的值为 False 的情况如下：

False、0、0.0、空值 None、空序列对象（空列表、空元祖、空集合、空字典、空字符串）、空 range 对象、空迭代对象。

其他情况，均为 True。这么看来，Python 所有的合法表达式都可以看做条件表达式，甚至包括函数调用的表达式。

【操作】测试各种条件表达式

if 3: #整数作为条件表达式 
    print("ok") 
a = [] #列表作为条件表达式，由于为空列表，是 False 
if a: 
    print("空列表，False") 
s = "False" #非空字符串，是 True 
if s:
    print("非空字符串，是 True") 
c = 9 
if 3<c<20: 
    print("3<c<20") 
if 3<c and c<20: 
    print("3<c and c<20") 
if True: #布尔值 
    print("True")

执行结果如下：

ok
非空字符串，是 True 
3<c<20 
3<c and c<20 
True

·条件表达式中，不能有赋值操作符“=”

在 Python 中，条件表达式不能出现赋值操作符“=”，避免了其他语言中经常误将关系运算符“==”写作赋值运算符“=”带来的困扰。如下代码将会报语法错误：

if 3<c and (c=20): 
    print("赋值符不能出现在条件表达式中")

双分支选择结构

双分支结构的语法格式如下：

if 条件表达式 : 
    语句 1/语句块 1 
else:
    语句 2/语句块 2

【操作】输入一个数字，小于 10，则打印该数字；大于 10，则打印“数字太大”

num = input("输入一个数字：") 
if int(num)<10: 
    print(num) 
else:
    print("数字太大")

三元条件运算符

Python 提供了三元运算符，用来在某些简单双分支赋值情况。三元条件运算符语法格式如下：

条件为真时的值 if (条件表达式) else 条件为假时的值

上一个案例代码，可以用三元条件运算符实现：

num = input("请输入一个数字") 
    print( num if int(num)<10 else "数字太大")

可以看到，这种写法更加简洁，易读。

多分枝选择结构

多分支结构

多分支选择结构的语法格式如下：

if 条件表达式 1 : 
    语句 1/语句块 1 
elif 条件表达式 2: 
    语句 2/语句块 2 
.
.
.
elif 条件表达式 n : 
    语句 n/语句块 n 
[else:
    语句 n+1/语句块 n+1 
]

【注】计算机行业，描述语法格式时，使用中括号[]通常表示可选，非必选。

双分支结构

多分支结构，几个分支之间是有逻辑关系的，不能随意颠倒顺序。

【操作】输入一个学生的成绩，将其转化成简单描述：不及格(小于 60)、及格(60-79)、良好(80-89)、优秀(90-100)。

方法 1（使用完整的条件表达）

score = int(input("请输入分数")) 
grade = '' 
if(score<60): 
    grade = "不及格" 
if(60<=score<80): 
    grade = "及格" 
if(80<=score<90): 
    grade = "良好" 
if(90<=score<=100): 
    grade = "优秀" 
print("分数是{0},等级是{1}".format(score,grade))

每个分支都使用了独立的、完整的判断，顺序可以随意挪动，而不影响程序运行。

方法 2（利用多分支结构）

score = int(input("请输入分数")) 
grade = '' if score<60 : 
    grade = "不及格" 
elif score<80 : 
    grade = "及格" 
elif score<90 : 
    grade = "良好" 
elif score<=100: 
    grade = "优秀" 
print("分数是{0},等级是{1}".format(score,grade))

多分支结构，几个分支之间是有逻辑关系的，不能随意颠倒顺序。

【操作】已知点的坐标(x,y)，判断其所在的象限

x = int(input("请输入 x 坐标")) 
y = int(input("请输入 y 坐标")) 
if(x==0 and y==0):print("原点") 
elif(x==0):print("y 轴") 
elif(y==0):print("x 轴") 
elif(x>0 and y>0):print("第一象限") 
elif(x<0 and y>0):print("第二象限") 
elif(x<0 and y<0):print("第三象限") 
else:
    print("第四象限")

选择结构嵌套

选择结构可以嵌套，使用时一定要注意控制好不同级别代码块的缩进量，因为缩进量决定了代码的从属关系。语法格式如下：

if 表达式 1：
    语句块 1 
    if 表达式 2： 
         语句块 2 
    else:
        语句块 3 
else:
    if 表达式 4： 
        语句块 4

【操作】输入一个分数。分数在 0-100 之间。90 以上是 A,80 以上是 B，70 以上是 C，60 以上是 D。60 以下是 E。

score = int(input("请输入一个在 0-100 之间的数字：")) 
grade = "" 
if score>100 or score<0: 
    score = int(input("输入错误！请重新输入一个在 0-100 之间的数字：")) 
else:
    if score>=90: 
        grade = "A" 
    elif score>=80: 
        grade = 'B' 
    elif score>=70: 
        grade = 'C' 
    elif score>=60: 
        grade = 'D' 
    else:
        grade = 'E' 
print("分数为{0},等级为{1}".format(score,grade)) 
--------------------------------------------------------
#或者也可以用下面代码更少的方法。不过，需要大家思考为什么这么写了 
score = int(input("请输入一个在 0-100 之间的数字：")) 
degree = "ABCDE" 
num = 0 
if score>100 or score<0: 
    score = int(input("输入错误！请重新输入一个在 0-100 之间的数字：")) 
else:
    num = score//10 
    if num<6:num=5 
    print("分数是{0},等级是{1}".format(score,degree[9-num]))

循环结构

循环结构用来重复执行一条或多条语句。表达这样的逻辑：如果符合条件，则反复执行循环体里的语句。在每次执行完后都会判断一次条件是否为 True，如果为 True 则重复执行循环体里的语句。图示如下：

循环体里面的语句至少应该包含改变条件表达式的语句，以使循环趋于结束；否则，就会变成一个死循环。

while 循环

while 循环的语法格式如下：

while 条件表达式： 
    循环体语句

我们通过一些简单的练习，来慢慢熟悉 while 循环。

【操作】利用 while 循环打印从 0-10 的数字。

num = 0 
while num<=10: 
    print(num) 
    num += 1

【操作】利用 while 循环，计算 1-100 之间数字的累加和；计算 1-100 之间偶数的累加和，计算 1-100 之间奇数的累加和。

num = 0 
sum_all = 0 #1-100 所有数的累加和
sum_even = 0 #1-100 偶数的累加和 
sum_odd = 0 #1-100 奇数的累加和 
while num<=100: 
    sum_all += num 
    if num%2==0:
        sum_even += num 
    else:
        sum_odd += num num += 1 #迭代，改变条件表达式，使循环趋于结束 
print("1-100 所有数的累加和",sum_all) 
print("1-100 偶数的累加和",sum_even) 
print("1-100 奇数的累加和",sum_odd)

for 循环和可迭代对象遍历

for 循环通常用于可迭代对象的遍历。for 循环的语法格式如下：

for 变量 in 可迭代对象： 
    循环体语句

【操作】遍历一个元组或列表

for x in (20,30,40): 
    print(x*3)

可迭代对象

Python 包含以下几种可迭代对象：

序列。包含：字符串、列表、元组
字典
迭代器对象（iterator）
生成器函数（generator）
文件对象

我们已经在前面学习了序列、字典等知识，迭代器对象和生成器函数将在后面进行详解。接下来，我们通过循环来遍历这几种类型的数据：

【操作】遍历字符串中的字符

for x in "sxt001": 
    print(x)

【操作】遍历字典

d = {'name':'gaoqi','age':18,'address':'西三旗 001 号楼'} 
for x in d: #遍历字典所有的 key 
    print(x) 
for x in d.keys():#遍历字典所有的 key 
    print(x) 
for x in d.values():#遍历字典所有的 value                           
    print(x) 
for x in d.items():#遍历字典所有的"键值对"         
    print(x)

range 对象

range 对象是一个迭代器对象，用来产生指定范围的数字序列。格式为：

range(start, end [,step])

生成的数值序列从 start 开始到 end 结束（不包含 end）。若没有填写 start，则默认从 0 开始。step 是可选的步长，默认为 1。如下是几种典型示例：

for i in range(10) 产生序列：0 1 2 3 4 5 6 7 8 9 
for i in range(3,10) 产生序列：3 4 5 6 7 8 9   
for i in range(3,10,2) 产生序列：3 5 7 9

【操作】利用 for 循环，计算 1-100 之间数字的累加和；计算 1-100 之间偶数的累加和，计算 1-100 之间奇数的累加和。

sum_all = 0 #1-100 所有数的累加和 
sum_even = 0 #1-100 偶数的累加和 
sum_odd = 0 #1-100 奇数的累加和 
for num in range(101): 
    sum_all += num
    if num%2==0:
        sum_even += num 
    else:
        sum_odd += num 
print("1-100 累加总和{0},奇数和{1},偶数和{2}".format(sum_all,sum_odd,sum_even))

嵌套循环和综合练习

一个循环体内可以嵌入另一个循环，一般称为“嵌套循环”，或者“多重循环”。

【操作】打印如下图案

0 0 0 0 0
1 1 1 1 1
2 2 2 2 2
3 3 3 3 3
4 4 4 4 4

for x in range(5): 
    for y in range(5): 
        print(x,end="\t") 
    print() #仅用于换行

【操作】利用嵌套循环打印九九乘法表

for m in range(1,10): 
    for n in range(1,m+1): 
        print("{0}*{1}={2}".format(m,n,(m*n)),end="\t") 
    print()

执行结果：

1*1=1 
2*1=2 2*2=4 
3*1=3 3*2=6 3*3=9 
4*1=4 4*2=8 4*3=12 4*4=16 
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

【操作】用列表和字典存储下表信息，并打印出表中工资高于 15000 的数据

姓名	年龄	薪资	城市
cc	18	30000	北京
xjz	19	20000	上海
xhd	20	10000	深圳

r1= dict(name="高小一",age=18,salary=30000,city="北京") 
r2= dict(name="高小二",age=19,salary=20000,city="上海") 
r3= dict(name="高小三",age=20,salary=10000,city="深圳") 
tb = [r1,r2,r3] 
for x in tb: 
    if x.get("salary")>15000: 
        print(x)

break 语句

break 语句可用于 while 和 for 循环，用来结束整个循环。当有嵌套循环时，break 语句只能跳出最近一层的循环。

【操作】使用 break 语句结束循环

while True: 
    a = input("请输入一个字符（输入 Q 或 q 结束）") 
    if a.upper()=='Q': 
        print("循环结束，退出") 
        break 
    else:
        print(a)

continue 语句

continue 语句用于结束本次循环，继续下一次。多个循环嵌套时，continue 也是应用于最近的一层循环。

【操作】要求输入员工的薪资，若薪资小于 0 则重新输入。最后打印出录入员工的数量和薪资明细，以及平均薪资

empNum = 0 
salarySum= 0 
salarys = [] 
while True: 
    s = input("请输入员工的薪资（按 Q 或 q 结束）") 
    if s.upper()=='Q': 
        print("录入完成，退出") 
        break
    if float(s)<0: 
        continue 
    empNum +=1 
    salarys.append(float(s)) 
    salarySum += float(s) 
print("员工数{0}".format(empNum)) 
print("录入薪资：",salarys) 
print("平均薪资{0}".format(salarySum/empNum))

执行结果：

请输入员工的薪资（按 Q 或 q 结束）2000 
请输入员工的薪资（按 Q 或 q 结束）3000 
请输入员工的薪资（按 Q 或 q 结束）4000 
请输入员工的薪资（按 Q 或 q 结束）5000 
请输入员工的薪资（按 Q 或 q 结束）Q 
录入完成，退出 
员工数 4 
录入薪资： [2000.0, 3000.0, 4000.0, 5000.0] 
平均薪资 3500.0

else 语句

while、for 循环可以附带一个 else 语句（可选）。如果 for、while 语句没有被 break 语句结束，则会执行 else 子句，否则不执行。语法格式如下：

while 条件表达式： 
    循环体 
else:
    语句块 
或者： 
for 变量 in 可迭代对象： 
    循环体 
else:
    语句块

【操作】员工一共 4 人。录入这 4 位员工的薪资。全部录入后，打印提示“您已经全部录入 4 名员工的薪资”。最后，打印输出录入的薪资和平均薪资

salarySum= 0 
salarys = [] 
for i in range(4): 
    s = input("请输入一共 4 名员工的薪资（按 Q 或 q 中途结束）") 
    if s.upper()=='Q': 
        print("录入完成，退出") 
        break 
    if float(s)<0: 
        continue 
    salarys.append(float(s)) 
    salarySum += float(s) 
else:
    print("您已经全部录入 4 名员工的薪资") 
print("录入薪资：",salarys) 
print("平均薪资{0}".format(salarySum/4))

循环代码优化

虽然计算机越来越快，空间也越来越大，我们仍然要在性能问题上“斤斤计较”。编写循环时，遵守下面三个原则可以大大提高运行效率，避免不必要的低效计算：

尽量减少循环内部不必要的计算
嵌套循环中，尽量减少内层循环的计算，尽可能向外提。

局部变量查询较快，尽量使用局部变量

 #循环代码优化测试 
 import time 
 start = time.time() 
 for i in range(1000): 
     result = []
     for m in range(10000): 
         result.append(i*1000+m*100) 
 end = time.time() 
 print("耗时：{0}".format((end-start))) 
 start2 = time.time() 
 for i in range(1000): 
     result = [] 
     c = i*1000 
     for m in range(10000): 
         result.append(c+m*100) 
 end2 = time.time() 
 print("耗时：{0}".format((end2-start2)))

其他优化手段

连接多个字符串，使用 join()而不使用+
列表进行元素插入和删除，尽量在列表尾部操作

使用 zip()并行迭代

我们可以通过 zip()函数对多个序列进行并行迭代，zip()函数在最短序列“用完”时就会停止。

【操作】测试 zip()并行迭代

names = ("cc","xjz","xhd","xyj")
ages = (18,16,20,25) 
jobs = ("老师","程序员","公务员") 
for name,age,job in zip(names,ages,jobs):
    print("{0}--{1}--{2}".format(name,age,job))

执行结果：

cc--18--老师 
xjz--16--程序员 
xhd--20--公务员

推导式创建序列

推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合，从而避免冗长的代码。推导式是典型的 Python 风格，会使用它代表你已经超过 Python 初学者的水平。

列表推导式

列表推导式生成列表对象，语法如下：

[表达式 for item in 可迭代对象 ] 
或者：
{表达式 for item in 可迭代对象 if 条件判断}

>>> [x for x in range(1,5)] 
[1, 2, 3, 4] 
>>> [x*2 for x in range(1,5)] 
[2, 4, 6, 8] 
>>> [x*2 for x in range(1,20) if x%5==0 ] 
[10, 20, 30] 
>>> [a for a in "abcdefg"] 
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> cells = [(row,col) for row in range(1,10) for col in range(1,10)] #可以使用两 个循环 
>>> for cell in cells: 
    print(cell)

字典推导式

字典的推导式生成字典对象，格式如下：

{key_expression : value_expression for 表达式 in 可迭代对象}

类似于列表推导式，字典推导也可以增加 if 条件判断、多个 for 循环。

统计文本中字符出现的次数：

>>> my_text = ' i love you, i love sxt, i love gaoqi' 
>>> char_count = {c:my_text.count(c) for c in my_text} 
>>> char_count 
{' ': 9, 'i': 4, 'l': 3, 'o': 5, 'v': 3, 'e': 3, 'y': 1, 'u': 1, ',': 2, 's': 1, 'x': 1, 't': 1, 'g': 1, 'a': 1, 'q': 1}

集合推导式

集合推导式生成集合，和列表推导式的语法格式类似：

{表达式 for item in 可迭代对象 } 
或者：
{表达式 for item in 可迭代对象 if 条件判断} 

>>> {x for x in range(1,100) if x%9==0} 
{99, 36, 72, 9, 45, 81, 18, 54, 90, 27, 63}

生成器推导式（生成元组）

很多同学可能会问：“都有推导式，元组有没有？”，能不能用小括号呢？

>>> (x for x in range(1,100) if x%9==0) 
<generator object <genexpr> at 0x0000000002BD3048>

我们发现提示的是“一个生成器对象”。显然，元组是没有推导式的。

一个生成器只能运行一次。第一次迭代可以得到数据，第二次迭代发现数据已经没有了。

>>> gnt = (x for x in range(1,100) if x%9==0) 
>>> for x in gnt: 
    print(x,end=' ') 
9 18 27 36 45 54 63 72 81 90 99 
>>> for x in gnt: 
    print(x,end=' ') 
>>>

综合练习

【操作】绘制多个同心圆

 import turtle 
 t = turtle.Pen() 
 my_colors = ("red","green","yellow","black")
 t.width(4) 
 t.speed(1) 
 for i in range(10): #0 1 2 3 4 
     t.penup() 
     t.goto(0,-i*10) #0, -100,-200,-300,-400 
     t.pendown()
     t.color(my_colors[i%len(my_colors)]) 
     t.circle(15+i*10) #100,200,300, 400,, 500 
 turtle.done() #程序执行完，窗口仍然在

运行效果：

【操作】绘制 18*18 棋盘

 #画棋盘 
 import turtle 
 width = 30 
 num = 18 
 x1 = [(-400,400),(-400+width*num,400)]
 y1 = [(-400,400),(-400,400-width*num)] 
 t = turtle.Pen() 
 t.speed(10) 
 # t.goto(x1[0][0],x1[0][1]) 
 # t.goto(x1[1][0],x1[1][1]) 
 for i in range(0,19): 
     t.penup() 
     t.goto(x1[0][0],x1[0][1]-30*i) 
     t.pendown() 
     t.goto(x1[1][0],x1[1][1]-30*i) 
 for i in range(0,19): 
     t.penup() 
     t.goto(y1[0][0]+30*i,y1[0][1])
     t.pendown() 
     t.goto(y1[1][0]+30*i,y1[1][1]) 
 t.hideturtle() #隐藏画笔 
 turtle.done() #保证运行窗口不被自动关闭

运行结果：

实操作业

输入一个学生的成绩，将其转化成简单描述：不及格(小于 60)、及格(60-79)、良好 (80-89)、优秀(90-100)
已知点的坐标(x,y)，判断其所在的象限
输入一个分数。分数在 0-100 之间。90 以上是 A,80 以上是 B，70 以上是 C，60 以上是 D。60 以下是 E
利用 while 循环，计算 1-100 之间数字的累加和；计算 1-100 之间偶数的累加和，计算 1-100 之间奇数的累加和
利用 for 循环，计算 1-100 之间数字的累加和；计算 1-100 之间偶数的累加和，计算 1-100 之间奇数的累加和
打印如下图案

0 0 0 0 0
1 1 1 1 1
2 2 2 2 2
3 3 3 3 3
4 4 4 4 4

利用嵌套循环打印九九乘法表
用列表和字典存储下表信息，并打印出表中工资高于 15000 的数据

姓名	年龄	薪资	城市
cc	18	30000	北京
xjz	19	20000	上海
xhd	20	10000	深圳

要求输入员工的薪资，若薪资小于 0 则重新输入。最后打印出录入员工的数量和薪资明细，以及平均薪资
员工一共 4 人。录入这 4 位员工的薪资。全部录入后，打印提示“您已经全部录入 4 名员工的薪资”。最后，打印输出录入的薪资和平均薪资
使用海龟绘图，绘制同心圆：
使用海龟绘图，绘制 18*18 的棋盘：

最后编辑于：2019.08.23 20:25:00

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 216,470评论 6赞 501
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 92,393评论 3赞 392
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 162,577评论 0赞 353
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 58,176评论 1赞 292
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 67,189评论 6赞 388
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 51,155评论 1赞 299
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 40,041评论 3赞 418
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,903评论 0赞 274
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 45,319评论 1赞 310
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,539评论 2赞 332
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,703评论 1赞 348
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,417评论 5赞 343
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 41,013评论 3赞 325
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,664评论 0赞 22
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,818评论 1赞 269
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,711评论 2赞 368
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,601评论 2赞 353

Python 流程控制（判断&循环）

选择结构

单分支选择结构

条件表达式详解

双分支选择结构

三元条件运算符

多分枝选择结构

选择结构嵌套

循环结构

while 循环

for 循环和可迭代对象遍历

可迭代对象

range 对象

嵌套循环和综合练习

break 语句

continue 语句

else 语句

循环代码优化

其他优化手段

使用 zip()并行迭代

推导式创建序列

列表推导式

字典推导式

集合推导式

生成器推导式（生成元组）

综合练习

实操作业

推荐阅读更多精彩内容