python学习笔记（二）流程控制

主要内容：

• 用while循环重复执行代码
• 用if-elif-else语句执行判断
• 用for循环遍历列表
• 使用列表和字典推导式
• 用缩进标识语句和代码块
• 对布尔值和布尔表达式求值

（一）while循环

while循环结构如下：

while condition:
    body
else:
    post-code

condition是一个布尔表达式，返回结果为True或False。如果condition返回结果为True，则循环执行body部分代码；如果返回结果为Flase，则while循环执行post-code代码，然后停止运行。Python解释器根据代码缩进的级别来识别这两个部分。

注意，这里的else部分是可选的。

continue语句：执行了continue语句，会导致body剩余的语句被跳过，进行下一次condition计算，循环继续进行。

break语句：执行了break语句，while循环立即终止。

（二）if-elif-else语句

最通用的if-elif-else结构的形式如下;

if condition1:
    body1
elif condition2:
    body2
.
.
else:
    body(n)

如果condition1返回的结果为True，则执行body1语句；否则，如果condition2返回的结果为True，则执行body2语句，一次类推，最后没有返回True的condition，则执行else语句。

pass语句用作语句的占位符，但是它不执行任何操作。

if x < 5:
    pass
else:
    x = 5

如下例：

'''
7.猜拳游戏
石头 剪刀 布
 0    1   2
 数据：
    unum 0 1 2
    cnum 0 1 2
'''
import random
unum=int(input("石头(0),剪刀(1),布(2) 请选择："))
cnum=random.randint(0,2) #[0,2)
 
l = '石头， 剪刀， 布'.split()
 
print("用户：%s"%l[unum])
print("电脑：%s"%l[cnum])
if unum==0 and cnum==1:
	print("赢了！")
elif unum==0 and cnum==2:
	print("输了！")
elif unum==1 and cnum==2:
	print("赢了！")
elif unum==1 and cnum==0:
	print("输了！")
elif unum==2 and cnum==0:
	print("赢了！")
elif unum==2 and cnum==1:
	print("输了！")
else:
    print('平局！')

（三）for循环

for循环遍历的是任何可迭代对象的返回值，也就是任何可以生成值序列的对象。例如，for循环可以挨个遍历列表、元组或字符串的元素。这里可迭代的对象还可以是特殊的range函数，或者被称为生成器（generator），或生成器表达式的特殊类型函数。常见形式为：

for item in sequence:
    body
else:
    post-code

对sequence的每个元素都会执行一次body部分的语句。一开始item会被设为sequence的第一个元素，并执行body部分；然后item会被设为sequence的第二个元素并执行body部分，等等，对sequence的其余元素会逐个一次处理。

else部分是可选的。像while循环的else部分一样，很少被用到。break和continue在for循环中的作用，和在while循环中是一样的。

以下循环将会打印出x中每个数字的倒数：

>>> x = [1,2,3,4,5,6]
>>> for i in x:
	print(1/i)

	
1.0
0.5
0.3333333333333333
0.25
0.2
0.16666666666666666

在for循环体中，break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

1.range函数

有时候循环需要显式的索引（如值在列表中出现的位置）。这是可以将range函数和len函数结合起来使用，生成供for循环使用的索引序列。

x = [1, 3, 5, 6, -7, 9, -6]

for i in range(len(x)):
    if x[i] < 0:
        print('Found a negative number at index', i)

2.用初值和步进值控制range函数

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，也可以使用range指定区间的值。

range函数有两个变体，可以对生成的值序列施以更多的控制。如果range函数带有两个数值参数，则第一个参数是结果序列的起始值，第二个参数是结果序列的结束值（不含）。

>>> for i in range(5):
	print(i)

	
0
1
2
3
4
>>> for i in range(3, 9):
	print(i)

	
3
4
5
6
7
8

也可以使range以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做’步长’):

>>> for i in range(0, 10, 3):
	print(i)

	
0
3
6
9

负数

>>>for i in range(-10, -100, -30) :
    print(i)
 
    
-10
-40
-70

