关于python:Python从入门到精通十Python流程控制的关键字该怎么用呢收藏下来常看常新

您好，我是码农飞哥，感谢您浏览本文，欢送一键三连哦 。
这篇文章次要介绍 Python 中流程管制的关键字的应用，波及到 if else,for,while 等关键字
干货满满，倡议珍藏，须要用到时常看看。小伙伴们如有问题及须要，欢送踊跃留言哦~ ~ ~。

前言

有句话说程序就是由流程 + 数据结构组成。任何程序都是如此。后面花了好几个篇幅来介绍 Python 中的各种数据结构，这一篇文章接着来介绍下流程管制。数据结构说白了就是用来存储数据的，而流程就是用来控制系统的运行的。

流程管制

流程管制有三种构造，一种是程序构造，一种是抉择（分支）构造，一种是循环构造。
程序构造：就是让程序依照从头到尾的程序执行代码，不反复执行任何一行代码，也不跳过任何一行代码。一步一个脚印示意的就是这个意思。
抉择（分支）构造：就是让程序依据不同的条件执行不同的代码，比方：依据年龄判断某个人是否是成年人。
循环构造: 就是让程序循环执行某一段代码。程序的流程这里不做介绍了。

抉择构造（if,else）:

if 语句

只应用 if 语句是 Python 中最简略的模式。如果满足条件则执行表达式。则跳过表达式的执行。其伪代码是：

if 条件为真:
   代码块

如果 if 前面的条件为真则执行代码块。否则则跳过代码的执行。
其流程图是：

就是说只应用 if 的话，则表达式成立的话执行代码块，不成立的话就完结。
上面就是一个简略的例子，如果满足 a == 1 这个条件则打印 a，否则跳过该语句。

a = 1
if a == 1:
    print(a)

if else 语句

if else 语句是 if 的变体，如果满足条件的话则执行代码块 1，否则则执行代码块 2。其伪代码是：

if 条件为真:
   代码块 1
else 
   代码块 2 

流程图是：

同时应用 if 和 else 的话，则表达式成立的话执行一个代码块，表达式不成立的话则执行另一个代码块。
举个简略的例子吧。

age = 3
if age >= 18:
    print('your age is', age)
    print('adult')
else:
    print("your age is", age)
    print('kid')

依据输出的年龄判断某人是否是成年人。如果 age 大于等于 18 岁，则输入 adult, 否则输入 kid。

if elif else 语句

if elif else 语句针对的就是 多个条件判断 的状况，如果 if 条件不满足则执行 elif 的条件，如果 elif 的条件也不满足的话，则执行 else 外面的表达式。其伪代码是：

if 条件为真:
   表达式 a
elif 条件为真:
   表达式 b
....
elif 条件为真:
   表白是 n -1
else 
   表达式 n 

其中 elif 能够有多个，然而 elif 不能独自应用，必须搭配 if 和 else 一起应用。
须要留神的是 if,elif 和 else 前面的代码块肯定要缩进，而且缩进量要大于 if,elif 和 else 自身，倡议的缩进量是 4 个空格。同一代码中所有语句都要有雷同的缩进。仍然是举例说明：

bmi = 80.5 / (1.75 * 1.75)
if bmi < 18.5:
    print('过轻')
elif 18.5 <= bmi < 25:
    print('失常')
elif 25 <= bmi < 28:
    print('过重')
elif 28 <= bmi < 32:
    print('瘦削')
else:
    print('重大瘦削')
pass

上面就是依据 bmi 规范来判断一个人是过轻，失常还是瘦削。pass 是 Python 中的关键字，用来让解释器跳过此处，什么都不做。

嵌套语句的应用

嵌套语句就是在一个 if 或者 else 的代码块中还存在子判断。如下例所示：

num = 23
if num < 20:
    print('不形成饮酒行为')
else:
    if 20 <= num and num < 80:
        print('已达到酒驾的规范')
    else:
        print('曾经达到醉驾的规范')

循环的关键字

while 循环语句详解

while 是作为循环的一个关键字。其伪代码是：

while 条件表达式：代码块

肯定要保障循环条件有变成假的时候，否则这个循环将成为一个死循环，即该循环无奈完结。 其流程图是：

如果 while 中的表达式成立的话则执行循环体，否则的话则间接完结。
举个栗子：计算从 1~100 的求和，这就是一个经典的使用循环的场景

sum = 0
n = 1
while n <= 100:
    sum = sum + n
    n = n + 1
print('sum=', sum)

运行后果是sum= 5050，这个循环的完结条件是 n >100, 也就是说当 n >100 是会跳出循环。

range 函数

range 函数用于生成一系列的数字，其语法结构是：

range(start,end,step)

其各局部的语法解释是：
start 示意开始的数字（包含，能够不填写），
end 完结的数字（不包含，必须填写），
step 步长（能够不填写），默认是 1
计算 1~100 的求和能够通过 range 函数来实现则是这样：

sum = 0
for x in range(101):
    sum = sum + x
print(sum)
print(range(101))

运行后果是：

5050
range(0, 101)

能够看出 range()函数失去的是一个 range 对象，必须通过 for 循环解析输入其内容。range(101)理论运行的后果是 range(0,101)，默认 start 等于 0，会输入 0~100 范畴内的所有数字，不包含数字 101。

for 循环

在介绍 range 函数时用到了 for 关键字，这里介绍一下 for 关键字的应用。其语法结构是:

for 迭代变量 in 字符串 | 列表 | 元组 | 字典 | 汇合：代码块

