循环（一）流程控制if-elif-else、while、for，pass、assert语句，range()/zip()/enumerate()函数

python语句后面没有分号

一、 if - elif - else语句

Python 是一门非常独特的编程语言,通过缩进来识别代码块，具有相同缩进量的若干行代码属于同一个代码块， 因此不要胡乱缩进，代码块一定要有缩进，没有缩进的不是代码块。另外，同一个代码块的缩进量要相同，缩进量不同的不属于同一个代码块。

建议缩进 1 个 Tab 键的位置，或者缩进 4 个空格；它们两者其实是等价的，很多编辑器都可以将 Tab 键设置为 4 个空格，比如，IDLE 中默认 Tab 键就是 4 个空格。

在其他语言中（如 C语言、C++、Java 等），选择结构还包括 switch 语句，也可以实现多重选择，但是在 Python 中没有 switch 语句，实现多重选择的功能时，只能使用 if else 分支语句。

语法格式如下 注意if elif else后面都有冒号

if 表达式：
    代码块


if 表达式：
    代码块 1
else：
    代码块 2


if 表达式 1：
    代码块 1
elif 表达式 2：
    代码块 2
elif 表达式 3：
    代码块 3
...//其它elif语句
else：
    代码块 n

二、pass语句

pass 是 Python 中的关键字，用来让解释器跳过此处，什么都不做。
在实际开发中，有时候我们会先搭建起程序的整体逻辑结构，但是暂时不去实现某些细节，而是在这些地方加一些注释，方面以后再添加代码，这时程序需要占一个位置，或者放一条语句，但又不希望这条语句做任何事情，此时就可以通过 pass 语句来实现。使用 pass 语句比使用注释更加优雅。

age = int( input("请输入你的年龄：") )
if age < 12 :
    print("婴幼儿")
elif age >= 12 and age < 18:
    print("青少年")
elif age >= 18 and age < 30:
    print("成年人")
elif age >= 30 and age < 50:
    #TODO: 成年人
    pass
else:
    print("老年人")

三、assert断言

Python assert 语句，又称断言语句，可以看做是功能缩小版的 if 语句，它用于判断某个表达式的值，如果值为真，则程序可以继续往下执行；反之，Python 解释器会报 AssertionError 错误。

语法格式：assert 表达式

assert 语句的执行流程可以用 if 判断语句表示，如下所示：

if 表达式==True:
    程序继续执行
else:
    程序报 AssertionError 错误

有读者可能会问，明明 assert 会令程序崩溃，为什么还要使用它呢？这是因为，与其让程序在晚些时候崩溃，不如在错误条件出现时，就直接让程序崩溃，这有利于我们对程序排错，提高程序的健壮性。

mathmark = int(input())
#断言数学考试分数是否位于正常范围内
assert 0 <= mathmark <= 100
#只有当 mathmark 位于 [0,100]范围内，程序才会继续执行
print("数学考试分数为：",mathmark)

运行结果：
90
数学考试分数为： 90

再次执行该程序，测试数据为：
159
Traceback (most recent call last):
  File "C:\Users\mengma\Desktop\file.py", line 3, in <module>
    assert 0 <= mathmark <= 100
AssertionError

四、while for 循环

Python 中的循环语句有 2 种，分别是 while 循环和 for 循环，while比较简单

while 条件表达式：
    代码块

有冒号

for 循环它常用于遍历字符串、列表、元组、字典、集合、range等可迭代对象，逐个获取序列中的各个元素。即被循环的对象要是一个可迭代对象 ，通过dir(str)、dir(list) 等观察会发现他们都有_iter_方法 通过这个手段可以判断一个对象是否是可迭代对象

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

有冒号

add = "http://c.biancheng.net/python/"
#for循环，遍历 add 字符串
for ch in add:
    print(ch,end="")

运行结果
http://c.biancheng.net/python/

需要特别注意for循环遍历字典
在使用 for 循环遍历字典时，经常会用到和字典相关的 3 个方法，即 items()、keys() 以及 values()
如果使用 for 循环直接遍历字典，则迭代变量会被先后赋值为每个键值对中的键。因此直接遍历字典，和遍历字典 keys() 方法的返回值是相同的，只能得到字典的键。

my_dic = {'python教程':"http://c.biancheng.net/python/",\
          'shell教程':"http://c.biancheng.net/shell/",\
          'java教程':"http://c.biancheng.net/java/"}
for ele in my_dic:
    print('ele =', ele)


程序执行结果为：
ele = python教程
ele = shell教程
ele = java教程

若要遍历字典 values()、items() 方法的返回值。

my_dic = {'python教程':"http://c.biancheng.net/python/",\
          'shell教程':"http://c.biancheng.net/shell/",\
          'java教程':"http://c.biancheng.net/java/"}
for ele in my_dic.items():
    print('ele =', ele)

程序执行结果为：
ele = ('python教程', 'http://c.biancheng.net/python/')
ele = ('shell教程', 'http://c.biancheng.net/shell/')
ele = ('java教程', 'http://c.biancheng.net/java/')

通过items()方法遍历键值对
其实也可直接遍历键，通过键访问值也可以得到键值对 
for ele in my_dic:
    print(ele,my_dic[ele])
    
运行结果
python教程 http://c.biancheng.net/python/
shell教程 http://c.biancheng.net/shell/
java教程 http://c.biancheng.net/java/


两种方法且区别在于
items()输出是键值对的格式
我们看到得到的ele用小括号括起来 因此ele的类型是元组tuple 可用元组[]访问方法访问ele中的两个元素
for ele in my_dic.items():
	type(ele)
    print(ele[0],ele[1])

运行结果
<class 'tuple'>
python教程 http://c.biancheng.net/python/
<class 'tuple'>
shell教程 http://c.biancheng.net/shell/
<class 'tuple'>
java教程 http://c.biancheng.net/java/




