程序流程控制（一）

python是通过一些程序结构来控制程序的执行顺序和流程的。

一、程序结构

计算机程序是一条条按顺序执行的指令。顺序结构是计算机程序的基础，但单一的程序结构不能解决所有问题。计算机程序由三种基本结构组成：

• 顺序结构

• 分支结构

• 循环结构

  1.顺序结构

  顺序结构是程序执行的基本流程，它会按照代码从上往下的顺序依次执行

a = 1
a += 1
print(a)
2

从上往下依次执行

分支结构

分支结构是程序根据条件判断结构而选择不同代码向前执行的一种方式，也叫条件分支。

分支结构包括： 1、 单分支 2、 二分支 3、 多分支

2.1 单分支

在python中单分支结构通过if语句来实现，语法如下：

if <条件>:
    语句块

• 注意条件语句结束后要紧跟冒号
• 语句块是if条件满足后执行的一条或多条语句序列
• 语句块中语句通过缩进与if语句所在行形成包含关系
• 缩进安装规范为4个空格 if语句会首先计算<条件>表达式，如果结构为True则会执行包含的语句块，结果为False则会跳过所包含的语句块。

if语句中的语句块是执行与否依赖于条件判断。但无论什么情况，控制都会转到与if语句同级别的下一条语句。

案例：成绩是否及格
60分及以上为及格，及格奖励一个么么哒 60分一下为不及格，不接个赏一个大耳吧

input函数
input函数用来接收用户输入的文本信息，然后以字符串的形式返回，它接收字符串参数作为提示信息输出。

score = input('请输入你的成绩：')   # 接受用户输入的成绩
score = float(score)    # input函数返回的是字符串str，所以要转换成浮点数
if score < 60:      # 判断成绩是否及格
    print('赏一个大耳吧')
请输入你的成绩： 50
赏一个大耳吧

score = input('请输入你的成绩：')   # 接受用户输入的成绩
score = float(score)
if score >= 60:      # 判断成绩是否及格
    print('奖励一个么么哒')
请输入你的成绩： 80
奖励一个么么哒

2.2 二分支

python中二分支结构通过if-else语句来实现的，语法格式如下

if <条件>:
    <语句块1>
else:
    <语句块2>

• 语句块1-是在if条件满足后执行的一个或多个语句序列
• 语句块2-是在if条件不满足后执行的语句序列
• 注意缩进，<语句2>通过缩进与else所在行形成包含关系 二分支语句用于区分<条件>的两种可能True或者False，分别执行路径

案例：成绩是否及格（2） 通过二分支改进案例成绩是否及格

score = input('请输入你的成绩：')   
score = float(score)  
if score < 60:      # 判断成绩是否不及格，不及格返回语句块1
    print('赏一个大耳吧')
else:               # 语句块1判断及格，直接返回else后的语句块。
    print('奖励一个么么哒')
请输入你的成绩： 80
奖励一个么么哒

三目运算 二分支结构还是一种更简洁的表达方式，语法格式如下：

<表达式> if <条件> else <表达式2>

下面的代码可以改写为：

score = input('请输入你的成绩：')  
score = float(score)    
print('赏一个大耳吧') if score < 60  else    print('奖励一个么么哒')   
请输入你的成绩： 50
赏一个大耳吧

2.3 多分支

python通过if=elif-else 表示多分支结构，语法如下：

if <条件1>:
    <代码块1>
elif<条件2>:
    <代码块2>
...
else:
    <代码块3>

多分支是二分支的扩展，用于多个判断条件多条执行路径的情况。python依次执行判断条件，寻找第一个结果为True的条件，执行该条件下的代码块，同时结束后跳过整个if-elif-else结构，执行后面的语句。如果没有任何条件成立，这执行else下的代码块，二else语句是可选的，也即是说可以没有else语句。
案例：成绩评价 请根据用户输入的成绩，按一下等级分区：

• <40:E
• 40-59:D
• 60-74:C
• 75-84:B
• 85-100:A

score = input('请输入你的成绩：')  
score = float(score)  
if score < 40:     
    print('成绩评价为：E')
elif score < 60 and score >= 40:     
    print('成绩评价为：D')
elif 60 <= score < 75:     
    print('成绩评价为：C')
elif 75 <= score < 85:     
    print('成绩评价为：B')
else:            
    print('成绩评价为：A')
请输入你的成绩： 80
成绩评价为：B

score = input('请输入你的成绩：')  # 另外一种写法
res = ''  
score = float(score)   
if score < 40:     
    res = 'E'