字符串，列表，元祖，字典，汇合都能够还用 for 来迭代。其流程图是：

for 循环就是：首先依据 in 关键字判断序列中是否有项，如果有的话则取下一项，接着执行循环体。如果没有的话则间接完结循环。

range 疾速生成推导式

列表推导式

列表推导式的语法格局是

[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]

此格局中，[if 条件表达式]不是必须的，能够应用，也能够省略。上面就是输入 1~10 的列表的乘积的一个例子：

L = [x * x for x in range(1, 11)]
print(L)

此表达式相当于

L = []
for x in range(1, 11):
    L.append(x * x)
print(L)

运行后果是：

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

来点简单的吧，上面就是输入

print([x for x in range(1, 11) if x % 2 == 0])

运行后果是 [2, 4, 6, 8, 10]
再来点简单的，应用多个循环，生成推导式。

d_list = [(x, y) for x in range(5) for y in range(4)]
print(d_list)

运行后果是：

[(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)]

下面代码，x 是遍历 range(5)的迭代变量（计数器），因而该 x 可迭代 5 次，y 是遍历 range(4)的计数器，因而该 y 可迭代 4 次。因而，该 (x,y) 表达式一共迭代了 20 次。它相当于上面这样一个嵌套表达式。

dd_list = []
for x in range(5):
    for y in range(4):
        dd_list.append((x, y))
print(dd_list)

元组推导式

元组推导式与列表推导式相似，其语法结构是：

(表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] )

此格局中，[if 条件表达式]不是必须的，能够应用，也能够省略。上面就是输入 1~10 的元组的乘积的一个例子：

d_tuple = (x * x for x in range(1, 11))
print(d_tuple)

运行后果是：

<generator object <genexpr> at 0x103322e08>

从下面的执行后果能够看出，应用元组推导式生成的后果并不是一个元组，而是一个生成器对象。
应用 tuple()函数，能够间接将生成器对象转换成元组。例如：

d_tuple = (x * x for x in range(1, 11))
print(tuple(d_tuple))

输入后果是(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

字典推导式

字典推导式的语法结构是：

{表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]}

其中 [if 条件表达式] 能够应用，也能够省略。举个例子：

key_list = ['姓名: 码农飞哥', '年龄:18', '喜好: 写博客']
test_dict = {key.split(':')[0]: key.split(':')[1] for key in key_list}
print(test_dict)

运行后果是：

{'喜好': '写博客', '年龄': '18', '姓名': '码农飞哥'}

嵌套循环

嵌套循环就是循环外面还有循环，最经典就是冒泡排序。冒泡排序每次比拟左右相邻的数字，如果后面的数字比前面的大则替换两个数字的地位。上面就演示一下：

test_list = [12, 3, 1, 13, 10, 5, 9]
for i in range(len(test_list)):
    for j in range(len(test_list) - i - 1):
        if test_list[j] > test_list[j + 1]:
            tmp = test_list[j]
            test_list[j] = test_list[j + 1]
            test_list[j + 1] = tmp
    print('第 {0} 循环后的后果是 ='.format(str(i)), test_list)
print('最终后果是 =', test_list)

运行后果是：

第 0 循环后的后果是 = [3, 1, 12, 10, 5, 9, 13]
第 1 循环后的后果是 = [1, 3, 10, 5, 9, 12, 13]
第 2 循环后的后果是 = [1, 3, 5, 9, 10, 12, 13]
第 3 循环后的后果是 = [1, 3, 5, 9, 10, 12, 13]
第 4 循环后的后果是 = [1, 3, 5, 9, 10, 12, 13]
第 5 循环后的后果是 = [1, 3, 5, 9, 10, 12, 13]
第 6 循环后的后果是 = [1, 3, 5, 9, 10, 12, 13]
最终后果是 = [1, 3, 5, 9, 10, 12, 13]

冒泡排序过程介绍：
从下面能够看出，外层循环负责冒泡排序进行的次数，而内层循环负责将列表中相邻的两个元素进行比拟，并调整程序，行将较小的放在后面。

跳出循环

跳出循环的关键字有两个，一个是 continue 语句，一个是 break。

1. 其中 continue 语句用于跳出执行本次循环体中残余的代码，转而执行下一次循环。

n = 0
while n <= 5:
    n = n + 1
    if n == 3:
        continue
    print(n)

运行的后果是：

1
2
4
5
6

能够看到数字 3 被跳过了。

2. break 语句用于齐全终止以后循环，须要留神的是如果是嵌套循环的话，只能中断应用 break 的循环。还是拿后面的冒泡排序来举个例子吧！

for i in range(len(test_list)):
    for j in range(len(test_list) - i - 1):
        if test_list[j] > test_list[j + 1]:
            test_list[j], test_list[j + 1] = test_list[j + 1], test_list[j]
        if j == 2:
            print('内层循环 break')
            break
    if i == 3:
        print('外层循环 break')
        break

运行后果是：

内层循环 break
内层循环 break
内层循环 break
内层循环 break
外层循环 break

能够看出内层循环的 break 不影响外层循环。也就是说 break 只会跳出以后的循环。

总结

本文简略介绍了 Python 中流程管制的几个关键字，抉择构造的话就是：if，elif，else 三个关键字。循环构造的话就是 while 和 for 两个关键字。语法比较简单。

我是码农飞哥，再次感谢您读完本文 。
全网同名【码农飞哥】。不积跬步，无以至千里，享受分享的高兴
我是码农飞哥，再次感谢您读完本文。