Python流程控制

1.if

if是条件控制语句，其语法定义如下：

if_stmt ::= "if" expression ":" suite
			( "elif" expression ":" suite )*
			["else" ":" suite]

if是固定格式，当if后面的expression为真时，执行其后面的suite，然后可以在后面接0或者任意多个elif语句，最后一条else语句可选。

>>> x = 8
>>> if x < 0:
...     print('negative')
... elif x == 0:
...     print('zero')
... else:
...     print('positive')
...
positive

Python中没有像C语言的switch … case这样的结构，因为使用elif就能达到一样的效果。

1.1真值计算

对于if语句后面的表达式expression的计算结果，除了以下几种情况为假之外，其它情况均为真：

• None
• False
• 数据类型零：0、0.0、0j
• 空序列：‘’、()、[]
• 空字典：{}
• 如果是用户自定义类，然后实现了__bool__或__len__方法，并且返回结果为False或0，那么也被当做假

# None
>>> if None:
...     print('should not print')
... else:
...     print('should print')
...
should print

# 整数0
>>> if 0:
...     print('should not print')
... else:
...     print('should print')
...
should print

# 空字符串
>>> if '':
...     print('should not print')
... else:
...     print('should print')
...
should print

# 空字典
>>> if {}:
...     print('should not print')
... else:
...     print('should print')
...
should print

1.2布尔运算符

有时在if后面的expression中会是一个由布尔运算符连接多个部分所组成的表达式，比如：

>>> p = '/home/user1/'
>>> if p.startswith('/') and p.endswith('/'):
...     print('The absolute path of a directory')
...
The absolute path of a directory

对于包含布尔运算符的表达式的真假值判断遵循以下规范：

操作符	结果
x or y	如果x为假，则结果为y，否则为x
x and y	如果x为假，则结果为x，否则为y
not x	如果x为假，则结果为True，否则为False

• or是一个短路运算符，只有当x为假时才会计算y
• and也是一个短路运算符，只有当x为真时才会计算y
• 这3个布尔运算符的优先级关系为：not > and > or

>>> 1 or 2
1
>>> 0 or 2
2
>>> 1 and 2
2
>>> 0 and 2
0

1.3比较运算符

比较运算符也常用于if后面的expression表达式，比较运算符总是返回bool类型的结果，即True或False，所有比较运算符如下：

运算符	说明
<	小于
<=	小于等于
>	大于
>=	大于等于
==	等于
!=	不等于
is	判断是否是某个对象
is not	判断是否不是某个对象

2.for

for语句的定义如下：

for_stmt ::= "for" target_list "in" expression_list ":" suite
			["else" ":" suite]

Python中的for循环只有for … in的形式，它遍历序列expression_list，每次遍历取出的元素赋值给target_list，第一个suite是循环体，然后还可以使用一个else子句，else只有在for循环正常结束之后才会执行，如果在for循环中被break打断了，则会跳过else子句。

# 遍历一个list
>>> for c in ['a','b','c']:
...     print(c)
...
a
b
c

# 如果想要类似C语言中的for循环，可以使用range
>>> for i in range(5):
...     print(i)
...
0
1
2
3
4

# 如果使用了else子句，那么会在循环正常结束后再执行else子句
>>> sum = 0
>>> for i in (1,2,3):
...     sum += i
... else:
...     print('sum = %d' % sum)
...
sum = 6

# 如果for循环体中使用了break，那么则不会执行else子句
>>> sum = 0
>>> for i in (1,2,3):
...     sum += i
...     if i == 2:
...             break
...     else:
...             print('sum = %d' % sum)
...
sum = 1
>>> print(sum)
3

如果需要在for循环同时取序列中元素的下标和值，可以使用enumerate函数：

>>> for i,v in enumerate(['tic','tac','toe']):
...     print(i,v)
...
0 tic
1 tac
2 toe

如果需要在for循环遍历一个序列的同时修改序列，建议是对该序列做一个拷贝然后再遍历该拷贝，如果不用拷贝的方式，直接在遍历该序列的同时修改该序列，可能会出现一些不可预料的情况：