还可以使用range()函数来创建一个列表，这里list（）函数的作用是把range函数生成的值强制转换为列表。

>>> list(range(5))
[0, 1, 2, 3, 4]

3.for循环和元组拆包

元组拆包操作可以让某些for循环变得简洁一些。以下代码将读取元组列表，每个元组中包含两个元素，计算每个元组中两个数的乘积并进行加和。

somelist = [(1,2), (3, 7), (9, 5)]
result = 0
for t in somelist:
    result = result + (t[0] * t[1])

以下代码效果相同但是更为简洁

somelist = [(1,2), (3, 7), (9, 5)]
result = 0
for x, y in somelist:
    result = result + (x * y)

元组的这种用法是Python提供的一种便利手段，表示列表的每个元素都应该是大小一致的元组，以便能拆包到for关键字后面跟着的元组变量中。

4.enumerate函数

enumerate函数返回的是元组（索引，数据项）。这样可以不通过索引来访问列表的数据项。索引是可用的。

x = [1, 3, 5, 6, -7, 9, -6]

for i, n in enumerate(x):
    if n < 0:
        print('Found a negative number at index', i)

5.zip函数

zip函数可以从一个或多个可迭代对象中逐一读取对应元素，并合并为元组，直至长度最短的那个可迭代对象读取完毕。

>>> x = [1, 2, 3, 4]
>>> y = 'a, b, c'.split()
>>> z = zip(x, y)
>>> list(z)
[(1, 'a,'), (2, 'b,'), (3, 'c')]

6.实例：

通过for循环打印循环次数，i、j、k分别代表每一个for循环函数的循环次数：

total = 0

for i in range(1, 5):
    for j in range(1, 5):
        for k in range(1, 5):
            if (i != k) and (i != j) and (j != k):
                total += 1
                print("{0}{1}{2}".format(i, j, k))

print("Total: ", total)

（四）列表和字典推导式

利用for循环遍历列表、修改或选中某个元素、新建列表或字典，这些都是十分常见的用法。

>>> x = [1, 2, 3, 4]
>>> x_squared = []
>>> for item in x:
	x_squared.append(item * item)

	
>>> x_squared
[1, 4, 9, 16]

推导式：

#列表推导式
new_list = [expression1 for variable in old_list if expression2]
#字典推导式
new_dict = [expression: expression2 for variable in list if expression3]

上述例子可以用推导式

>>> x = [1, 2, 3, 4]
>>> x_squared = [item * item for item in x]
>>> x_squared
[1, 4, 9, 16]

甚至可以用if语句来筛选列表的项

>>> x = [1, 2, 3, 4]
>>> x_squared = [item * item for item in x if item > 2]
>>> x_squared
[9, 16]

字典推导式也类似，但是需要同时给出键和值。如果要实现类似上面的例子，需要把数字作为字典键，数字的平方作为字典值，就可以用字典推导式来实现。

>>> x = [1, 2, 3, 4]
>>> x_squared_dict = {item: item * item for item in x}
>>> x_squared_dict
{1: 1, 2: 4, 3: 9, 4: 16}

生成器表达式

生成器表达式（generator expression）类似于列表推导式，看起来于列表推导式十分相像，只是用圆括号代替了方括号而已。

>>> x_squared = (item * item for item in x)
>>> x_squared
<generator object <genexpr> at 0x0000026799383660>
>>> for squared in x_squared:
	print(squared, )

	
4
9
16

注意，除方括号的变化之外，生成器表达式还不返回列表。如上所示，生成器表达式返回的是生成器对象，可用作for循环中的迭代器，这与range（）函数的用途非常类似。使用生成器表达式的优点是，不会在内存中生成整个列表。因此可以生成任意大小的值序列，内存开销也很小。

（五）语句、代码块和缩进

Python用语句缩进来确定流程控制结构不同代码块（即语句体）的边界。一个代码块由一条或者多条语句组成，语句之间通常由换行符分隔。赋值语句、函数调用、print函数、占位用的pass语句和del语句都是Python语句。代码流程控制结构（if-elif-else、whlie和for循环）则属于复合语句。

