Python 流程控制-分支与循环_python控制结构之分支结构与循环结构头哥作业

1. 流程控制概述

流程就是程序在运行时的顺序，我们要想改变它的顺序，就需要用到流程控制了。简单的说就是控制代码的执行顺序。

顺序结构

python 的流程结构主要有三种，顺序、分支、循环。

顺序结构较为简单，就是从上到下的运行代码，我们所编写的代码都是这样的流程
1

分支结构

我们要想计算机有人一样的思想，就必须要有对条件的判断功能，对根据条件做出不同的流程的称之为分支结构

if - elif - else

分支结构中用到的语句是 if-elif-else （其中elif可以为多个）
if 也就是 ‘如果’ , 当 if 后的条件满足时执行下面的子代码
符合条件返回 True , 不满足返回 False
1
2
3

if 的标准语法为					# 代码的缩进方式写在后面

		if condition_1:			# condition_1为条件一
		    statement_block_1   # 条件一满足后执行的子代码
		elif condition_2:	    # condition_2为条件二
		    statement_block_2   # 条件一不满足且条件二满足时执行
		else:
		    statement_block_3	# 以上条件都不满足时执行的代码
1
2
3
4
5
6
7
8

if 的流程图

if 的嵌套

嵌套的意思就是把一个 if-elif-else 结构放在另外一个if-elif-else 结构。

if 嵌套语法:

		if 条件A:			
		    语句1
		    
		    if 条件B:		# 条件A满足后判断条件B
		        语句2
		    elif 条件C:		# 满足条件A但不满足条件B时，判断条件C
		        语句3
		    else:			#满足条件A但是条件B，C都不满足时
		        语句4
		        
		elif 条件D:			#条件A不满足时，判断条件D
		    语句5
		else:				#条件A，D都不满足时，执行语句 6 。
		    语句6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

代码示例:

x = 10			    # 定义一个变量存放数据
if x % 2 == 0:		# 判断 x 能否被 2 整除 
    
    if x % 5 == 0:		 # 满足了能被 2 整除后，判断是否能被 5 整除
        print(str(x) + ' 既能被 2 整除，也能被 5 整除')
    else:
        print(str(x) + ' 能被 2 整除，但不能被 5 整除')
        
elif x % 3 == 0:	# 不能被 2 整除后，判断是否能被 3 整除
    print(str(x) + ' 能被 3 整除，但不能被 2 整除')	
else:				# 所有条件都不满足
    print('不能被 2 和 3 整除')


首先先判断 x 能否被 2 整除，若返回True,执行下面嵌套的if语句。
    嵌套的if语句返回True，输出语句 ‘既能被 2 整除，也能被 5 整除’ 
    嵌套的if语句返回False，输出语句‘能被 2 整除，但不能被 5 整除’
若 x 不能被 2 整除，返回False，执行 elif 的条件判断语句。
若 elif 的条件判断返回False，执行 else 的语句。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

if 的简写：

简写的语法:
		True的逻辑 if 条件 else False的逻辑
		
说白点就是 if 前面跟着条件满足后需要执行的代码，else后面跟着条件不满足
时执行的代码。


简写前:
				x = 7
				if x % 2 == 0:
				    print('为True')
				else:
				    print('为False')

简写后
		x = 7
		print('为True') if x % 2 == 0 else print('为False')


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

循环结构

循环，看这词也就能知道，这个结构能一直重复运行。

在 python 中循环语句主要有 for 和 while 俩种。

while循环：

while循环的语法:

		while 判断条件(condition)：
	        循环体代码
		    
1. 首先判断条件是否满足，满足返回 True，并执行循环体代码，False则退出
2. 当循环体代码完成一轮循环后，会重新判断条件是否还满足，若满足则继续执
行循环体代码。
3. 若条件一直为 True 的话，代码会一直循环，也就是死循环了。	    
1
2
3
4
5
6
7
8
9

while循环流程示意：

while和else的结合使用：

while 后面可以加 else 语句

		while 判断条件:
		    循环体代码
		else:
		    语句


解释: 当 while 判断条件为 True 时，执行循环体代码，当条件为 False 时
，也就是退出循环时，执行 else 语句代码。

注意的是人为退出循环时不会执行 else 的代码。（break）

1
2
3
4
5
6
7
8
9
10
11
12
13