# 想要去除nums中的偶数
>>> nums = [1,2,4,3]
>>> for n in nums:
...     if n % 2 == 0:
...             nums.remove(n)
...
>>> nums
[1, 4, 3]
# python在循环时内部会有一个计算器记录当前循环下标（从0开始），并且每次自动加1
# 所以当循环到元素2时，记录的当前下标为1，然后判断2为偶数并移除了它，然后后面的元素依次往前挪一位，当进入下一次循环时自动取下标为2的元素，则取到了元素3，这样就把元素4给漏掉了

# 这种情况，一般是建议拷贝一份序列后在对其进行遍历
>>> nums = [1,2,4,3]
>>> for n in nums.copy():
...     if n % 2 == 0:
...             nums.remove(n)
...
>>> nums
[1, 3]

# 还可以使用切片方式nums[:]创建一个拷贝，比copy的方式更简洁
>>> nums = [1,2,4,3]
>>> for n in nums[:]:
...     if n % 2 == 0:
...             nums.remove(n)
...
>>> nums
[1, 3]

使用for循环对字典遍历时默认遍历其key，但是也可以使用字典的.items()方法同时遍历其key和value，或者使用字典的.values()方法只遍历其values：

# 遍历字典的key
>>> d = {'name':'tom','age':18}
>>> for k in d:
...     print(k)
...
name
age

# 同时遍历key和value
>>> for k,v in d.items():
...     print(k,v)
...
name tom
age 18

# 只遍历value
>>> for v in d.values():
...     print(v)
...
tom
18

如果需要使用for循环同时遍历多个长度相同的序列时可以使用zip函数：

# 同时遍历2个序列
>>> keys = ['name','age']
>>> values = ['tom',18]
>>> for k,v in zip(keys,values):
...     print(k,v)
...
name tom
age 18

# 同时遍历3个序列
>>> for i,j,k in zip([1,2],[3,4],[5,6]):
...     print(i,j,k)
...
1 3 5
2 4 6

如果需要使用for循环反向遍历一个序列时，可以使用reversed函数：

>>> for i in reversed([1,2,3]):
...     print(i)
...
3
2
1

3.while

while语句的定义如下：

while_stmt ::= "while" expression ":" suite
				["else" ":" suite]

当表达式expression为真时执行suite，后边还可以跟一个可选的else子句，当表达式expression为假时执行else子句中的suite，如果在第一个suite中执行了break，则退出循环，并且不会执行else子句。

# 使用while循环计算1~10的和
>>> i = 1
>>> sum = 0
>>> while i <= 10:
...     sum += i
...     i += 1
...
>>> sum
55

# else子句在while的expression为假时执行
>>> i = 1
>>> sum = 0
>>> while i <= 10:
...     sum += i
...     i += 1
... else:
...     print('loops over')
...
loops over
>>> sum
55

# while的循环体中执行了break，所以子句else被跳过不执行
>>> i = 1
>>> sum = 0
>>> while i <= 10:
...     sum += i
...     i += 1
...     if i == 9:
...             break
...     else:
...             print('loop over')
...
loop over
loop over
loop over
loop over
loop over
loop over
loop over
>>> sum
36

4.break

break语句用于for或者while循环体中，执行后直接退出循环，并且不会执行循环的else子句，具体示例请见上面的for和while小节内容，这里不再重复举例。

5.continue

continue语句在for或者while循环体中，跳过本次循环中后续的内容，然后进入下一次循环，它不会结束整个循环，并且不影响循环的else子句。

# 使用continue跳过for循环中偶数的打印步骤，并且不会影响到else子句
>>> for i in range(1,11):
...     if i % 2 == 0:
...             continue
...     print(i)
... else:
...     print('loops over')
...
1
3
5
7
9
loops over

# 使用continue跳过while循环中偶数的打印步骤，并且不会影响到else子句
>>> i = 0
>>> while i <= 10:
...     i += 1
...     if i % 2 == 0:
...             continue
...     print(i)
... else:
...     print('loops over')
...
1
3
5
7
9
11
loops over

6.pass

pass语句不做任何事情，通常用于一些在语法上需要写内容，但是实际没有内容可写的情况下进行占位。

# 自定义异常类
class MyException(Exception):
	pass

# 先定好函数名，函数体还需要进一步思考后编写
def myfun():
	pass