复合语句由一条或多条子句组成，每条子句后面跟着缩进代码块。复合语句可以像任何其他语句一样出现在代码块中，这样就创建了嵌套代码块。

如果语句之间使用分号分隔，则可以在同一行放置多条语句。

Python对缩进量没有限制，也不会报错。只要保持同一个代码块中的缩进量一致，缩进多少字符都没有关系，推荐标准是使用4个空格。

任何由空白字符分隔的字符串都会被Python解释器自动拼接起来。

（六）布尔值和布尔表达式

Python有一种布尔对象类型，可以被赋为True或False。所有布尔操作表达式都返回True或False。

大多数Python对象都能用作布尔类型

• 数字0、0.0、和0 + 0j都是False，其他数字均为True；
• 空字符串" "是False，其他字符串均为True；
• 空列表[ ]是False，其他列表均为True；
• 空字典{ }是False，其他字典均为True；
• 空集合（）是False，其他集合均为True；
• Python的特殊值None始终为False。

通常情况下，Python的其他数据结构同样适用于上述规则。如果数据结构为空或0，则在布尔上下文中将被视为False，否则被视为True。某些对象（如文件对象和编码对象）对0或空元素没有明确的定义，这些对象也不应该在布尔上下文中使用。

Python常用操作符

用普通的<、<=、>、>=等操作符，就可以进行对象之间的比较。==是判断相等操作符，!=是判断不等操作符。in和not in操作符用于判断是否属于序列（列表、元组、字符串和字典）的成员，身份操作符is和is not用于判断判断两个对象是否为同一个对象。

比较运算符

以下实例演示了Python所有比较运算符的操作：

a = 21
b = 10
c = 0
 
if ( a == b ):
   print ("1 - a 等于 b")
else:
   print ("1 - a 不等于 b")
 
if ( a != b ):
   print ("2 - a 不等于 b")
else:
   print ("2 - a 等于 b")
 
if ( a < b ):
   print ("3 - a 小于 b")
else:
   print ("3 - a 大于等于 b")
 
if ( a > b ):
   print ("4 - a 大于 b")
else:
   print ("4 - a 小于等于 b")
 
# 修改变量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
   print ("5 - a 小于等于 b")
else:
   print ("5 - a 大于  b")
 
if ( b >= a ):
   print ("6 - b 大于等于 a")
else:
   print ("6 - b 小于 a")

输出结果为：

1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a

布尔操作符

通过and、or、not操作符，可以将返回布尔值的多个表达式组合成更为复杂的表达式。

a = 10
b = 20
 
if ( a and b ):
   print ("1 - 变量 a 和 b 都为 true")
else:
   print ("1 - 变量 a 和 b 有一个不为 true")
 
if ( a or b ):
   print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("2 - 变量 a 和 b 都不为 true")
 
# 修改变量 a 的值
a = 0
if ( a and b ):
   print ("3 - 变量 a 和 b 都为 true")
else:
   print ("3 - 变量 a 和 b 有一个不为 true")
 
if ( a or b ):
   print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("4 - 变量 a 和 b 都不为 true")
 
if not( a and b ):
   print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
   print ("5 - 变量 a 和 b 都为 true")

输出结果为：

1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false

短路求值

>>> def ReturnTrue():
	print('ReturnTrue() was called')
	return True

>>> def ReturnFalse():
	print('ReturnFalse() was called')
	return False

>>> ReturnTrue()
ReturnTrue() was called
True
>>> ReturnFalse()
ReturnFalse() was called
False
>>> ReturnFalse() or ReturnTrue()
ReturnFalse() was called
ReturnTrue() was called
True
>>> ReturnTrue() or ReturnFalse()
ReturnTrue() was called
True

优先级

优先级的规则有很多，如果不太确定，可以使用圆括号来确保Python按照要求解释表达式。如果表达式比较复杂，无论是否必要，用圆括号可能都是比较好的做法，因为这可以让以后维护代码的人确切地理解代码地意图。

参考：

1. 菜鸟教程
2. 码云：https://gitee.com/luhuadong/Python_Learning