while 和 else 结合使用示例:

	x = 9
	while x > 0:
	    if x == 1:
	        print(str(x) + '和1一样大')
	        x -= 1
	        continue
	    print(str(x) + '比1大')
	    x -= 1
	else:
	    print(str(x) + '比1小')

当 x 等于1时，执行代码让 x 减 1 变成 0，使其不满足 while 条件退出循环
，退出循环时要执行 else 的代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

while死循环：
死循环，也就是不能退出的循环。

要想循环一直执行，我们必须要让 while 的条件一直为 True 。
什么情况下 while 能一直为 True 呢？

1. 直接用 True 作为 while 的条件

			while True:
		    	print('你好')

2. 用大于 0 的数字作为条件

			while 1:
		    	print('你好')

3. 用带有元素的数据集作为条件，例如列表、字典、字符串等等。

			list_a = ['1', '2']
			while list_a:
			    print('你好')
			    
	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

python如何中代表False以及True：

这里提上一点，在 python 中以下内容代表的是 False 。

	数字  0  为False，其他所有数值皆为True
	空 字符串 为False，其他所有字符串皆为True
	空 list  为False，其他所有list皆为True
	空 tuple 为False，其他所有tuple皆为True
	空 dict  为False，其他所有dcit皆为True
	
1
2
3
4
5
6
7
8

while循环的一些实例:

打印1-10的数字:
				count = 0
				while count <= 10:
				    print(count)
				    count += 1

打印1-10的偶数:
				count = 0
				while count <= 10:
				    if count % 2 == 0:
				        print('loop', count)
				    count += 1

计算1-100的和:
				sum = 0
				x = 0
				while x <= 100:
				    sum = sum + x
				    x += 1
				print(sum)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

while嵌套：

while 循环也有嵌套。
打印乘法表:


	x = 1
	while x < 10:
	    y = 1
	    while y <= x:
	        print(x, '*', y, '=', (y * x), '\t', end='')
	        y += 1
	    print('')
	    x += 1


1
2
3
4
5
6
7
8
9
10
11
12
13
14

for循环：
在 Python 中，for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。

for 循环的语法:
				
				for <variable> in <sequence>:
				    <statements>
				else:
				    <statements>
				    
1. in 字面意思，从某个集合（列表等）里顺次取值
2. 其中 <sequence> 代表着迭代的对象， <statements> 代表着循环体，
variable 称为迭代变量。
3. 迭代变量用于存放从序列类型变量中读取出来的元素，所以一般不会在循环中
对迭代变量手动赋值
4. for 循环每一次循环都会把元素赋值给迭代变量，直到没有元素可以取。




''' while 循环也可以取出列表中的元素。'''

				list_a = [2.3, 445, 52, 2, 32, 4, 4]
				i = 0
				while i < len(list_a):
				    print(list_a[i])
				    i += 1

但是更加复杂，建议使用 for 循环。


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

for 循环的流程图

for循环嵌套

打印乘法表

		for i in range(1, 10):
		    for j in range(1, i + 1):
		        print(j, '*', i, '=', (j * i), end='\t')
		    print()

1
2
3
4
5
6
7

for循环简写

1. 单个 for 语句缩写

简写语法:
				[ 对i的操作 for i in 列表 ]

相当于:

				for i in 列表:
				    对i的操作
				    
1
2
3
4
5
6
7
8

举例:
				[print(i) for i in range(5)]

等价于:
				for i in range(5):
				    print(i)
				    
1
2
3
4
5
6
7

多个 for 语句缩写

简写语法:
       [对x的操作 for 单个元素 in 列表 for x in 单个元素]

举例:
		list_a = ['XWenXiang', '666']
		[print(x) for y in list_a for x in y]

等价于:
		list_a = ['XWenXiang', '666']
		for y in list_a:
		    for x in y:
		        print(x)
		        
1
2
3
4
5
6
7
8
9
10
11
12
13

可迭代对象：

字符串，列表，元祖，字典，集合， 文件等等，都是可迭代对象。
注意: int 类型不能迭代。

1. 字符串迭代

		str_a = 'XWenXiang'
		for i in str_a:
		    print(i)
1
2
3

2. 列表迭代

		list_a = ['X', 8, [6, 's']]
		for i in list_a:
		    print(i)
1
2
3

3. 元组迭代

		tup_a = ('X', 8, [6, 's'])
		for i in tup_a:
		    print(i)
1
2
3

4. 字典迭代

		dict_a = {'X': 6, 'W': 6, 'x': 6}
		for key, value in dict_a.items():
    		print(key, value)