elif score < 60 and score >= 40:     
    res = 'D'
elif 60 <= score < 75:     
    res = 'C'
elif 75 <= score < 85:     
    res = 'B'
else:            
    res = 'A'
print('成绩评价为：{}'.format(res))
请输入你的成绩： 60
成绩评价为：C

if score >= 60:
    if score < 70:
        if  score < 90:
            pass
# 嵌套案例，一般嵌套不能超过三层，影响代码美观也不好进行差错

3. 循环结构

python中循环节后有两种：

1. 条件循环也叫while循环

2. 遍历循环也叫for循环

   3.1 条件循环

   python中的条件循环通过while循环语句来实现，所以也叫while循环，

   语法格式如下： ``` while<条件>: 代码块

```

• while关键字空格后条件表达式末尾加上冒号组成while语句

• 代码块中的代码通过4个空格和while语句形成包含关系

  while语句首先计算<条件>表达式，如果结构True，则执行对对应代码块中的语句，执行结束后再次指定<条件>

  表达式，再次判断结果，如果未True则循环执行，知道<条件>表达式为False时跳出循环，执行和while语句相同缩进的下一条语句。

当<条件>表达式恒为True时，形成无限循环，也叫死循环，需要小心使用

# 依次打印0-5
i = 0
while i < 6:    # 判断i小于10，执行下方代码块。直至i不小于10跳出。
    print(i)
    i = i + 1    # 需要将条件放打印下方，不然不会打印0
0
1
2
3
4
5

# 序列的循环
# 列表的元素循环
ls = ['s','f','y','u']
i = 0
# len计算列表ls长度，然后判断i是否小于计算的长度，小于执行代码块，不下于跳出
while i < len(ls):  
    print(ls[i])   # 打印列表ls中循环的i数值的索引
    i = i + 1
s
f
y
u

# 元祖的循环
ls = ('s',1,[1,2])
i = 0
while i < len(ls):  
    print(ls[i]) 
    i = i + 1
s
1
[1, 2]

# 集合的循环
# 集合没有顺序，没有索引，需要先转换成列表，然后才能循环
ls = {'s',1,(2,)}
ls = list(ls)
i = 0
while i < len(ls):  
    print(ls[i])
    i = i + 1
1
s
(2,)

# 字典也不可以直接通过这种方法循环
# 因为字典没有整数索引
# 可以先获取字典的keys，转化为列表，然后在迭代循环
ls = {'name': 'xiaolan',
      'age': 18,
      'sex': '男'
}
keys = list(ls.keys())    # ls.keys()函数提取出字典的key，然后在转化成list
i = 0
while i < len(keys):  
    print(keys[i],ls[keys[i]])  # 打印列表的key，然后在根据key获取ls字典的值。
    i = i + 1
name xiaolan
age 18
sex 男

3.2 遍历循环

python 中使用关键字for来实现遍历循环，也叫for循环，也叫迭代循环
语法如下：

for <循环变量> in <遍历结构>:
    代码块

• 关键字for + 空格 + <循环变量> + 关键字in + <遍历结构> + 冒号组成for语句
• 代码块通过缩进和for语句形成包含关系 for循环会依次取出遍历结构中的元素，然后赋值给循环变量，每次遍历都会执行代码块，直到取出遍历结构中的所有元素。

所有可迭代对象都可以作为遍历结构进行for循环。

基本数据类型中序列数据类型，散列数据类型都可以进行迭代。 数值类型（整数，浮点数，复数)不可进行迭代。

# for循环来遍历可迭代对象非常方便
# 对于序列来说，迭代按照顺序进行

# 列表
ls = list('assd')
for i in ls:      # i可以为任意变量
    print(i)
a
s
s
d

#字符串
ls = 'assd'
for i in ls:
    print(i)
a
s
s
d

# 元组
t = (1,2,'a')
for a in t:
    print(a)
1
2
a

# 集合
# 对于集合来说，迭代是没有顺序的
j = {1,5,'s'}
for a in j:
    print(a)
1
s
5

# 字典
# dict.values()函数，返货字典的值
ls = {'name': 'xiaolan',
      'age': 18,
      'sex': '男'
}
for a in ls:
    print(a)
name
age
sex

# dict.values()函数，返回字典的值
for a in ls.values():
    print(a)
xiaolan
18
男

# dict.itmes()函数，返回字典的键值对
# 如果想同时迭代出键和值
for a in ls.items():
    print(a)
('name', 'xiaolan')
('age', 18)
('sex', '男')