流程控制
- 顺序结构
- 掌握分支结构的功能和用法
- 分支结构容易出现的各种错误
- 使用 if 表达式
- 使用 pass 空语句
- 掌握断言的功能和用法
- 掌握 while 循环的语法
- 使用 while 循环遍历列表或元组
- 掌握 for in 循环的语法
- 使用 for in 循环遍历列表和元组
- 使用 for in 循环遍历字典
- 在循环中使用 else
- 掌握嵌套循环的用法
- 使用 for 表达式
- 与循环相关的工具函数
- 使用 break 结束循环
- 使用 continue 忽略本次循环的剩下语句
- 使用 return 结束方法
- 通过实例熟练使用流程控制
顺序结构 Sequence Structure 代码按照编写的顺序，自上而下逐行运行
if 分支结构
Python if 语句有如下3种形式
形式1：
if 表达式:
语句
形式2：
if 表达式:
语句
else：
语句
形式3：
if 表达式1：
语句块1
elif 表达式2：
语句块2
elif 表达式3:
语句块3
else:
语句块
- 条件表达式就是计算结果必须为布尔值的表达式
- 表达式后面的冒号不能少
- 注意if后面的出现的语句，如果属于if语句块，则必须同一个锁紧等级
- 条件表达式结果为True执行if后面的缩进的语句块
username=str(raw_input("请输入用户名:"))
password=str(raw_input("请输入密码:"))
if username !='' and password !='':
if username == "admin" and password=="12345" :
print ("身份认证成功")
else:
print ("身份认证失败")
else:
print("请输入用户名和密码")
pass 语句
pass 是空语句，是为了保持程序结构的完整性，pass 不做任何事情，一般用做占位语句
s = input('输入一个整数')
s = int(s)
if s > 5:
print('大于')
elif s < 5:
# 空语句，相当于占位符
pass
else:
print('等于')
断言
Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。
语法格式如下：
assert expression
等价于：
if not expression:
raise AssertionError
assert 后面也可以紧跟参数:
assert expression [, arguments]
等价于：
if not expression:
raise AssertionError(arguments)
例：
age= input('请输入您的年龄:')
age = int(age)
assert 20 < age < 80
print('您输入的年龄在20~80之间')
如果输入的年龄不在20～80之间，就会报错。
循环结构
- while 循环
while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。
while 判断条件(condition)：
执行语句(statements)……
执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。当判断条件假 false 时，循环结束
count = 0
while (count < 9):
print('The count is:', count)
count = count + 1
print("Good bye!")
# The count is: 0
# The count is: 1
# The count is: 2
# The count is: 3
# The count is: 4
# The count is: 5
# The count is: 6
# The count is: 7
# The count is: 8
# Good bye!
（1）使用 while 循环遍历列表和元组
由于列表和元组的元素都是有索引的，因此程序可通过 while 循环、列表或元组的索引来遍历列表和元组中的所有元素。
遍历元组
a_tuple = ('fkit', 'crazyit', 'Charli')
i = 0
# 只有i小于len(a_list)，继续执行循环体
while i < len(a_tuple):
print(a_tuple[i])
# 根据i来访问元组的元素
i += 1
# fkit
# crazyit
# Charli
遍历列表
src_list = [12, 45, 34,13, 100, 24, 56, 74, 109]
a_list = [] # 定义保存整除3的元素
b_list = [] # 定义保存除以3余1的元素
c_list = [] # 定义保存除以3余2的元素
# 只要src_list还有元素，继续执行循环体
while len(src_list) > 0:
# 弹出src_list最后一个元素
ele = src_list.pop()
# 如果ele % 2不等于0
if ele % 3 == 0 :
a_list.append(ele) # 添加元素
elif ele % 3 == 1:
b_list.append(ele) # 添加元素
else:
c_list.append(ele) # 添加元素
print("整除3:", a_list)
print("除以3余1:",b_list)
print("除以3余2:",c_list)
# 整除3: [24, 45, 12]
# 除以3余1: [109, 100, 13, 34]
# 除以3余2: [74, 56]
（2）for-in 循环
for-in 循环专用于遍历范围、列表、元素和字典等可迭代对象包含的元素
for 变量 in 字符串｜范围｜集合等:
statements(s)
对于上面的语法格式有两点说明
1.for-in 循环中的变量的值受 for-in 循环控制，该变量将会在每次循环开始时自动被赋值，因此程序不应该在循环中对该变量赋值
2.for-in 循环可用于遍历任何可选代对象，所谓可迭代对象，就是指该对象中包含iter方法，且该方法的返回值对象具有next方法
n = input("输入你要计算的阶乘：")
num = int(n)
result = 1
for i in range(1, num+1):
result *= i
print(result)
（3）使用 for-in 循环遍历列表和元组
遍历元组
a_tuple = ('a', 'b', 'c')
for i in a_tuple:
print('元素：', i)
# 元素： a
# 元素： b
# 元素： c
遍历列表
src_list = [1,22.5,3,45,'ab',78,2]
list_sum = 0
count = 0
for i in src_list:
if isinstance(i, int) or isinstance(i, float):
# 如果该元素是整数或浮点数
# print(i)
list_sum += i
count += 1
print('总和为:', list_sum)
print('平均值为:', list_sum / count)
# 总和为: 151.5
# 平均值为: 25.25
（4）使用 for-in 循环遍历字典
回忆一下字典的三个方法
items ： 返回字典中所有 key-value 对的列表。
keys ： 返回字典中所有 key 的列表
values ：返回字典中所有 value 的列表
my_dict = {'Math':80, 'EP':95, 'English':75}
for key, values in my_dict.items():
print('key:', key)
print('value:', values)
（5）循环使用 else
Python 的循环都可以定义 else 代码块，当循环条件为 False 时，程序会执行 else 代码块。
a_list = [330 , 1.4 , 50,'fkit', -3.5 ]
for ele in a_list:
print('元素 ：', ele)
else:
# 访问循环计数器的值 依然等子最后一个元素的值
print('else块：', ele)
# 元素 ： 330
# 元素 ： 1.4
# 元素 ： 50
# 元素 ： fkit
# 元素 ： -3.5
# else块： -3.5
（6）嵌套循环
将一个循环放在另一个循环体中，就形成了嵌套循环，其中for，while，do…while均可作为外层循环和内层循环
（7）for 表达式
for 表达式用于利用其他区间、元组、列表等可迭代对象创建新的列表
for 表达式与普通for 循环的区别有两点
1.在for 关键字之前定义一个表达式，该表达式通常会包含循环计数器
2.for 表达式没有循环体，因此不需要冒号
a_range = range(10)
# 对a_range执行for表达式
a_list = [x * x for x in a_range]
# a_list集合包含10个元素
print(a_list)
b_list = [x * x for x in a_range if x % 2 == 0]
# a_list集合包含5个元素
print(b_list)
# 使用for表达式创建生成器
c_generator = (x * x for x in a_range if x % 2 == 0)
# 使用for循环迭代生成器
for i in c_generator:
print(i, end='\t')
print()
d_list = [(x, y) for x in range(5) for y in range(4)]
# d_list列表包含20个元素
print(d_list)
dd_list = []
for x in range(5):
for y in range(4):
dd_list.append((x, y))
print(dd_list)
e_list = [[x, y, z] for x in range(5) for y in range(4) for z in range(6)]
# 3_list列表包含120个元素
print(e_list)
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)
输出结果
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 4, 16, 36, 64]
0 4 16 36 64
[(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)]
[(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)]
[[0, 0, 0], [0, 0, 1], [0, 0, 2], [0, 0, 3], [0, 0, 4], [0, 0, 5], [0, 1, 0], [0, 1, 1], [0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 1, 5], [0, 2, 0], [0, 2, 1], [0, 2, 2], [0, 2, 3], [0, 2, 4], [0, 2, 5], [0, 3, 0], [0, 3, 1], [0, 3, 2], [0, 3, 3], [0, 3, 4], [0, 3, 5], [1, 0, 0], [1, 0, 1], [1, 0, 2], [1, 0, 3], [1, 0, 4], [1, 0, 5], [1, 1, 0], [1, 1, 1], [1, 1, 2], [1, 1, 3], [1, 1, 4], [1, 1, 5], [1, 2, 0], [1, 2, 1], [1, 2, 2], [1, 2, 3], [1, 2, 4], [1, 2, 5], [1, 3, 0], [1, 3, 1], [1, 3, 2], [1, 3, 3], [1, 3, 4], [1, 3, 5], [2, 0, 0], [2, 0, 1], [2, 0, 2], [2, 0, 3], [2, 0, 4], [2, 0, 5], [2, 1, 0], [2, 1, 1], [2, 1, 2], [2, 1, 3], [2, 1, 4], [2, 1, 5], [2, 2, 0], [2, 2, 1], [2, 2, 2], [2, 2, 3], [2, 2, 4], [2, 2, 5], [2, 3, 0], [2, 3, 1], [2, 3, 2], [2, 3, 3], [2, 3, 4], [2, 3, 5], [3, 0, 0], [3, 0, 1], [3, 0, 2], [3, 0, 3], [3, 0, 4], [3, 0, 5], [3, 1, 0], [3, 1, 1], [3, 1, 2], [3, 1, 3], [3, 1, 4], [3, 1, 5], [3, 2, 0], [3, 2, 1], [3, 2, 2], [3, 2, 3], [3, 2, 4], [3, 2, 5], [3, 3, 0], [3, 3, 1], [3, 3, 2], [3, 3, 3], [3, 3, 4], [3, 3, 5], [4, 0, 0], [4, 0, 1], [4, 0, 2], [4, 0, 3], [4, 0, 4], [4, 0, 5], [4, 1, 0], [4, 1, 1], [4, 1, 2], [4, 1, 3], [4, 1, 4], [4, 1, 5], [4, 2, 0], [4, 2, 1], [4, 2, 2], [4, 2, 3], [4, 2, 4], [4, 2, 5], [4, 3, 0], [4, 3, 1], [4, 3, 2], [4, 3, 3], [4, 3, 4], [4, 3, 5]]
[(3, 30), (3, 12), (3, 66), (3, 39), (3, 78), (3, 36), (3, 57), (5, 30), (11, 66), (11, 121)]
for 表达式当然也是有循环的，它同样会对可迭代对象进行循环一一可迭代对象包含几个对象，该循环就对for 之前的“表达式”执行几次（相当于for 之前的表达式就是循环体），并将每次执行的值收集起来作为新的列表元素
for 表达式最终返回的是列表，因此for 表达式也被称为列表推导式
还可以在for 表达式后面添加if 条件，这样for 表达式将只迭代那些符合条件的元素
如果将for 表达式的方括号改为圆括号， for 表达式将不再生成列表，而是生成一个生成器(generator ），该生成器同样可使用for 循环选代。对于使用圆括号的for 表达式，它最终返回的是生成器，因此这种for 表达式也被称为生成器推导式
（8）常用工具函数
zip（）函数
把两个列表（或元祖，字符串也行）‘压缩’ 成一字zip对象（可迭代对象），使用循环可以并行的循环两个列表；
l1 = [1,2,3,4]
l2 = [1,2,3,4]
r = [i for i in zip(l1,l2)]
print(r)
# [(1, 1), (2, 2), (3, 3), (4, 4)]
返回的是一个列表，里边是由原列表元素组成的元祖
注意：列表元素数量不一样，zip（）函数将以长度短的列表为准
l1 = [1,2,3,4]
l2 = [1,2,3]
r = [i for i in zip(l1,l2)]
print(r) # [(1, 1), (2, 2), (3, 3)]
reversed（）函数
反向遍历，可接受列表、元祖、字符串（set集合和字典不行，否则报错）等参数。
s = (1,2,3,)
r = [i for i in reversed(s)]
print(r)
# [3, 2, 1]
sorted（）函数
对列表、元祖、字符串进行反向排序
s = (1,2,3)
r = sorted(s)
r1 = sorted(s,reverse=True)
print(r) # [1, 2, 3]
print(r1) # [3, 2, 1]
- 控制循环结构
break
break可以用来终止当前的循环语句，即使循环没结束，执行了break语句这个循环就终止了，直接跳出整个循环
def func2():
for i in range(1,11):
if i % 2 == 0:
break
#到第一个符合条件的情况下就停止。不输出符合条件的语句，并停止。
print(i)
func2()
# 输出结果：1
continue
continue语句是用来告诉程序跳出本次循环，然后执行下一轮循环，不同与break，break是跳出整个循环，continue是结束这一次循环，继续下一次循环
def func():
for i in range(1,11):
if i % 2 == 0:
continue
#if判断后，跳过continue语句下的表达式。不输出print(i)
print(i)
func()
# 输出结果：1 3 5 7 9
pass
pass语句实际上什么都不做，它只是在语法上需要一条语句但程序不需要进行任何操作时才使用
def func1():
for i in range(1,11):
if i % 2 == 0:
pass
#pass不做任何操作
print(i)
func1()
# 1输出结果： 2 3 4 5 6 7 8 9 10
return
return语句用于从包围它的最直接方法，函数或匿名函数返回。本次只说使用return结束方法，其他return不在这次中过多说明
def test():
# 外层循环
for i in range(10):
for j in range(10):
print('i的值是：%d,j的值是：%d'%(i, j))
if i == j:
return
print('return后的输出语句')
test()
# i的值是：0,j的值是：0
从这个运行结果来看，虽然 return 并不是专门用于控制循环结构的关键字 ，但通 return 语句确实可结束一个循环
网友评论