1
2
3

5. 集合迭代

字典和集合是无序的，所以取出的元素是随机的

		set_a = {'X', 6}
		for i in set_a:
    		print(i)
1
2
3
4
5

6. 文件迭代

		fil=open("data.txt")
		for r in fil:
			print(r)
1
2
3

break 和 continue:

while 循环执行 break 和 continue 的流程图，图片引自菜鸟教程

for 循环执行 break 和 continue 的流程图，图片引自菜鸟教程

break
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

在while 循环中使用 break 实例:

			while True:
			    print('6')
			    break

break 是跳出循环，接下来运行循环外的代码

上述函数如果没有 break 的话那么它是一个死循环。加上break时，只会运行一
次循环体代码，然后结束循环。
1
2
3
4
5
6
7
8
9
10

在 for 循环中使用 break 实例:

			for i in range(8):
			    if i == 2:
			        break
			    print(i)


在上述代码中，如果没有 break ，程序会遍历出 0-7 的数字，但是加了 if 语
句后当数字等于 2 时，就会跳出循环
1
2
3
4
5
6
7
8
9
10

continue

continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

在while 循环中使用 continue 实例:

			while True:
			    print('6')
			    continue

上述函数即使加了 continue 但是它是死循环，而 continue 只能跳过本次循
环进行下一次循环，所以并没有结束死循环。



				i = 0
				while i <= 8:
				    i += 1
				    if i == 4:
				        continue
				    print(i)




如果是上述代码，if 判断当 i 等于 4 的时候，跳过本次循环，进入下一个循环
也就是说，i 等于 4 的时候并不会被输出，也就跳过了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在 for 循环中使用 continue 实例:

			for i in range(8):
    			if i == 2:
        			continue
    			print(i)


在上述代码中，如果没有 continue ，程序会遍历出 0-7 的数字，但是加了 
if 语句后当数字等于 2 时，就会跳过 2 这个数字，然后继续执行下一次循环，
同样的代码，使用 continue 和 break 就完全不同。
1
2
3
4
5
6
7
8
9
10
11

range关键字：

在python2.x 中 range() 函数可创建一个整数列表

而在 Python3 range() 返回的是一个可迭代对象（类型是对象），而不是列>表类型， 所以打印的时候不会打印列表

函数的语法
				range(start, stop[, step])

				start: 开始的位置。默认是从 0 开始。
				stop: 结束的位置，但不包括 stop 。
				step：步长，默认为1。
				
1
2
3
4
5
6
7

函数示例:
1. 在 python3 中打印:

			number = range(1, 10, 1)
			print(number)

得到的结果是 range(1, 10)

2. 在 python2 中打印

            number = range(1, 10, 1)
			print(number)
			
得到的结果是 [1, 2, 3, 4, 5, 6, 7, 8, 9]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

我们可以改变它的起始位置，结束位置，以及它的步长。

1. 步长
步长就是元素之间的间隔，我们可以改变上面代码的步长看下效果

			我们把它改成 range(1, 10, 2)
			
得到的结果是[1, 3, 5, 7, 9] 很明显看到它们之间相差了 2 也就是等差数列

2. 起始位置
起始位置就是从哪个数字开始

3.结束位置
结束位置需要注意的是，在数字集中不包含结束位置，也就是包首不包尾。
1
2
3
4
5
6
7
8
9
10
11
12
13
14

1. 我们可以对range进行切片处理:

			s = range(1, 10, 1)
			print(s)
			print(s[1:5])
			
得到的结果是:			
			[1, 2, 3, 4, 5, 6, 7, 8, 9]
			[2, 3, 4, 5]



2. 我们又可能只需要数字集后面几位而数据集又很大时，我们可以通过切片从后
面开始切:
			print(s[-5:-1])
			
'''需要注意的是切片处理默认以左往右切，也就是在坐标系中，从小到大切'''

得到的结果是: [5, 6, 7, 8]


3. 当然我们可以改变切片的顺序

			print(s[-1:-5:-1])

这样子的结果是 [9, 8, 7, 6] ，-1 改变了切片的顺序，从坐标系右向左了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

缩进：
python是通过缩进来判断代码从属关系的，子代码要与父代码相差 4 个空格，也就是一个 Tab 键的距离。

			if True:
			    print ("A")
			    print ("B")
			else:
			    print ("C")
			  print("D")
			
如上述代码，缩进格式不对，程序会报错。
1
2
3
4
5
6
7
8
9