目录
- Python 提供了两种基本流程控制结构
- 分支结构(实现根据条件来选择性地执行某段代码)
- if
- 循环结构(实现根据循环条件重复执行某段代码)
- while / for…in
- 控制循环
- break / continue
顺序结构
- 如果没有控制流程,python 程序的语句是一个顺序执行流,从上向下依次执行每条语句
if 分支结构
-
if 分支使用布尔表达式或布尔值(bool)作为条件分支条件来进行分支控制
-
Python 的 if 语句由如下三种形式
# 第一种形式
if expression :
statements...
# 第二种形式
if expression :
statements...
else :
statements...
# 第三种形式
if expression :
statements...
elif expression : // 可以有零条或多条 elif 语句
statements...
else:
statement...
- 如果 if 条件为 ”真",程序就会执行 if 条件后面的多条语句
- 否则就会依次判断 elif 条件,如果 elif 条件为 “真”,程序就会执行 elif 条件后面的多条语句
- 如果前面的条件都为 “假”,程序就会执行 else 后的代码块(如果有)====================================================================
- if expression:, elif expression:, else:, 后缩进的多行代码被成为代码块
- 一个代码块通常被当成一个整体来执行(除非在运行过程中遇到 return, break, continue 等关键字)因此这个代码块也被成为条件执行体
# Python 是一门很 独特 的语言,它的代码块是通过缩进来标记的(大部分语言都使用花括号或 end 作为代码块的标记)
# - 具有相同缩进的多行代码属于同一个代码块
# - 如果代码莫名奇妙地乱缩进,Python解释器会报错(Python不是格式自由的语言)
s_age = input('请输入您的年龄:')
age = int(s_age)
if age > 20:
# 只有当 age 大于 20 时,下面整体缩进的代码块才会被执行
# 整体缩进的语句是一个整体,要么一起执行,要么一起不执行
print('年龄已经大于20岁了')
print('20岁以上的人应该学会承担责任')
不要忘记缩进
- 代码块一定要缩进,否则就不是代码块
- if 条件后的条件执行体一定要缩进。只有缩进后的代码才能算条件执行体
- Python 通常建议缩进为 4 个空格
s_age = input('请输入您的年龄:')
age = int(s_age)
if age > 20:
print('20岁以上的人应该学会承担责任')
# 上面程序的 if 条件下面 print 语句位于同一条竖线上
# 这样在 if 条件下就没有受控制的代码块了
# 定义变量b,并为其赋值
b = 5
if b > 4:
# 如果 b > 4,则执行下面的条件执行体,只有一行代码作为代码块
print('b 大于 4')
else:
# 否则,执行下面的条件执行体,只有一行代码作为代码块
b -= 1
# 对于下面代码而言,它已经不再是条件执行体的一部分,因此总会执行
print('b 不大于4')
# 定义变量 c,并为其赋值
c = 5
if c > 4:
# 如果 c > 4,则执行下面的条件执行体,只有 c-=1 一行代码为条件执行体
c -= 1
# 下面一行是普通代码,不属于条件执行体
print("c大于4")
# 此处的 else 将没有 if 语句,依次编译出错
else:
# 否则,执行下面的条件执行体,只有一行代码作为代码块
print("c 不大于 4")
不要随意缩进
# 虽然 Python 语法允许代码块随意缩进 N 个空格,但同一个代码块内的代码必须保持相同的缩进
# 不能一会缩进2个空格,一会缩进4个空格
s_age = input('请输入您的年龄:')
age = int(s_age)
if age > 20:
print('年龄已经大于20岁了') # 缩进 4 个
print('20岁以上的人应该学会承担责任...') # 缩进 5 个(同一个代码块的代码应该缩进相同的空格)
# python 代码块种的所有语句必须保持相同的缩进,既不能多,也不能少
# 对于不需要使用代码块的地方,千万不要随意缩进,否则程序也会报错
不要遗忘冒号
# 冒号精确表示代码块的开始点
# - 这个功能不仅在条件执行体中如此,后面的循环体,方法体,类体全都遵循该规则
# - 如果程序遗忘了冒号,pyton解释器就无法识别代码块的开始点
s_age = input('请输入您的年龄:')
age = int(s_age)
if age > 20
print('年龄已经大于20岁了') # 缩进 4 个
print('20岁以上的人应该学会承担责任...')
if 条件的类型
if 条件可以是任意类型,当下面值作为 bool 表达式时,会被解释器当作 False 处理
- False(布尔值False)
- None (空数值)
- 0(数值0)
- ""(空字符串)
- ()(空元组)
- [](空列表)
- {}(空对象)
if 分支的错误处理
当使用 if else 语句进行流程控制时,一定不要忽略了 else 所带的隐含条件
使用 if else 语句时:
- 一定要先处理包含范围更小的情形
- 优先把包含范围小的条件放在前面处理
pass 语句(空语句)
# python 的 pass 语句就是空语句
# 有时候程序需要占个位,放一条语句,但又不希望这条语句做任何事情,此时就可通过pass语句来实现
# 使用 pass 语句,可以让程序更完整
s_age = input('请输入您的年龄:')
age = int(s_age)
if age > 20:
print('年龄已经大于20岁了') # 缩进 4 个
print('20岁以上的人应该学会承担责任...')
elif age < 5:
pass # 占位,不做任何事情
else:
pass # 占位,不做任何事情
循环结构
循环语句可能包含如下 4 个部分
- 初始化语句(init_statement):一条或多条语句,用于完成一些初始化工作。(初始化语句在循环开始之前执行)
- 循环条件(test_statement):这是一个布尔值表达式,这个表达式能决定是否执行循环体
- 循环体(body_statement):这个部分是循环的主体,如果循环条件允许,这个代码块将被重复执行
- 迭代语句(iteration_statements): 这个部分在依次循环体结束后,对循环条件求值之前执行,通常用于控制循环条件中的变量,使得循环在合适的时候结束
这 4 个部分只是一般分类,并不是每个循环中都非常清晰地分出这 4 个部分
while 循环
while 循环的语法格式:
[init_statement]
while test_experssion :
body_statement
[iteration_statement]
while 循环也可被当成分支语句使用
如果 test_expression 条件一开始就为假,则循环体部分将永远不会获得执行机会
count_i = 0 # 循环的初始化条件
while count_i < 10: # 当 count_i 小于 10 时,执行循环体
print('count_i: ', count_i) # 循环体
count_i += 1 # 迭代语句
print('循环结束')
while 循环遍历列表和元组
# 由于列表和元组的元素都是有索引的
# 程序可通过 while 循环,列表或元组的索引来遍历列表和元组中的所有元素
a_tuple = ('a', 'b', 'c', 'd')
i = 0 # 只有 i 小于 len(a_tuple) 继续执行循环体
while i < len(a_tuple):
print(a_tuple[i]) # 根据 i 来访问元素索引
i += 1 # 迭代语句
# while 循环也可以用于遍历列表
for in 循环
for-in 循环专门用于遍历范围,列表,元素和字典等可迭代对象包含的元素
语法格式:
for 变量 in 字符串|范围|集合等:
statements
- for-in 循环中变量的值受 for-in 循环控制,该变量将会在每次循环开始时自动被赋值,因此程序不应该在循环中对该变量赋值
- for-in 循环可用于遍历任何可迭代对象(指该对象中包含一个__iter__方法,且该方法的返回值对象具有 next() 方法)
# for-in 循环可用于遍历范围
s_max = input("请输入您想计算的阶乘: ")
mx = int(s_max)
result = 1
for num in range(1, mx + 1):
result *= num
print(result)
# for-in 循环的循环计数器赋值在语法上是允许的,但没有什么意义,而且非常容易导致错误
for i in range(1, 5):
i = 20
print('i: ', i)
for in 循环遍历列表和元组
# 在使用 for-in 循环遍历列表和元组
# 列表或元组有几个元素,for-in循环的循环体就执行几次
# 针对每个元素执行依次,循环计数器会依次被赋值为元素的值
a_tuple = ('a', 'b', 'c', 'd')
for ele in a_tuple:
print('当前元素是: ', ele)
for in 循环遍历字典
字典包含如下三个方法
- items(): 返回字典所有 key-value 对
- keys(): 返回字典所有 key
- values(): 返回字典所有 value
my_dict = {'语文': 89, '数学': 92, '英语': 80}
# items返回的是字典中所有 key-value 组成的列表
# 列表元素都是的长度为 2 的元组
# 程序要声明两个变量来分别代表 key, value(也是序列解包的应用)
for key,value in my_dict.items():
print(key, value)
print('=' * 90)
for key in my_dict.keys():
print(key, my_dict[key])
print('=' * 90)
for value in my_dict.values():
print(value)
循环使用 else
python 的循环都可以定义 else 代码块
当循环条件为 False 时,程序会执行 else 代码块
count_i = 0
while count_i < 5:
print('count_i 小于5: ', count_i)
count_i += 1
else: # 在循环结束之前,会先执行 else 代码块
# else 代码块其实没有太大的价值(将 else 代码块的内容直接放在循环体之外即可)
print('count_i 大于或等于5: ', count_i)
# for 循环同样可以使用 else 代码块
# for 循环把区间,元组或列表的所有元素遍历一次之后
# for 循环会执行 else 代码块,
# 在 else 代码块中,循环计数器的值依然等于最后一个元素的值
a_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for ele in a_list:
print('元素:', ele)
else: # 访问循环计数器的值,依然等于最后一个元素的值
print('else块:', ele)
嵌套循环
把一个循环放在另一个循环体内,就可以形成嵌套循环
- 嵌套循环既可以是 for-in 循环,嵌套 while 循环
- 也可以是 while 循环嵌套 do while循环···
- 各种类型的循环都可以作为外层循环,各种类型的循环也都可以作为内层循环
当程序遇到嵌套循环时,如果外层循环的循环条件允许
则开始执行外层循环的循环体,而内层的循环体将被外层循环的循环体来执行
- 只是内层循环需要反复执行自己的循环体而已
- 当内层循环执行结束且外层循环的循环体也执行结束后,将再次计算外层循环的循环条件,决定是否再次开始执行外层循环的循环体
for i in range(0, 5): # 外层循环
j = 0
while j < 3: # 内层循环
print('i的值为 %d , j 的值为: %d' % (i, j))
j += 1
for 表达式
for 表达式用于利用其他区间,元组,列表等可迭代对象创建新的列表
语法格式:
[表达式 for 循环计数器 in 可迭代对象]
- 在 for 关键字之前定义一个表达式,该表达式通常会包含循环计数器
- for 表达式没有循环体,因此不需要冒号
a_range = range(10)
a_list = [x * x for x in a_range] # 对 a_range 执行 for 表达式
print(a_list) # a_list 包含 10 个元素
b_list = [x * x for x in a_range if x % 2 == 0]
print(b_list)
# 将 for 表达式的方括号改为圆括号
# for表达式将不再生成列表,而是生成一个生成器(generator),该生成器同样可以使用 for 循环迭代
# 这种 for 表达式也被成为生成器推导式
c_generator = (x * x for x in a_range if x % 2 == 0)
# 使用 for 循环迭代生成器
for i in c_generator:
print(i, end='\t')
# for 表达式可使用多个循环,就像嵌套循环一样
d_list = [(x, y) for x in range(5) for y in range(4)] # d_list 列表包含 20 个元素
print(d_list)
常用工具函数
zip()
使用 zip() 函数可以把两个列表 "压缩" 成一个 zip 对象(可迭代对象)
- 就可以使用一个循环进行变脸两个列表
# 如果使用 zip() 函数压缩 n 个列表,
# zip() 函数返回的可迭代对象的元素就是长度为 N 的元组
a = ['a', 'b', 'c']
b = [1, 2, 3]
print([x for x in zip(a, b)])
# [('a', 1), ('b', 2), ('c', 3)]
reversed() / sorted()
a = [20, 30, -1.2, 3.5, 90, 3.6]
# 有些时候,程序需要反向遍历,可通过 reversed() 函数
# reversed() 函数可接收各种序列(元组,列表,区间等)参数
# - 返回一个"反序排列"的迭代器
# - 该函数对参数本身不会产生任何影响
print([x for x in reversed(a)])
# sorted 可对可迭代对象按照由小到大的顺序进行遍历
print(sorted(a))
控制循环结构
break 结束循环
有些时候,需要在某种条件出现时强制终止循环,而不是等到循环条件为 False 时才退出循环
可以使用 break 来完成这个功能
break 用于完全结束一个循环,跳出循环体
for i in range(0, 10):
print('i的值是: ', i)
if i == 2:
break # 执行该语句时将结束整个循环
# 对于带 else 块的 for 循环,如果使用 break 强制终止循环,程序将不会执行 else 块
for i in range(0, 10):
print('i的值是: ', i)
if i == 2:
break # 执行该语句时将结束整个循环
else:
print('else: ', i)
# python 的 break 只可以结束其所在的循环,不可以结束嵌套循环的外层循环
exit_flag = False
for i in range(0, 5):
for j in range(0, 3):
print('i的值为:', i, ' j的值为:', j)
if j == 1:
exit_flag = True
break # 跳出内层循环
if exit_flag:
break # 跳出外层循环
continue 跳过本次循环后的代码
···
continue 的功能和 break 有点类似,
区别是 continue 只是忽略当次循环剩下的语句,接着开始下一次循环
break 是完全终止循环本身
···
for i in range(0, 10):
print('i的值是: ', i)
if i == 1:
continue # 执行该语句时将结束整个循环
print('continue后输出的语句: ')