for ele in my_dic.keys():
	print(ele)
for ele in my_dic.values():
	print(ele)	
	
运行结果
python教程 
shell教程
java教程
http://c.biancheng.net/python/	
http://c.biancheng.net/shell/
http://c.biancheng.net/java/

五、for循环中常用到的函数

1、range(stop) 、range(start,stop[,step])

for循环做数字循环时 循环次数还可以用内置函数range()来控制

range()函数的用法
从指定的第一个值start开始，一直数到指定的第二个值stop停止，不包含第二个值

for value in range(1,5):
    print(value)

运行结果
1
2
3
4

range() 函数的返回值并不直接是列表类型（list），而是range类型 ，数值单调增

>>> type([1,2,3,4,5])
<class 'list'>
>>> type(range(1,6))
<class 'range'>


>>> r=range(1,6)
>>> r
range(1, 6)   
>>> type(r)
<class 'range'>

并没有直接产生1,2,3,4，5 这五个数字 这些数字此时还没没有分配内存空间 
只有当我们使用到range中的那个数之后 那个数才占用内存
如当前循环到3 只有1 2 3 三个数分配了空间 其他没有

而如果想要得到 range() 函数创建的数字列表，还需要借助 list() 函数
可以看到如果将 range() 作为 list() 的参数，其输出就是一个数字列表

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

在使用 range() 函数时还可以指定步长step例如，下面的代码打印 1~10 内的偶数：

even_numbers = list(range(2,11,2))
print(even_numbers)

在这个示例中，函数 range() 从 2 开始数，然后不断地加 2，直到达到或超过终值，因此输出如下：
[2, 4, 6, 8, 10]


even_numbers = list(range(2,12,2))
print(even_numbers)

[2, 4, 6, 8, 10]  没有包括12
注意，即便 range() 第二个参数恰好符合条件，最终创建的数字列表中也不会包含它

要得到0-100能被3整除的数 还可以直接用range(0,100,3) 不用取余运算

如果range只有一个参数，该参数做stop，默认从0开始
range(100) 得到0到99的这100个数

lst=[];
for i in range(100)    #循环100次
	n=random.randint(1,10)   
	lst.ppend(n)
	
需要import random模块
random.random()产生0-1之间的一个随机小数  半闭半开[0,1)
random.randint(a,b)产生a-b之间的一个随机整数  闭区间[a,b]

2、zip函数

它可以将多个序列（列表、元组、字典、集合、字符串以及 range() 区间构成的列表）“压缩”成一个 zip 对象。所谓“压缩”，其实就是将这些序列中对应位置的元素重新组合，生成一个个新的元组）

和 Python 3.x 版本不同，Python 2.x 版本中的 zip() 函数会直接返回列表，而不是返回 zip 对象。但是，返回的列表或者 zip 对象，其包含的元素（都是元组）是相同的。

>>> lst=[1,2,3]
>>> tpl=(5,6,7,8)
>>>> z=zip(lst,tpl)
>>> z
<zip object at 0x00CCDD00>

>>>print([x for x in zip(lst,tpl)])   或者 print([x for x in z])
[(1, 5), (2, 6), (3, 7)]

注意这里采用了列表解析:print()里面有中括号[]

如果这样写 
>>> for x in zip(lst,tpl):
...     print(x)
...
程序运行结果是
(1, 5)
(2, 6)
(3, 7)

列表解析传送门

在使用 zip() 函数“压缩”多个序列时，它会分别取各序列中第 1 个元素、第 2 个元素、… 第 n 个元素，各自组成新的元组。
当多个序列中元素个数不一致时，会以最短的序列为准进行压缩。

另外，对于 zip() 函数返回的 zip 对象，既可以像上面程序那样，通过遍历提取其存储的元组，也可以向下面程序这样，通过调用 list() 函数将 zip() 对象强制转换成列表：

my_list = [11,12,13]
my_tuple = (21,22,23)
lst=list(zip(my_list,my_tuple))
print(list(zip(my_list,my_tuple)))  或者 print(lst)

程序执行结果为：
[(11, 21), (12, 22), (13, 23)]

lst=[1,2,3]
tpl=(5,6,7,8)
>>> r=[]
>>> for x,y in zip(lst,tpl):
...     r.append(x+y)
...
>>> r
[6, 8, 10]
>>>

3、enumerate(iteratorObjet)函数

返回一个枚举对象 该枚举对象的元素是参数可迭代对象的所有元素及其对应的索引
可以将枚举对象转成list等

 enumerate(object)
 |  enumerate(iterable, start=0)
 |
 |  Return an enumerate object.
 |
 |    iterable
 |      an object supporting iteration
 |
 |  The enumerate object yields pairs containing a count (from start, which
 |  defaults to zero) and a value yielded by the iterable argument.
 |
 |  enumerate is useful for obtaining an indexed list:
 |      (0, seq[0]), (1, seq[1]), (2, seq[2]), ...

>>> r=[6,8,10,12,14]
>>> s=["one","two","three","four"]
>>> list(enumerare(s))
[(0, 'one'), (1, 'two'), (2, 'three'), (3, 'four')]

判断列表中某个元素是否是偶数 是偶数 修改元素值为even

lst=[1,5,3,20,6,2,7]
for i in range(len(lst)):
	if lst[i]%2==0:
		lst[i]='even'
print(lst)

运行结果
[1,5,3,'even','even','even',7]

或者
lst=[1,5,3,20,6,2,7]
for i,ele in enumerate(lst):   #两个变量 i作索引 ele为该索引对应的元素
	if ele%2==0:
		lst[i]='even'
print(lst)

运行结果
[1,5,3,'even','even','even',7]