python流程控制详解（含迭代器，生成器）（二）

思维导图文本

4、流程控制
条件语句
if语句
定义
if语句用于实现条件判断，让程序作出简单或复杂的决策。
if...else...

if...elif...else

若结果为真则执行，反之不执行（若...则执行...否则...）
举例
若‘你是好学生’ 则 ‘学好Python’；若‘你不是好学生’，则‘回家种田’
语法
单if条件

if 条件判断1：
if条件判断根据代码返回的布尔逻辑结果True或False来进行选择操作
布尔/比较/身份/成员操作能够返回True和False
布尔操作
and
or
not
比较操作
==
！=
>
<
> =
< =
成员操作
in
not in
身份操作
is
is not
代码块1
根据PEP规定，Python缩进采用4个空格
一般的IDE和文本编辑器会帮忙自动缩进
用tab可以成功执行，也不是非常符合代码规范
其他程序一般采用花括号来解决代码之间的关系
else：
else是可选部分
若没有else部分，则if条件为真时，执行代码块，否则什么都不执行
代码块2
多if条件

if 条件判断1：
代码块1
elif条件判断2：
elif 相当于 else if
代码块2
elif条件判断3：
多条件判断中，只要有一个条件为真，则执行后并结束判断
代码块3
……
else:
代码块n
举例
单条件判断
举例1
判断正负数
>>> num = 10
>>> if num > 0 :
...     print '正数'
python3.0中，print后面的内容需要加括号（ ）
2.7.6可加可不加
... else:
...     print '负数'
...
正数
举例2
用户输入一个数字，判断正负数
#!/usr/bin/python
# -*- coding: UTF-8 -*-
num = input('number: ')
通过input( )函数获取用户输入
n = int(num)
通过int( )整数函数将用户输入转换为整数
if n > 0 :
print '正数'
else:
print '负数'
多条件判断
举例3
判断成绩优良中差
>>> score = 80
>>> if score < 60:
...     print '不及格'
... elif 60<= score <= 79:
...     print '中等'
... elif 80 <= score <= 100:
...     print '优良'
... else:
...     pass
...
优良
举例4
用于输入分数，给出判断结果
#!/usr/bin/python
# -*- coding: UTF-8 -*-
score = int(input('分数: '))
if score < 60:
print '不及格'
elif 60<= score <= 79:
print '中等'
... elif 80 <= score <= 100:
print '优良'
... else:
...     pass
多条件同时判断
举例5
or表示任意一个条件成立即可
>>> num = 8
>>> if num > 9 or num < 10:
...     print 'yes'
... else:
...     print 'no'
...
yes
举例6
and表示所有条件成立才可以
>> num = 8
>>> if num > 9 and num < 10:
...     print 'yes'
... else:
...     print 'no'
...
no
嵌套条件判断
举例7
if...else...语句嵌套if...else...语句
>>> num = 8
>>> if num < 10:
...     print 'yes'
...     if num == 8:
...         print 'it is 8'
...     else:
...         print 'it is others'
... else:
...     print 'no'
...
yes
it is 8
优化
num = 7
if num < 10:
print '%s < 10' % num
if num == 8:
print '%s is 8' % num
else:
print '%s is not 8' % num
else:
print '%s >= 10' % num
条件表达式
举例8
概述
条件表达式也称为三元操作符，是if语句的缩写格式
如果X为真，则A等于Y，否则A等于Z
A = Y if X else Z
if X:
A = Y
else:
A = Z
举例
>>> num = 8
>>> A = 10 if num > 0 else 9
>>> if num > 0:
...     A = 10
... else:
...     A = 9
...
>>> A
10
>>> A
10
>>> A = 'YES' if True else 'NO'
>>> if True:
...     A = 'YES'
... else:
...     A = 'NO'
>>> A
'YES'
循环语句
条件循环
while语句
定义

while语句用于实现条件循环，可以在条件满足的情况下循环执行代码块
若结果为真则执行循环，反之不执行（若...则循环...）
语法

While条件判断：
While条件判断根据代码返回的布尔逻辑结果True或False来进行选择操作
与if条件一样
布尔/比较/身份成员操作能够返回True和False
布尔操作
and
or
not
比较操作
==
！=
>
<
> =
< =
成员操作
in
not in
身份操作
is
is not
一般在条件判断之前，会有初始语句，例如定义变量初始值等
n = 0
i = 1
循环代码块
重复执行，直到条件不满足
一般包含递增赋值语句，确保循环最终能退出
i = i + 1
举例
举例1
输出1到10
>>> n = 0
>>> while n < 10:
...     n = n + 1
...     print n
...
1
2
3
4
5
6
7
8
9
10
举例2
输出0到10数字相加的结果
>>> n = 0
>>> sum = 0
>>> while n < 10:
...     sum = sum + n
...     n = n + 1
...     print sum
...
0
1
3
6
10
15
21
28
36
45
举例3
while与else结合

>>> n = 0
>>> while n < 10:
...     n = n + 1
...     print n
... else:
...     n = -n
...     print n
...
1
2
3
4
5
6
7
8
9
10
-10
循环语句
for语句
定义

for语句用于实现循环，例如对列表和字符等可迭代对象进行遍历
语法

for X in Y
X为变量
Y为可迭代对象
可以是字符串/元祖/列表/字典/函数等可迭代对象
代码块
举例
举例1
遍历字符串
>>> s = 'hello,world'
>>> for x in s:
...     print x
...
h
e
l
l
o
,
w
o
r
l
d
>>> for a in s:
...     print a.upper(),
代替\n
...
H E L L O , W O R L D !
举例2
遍历列表
>>> l = [1,2,3]
>>> for x in l:
>>> for x in l:
...     print x,
...
1 2 3
...     print x
...
1
2
3
举例3
计算和
>>> l = [1,2,3,4,5]
>>> sum = 0
>>> for i in l:
...     sum = sum + i
...     print sum
...
1
3
6
10
15
举例4
计算乘阶
>>> i = 1
>>> for x in [1,2,3,4,5]:
...     i = i * x
...     print i
...
1
2
6
24
120
举例5
for语句结合else
当循环执行完之后则执行else语句
>>> l1 = [1,2,3,4,5]
>>> for i in l1:
...     l = i * i
...     print l
... else:
...     print i
...
1
4
9
16
25
5
举例6
for语句结合range( )
功能
range( )函数可以生成整数列表
range(x,y）会生成x到y-1的整数列表
range(1,10)会生成1到9的整数列表
语法
完整语法
range(start, end, step)
range( )返回一个包括所有k的列表，这里start<=k<end，从start到end

k每次递增step。step不可以为0，否则将发生错误。
若没有给step，只有2个值，则step默认为1
range返回的值不能等于end，可以等于start
简略语法
range( end )
>>> range(5)
[0, 1, 2, 3, 4]
range (start, end)
举例
>>> for x in range(1,10):
...     print x
...
1
2
3
4
5
6
7
8
9
>>> i = 1
>>> for x in range(5):
...     i = i * (x + 1)
...     print i
...
1
2
6
24
120
举例7
for语句结合zip( )
功能
zip( )函数获取多个列表的元素，生成内置元祖的列表
结合for循环语句可以实现多列表并行遍历
语法
for (x,y) in zip (l1, l2)
举例
>>> l1 = ['a','b','c','d']
>>> l2 = [1,2,3,4]
>>> zip(l1,l2)
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> for (x,y) in zip(l1,l2):
...     print x , y
...
a 1
b 2
c 3
d 4
举例8
for语句结合map( )
功能
map( )函数将可迭代对象的每个元素传入函数并返回一个列表
语法
map(f, iterable)
[f(x) for x in iterable]
map函数包括函数和可迭代对象（列表等）
当函数为None时，map( )可以实现并行解析
举例
>>> l1 = ['a','b','c','d']
>>> l2 = [1,2,3,4]
>>> map(None,l1,l2)
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> for (x,y) in map(None,l1,l2):
...     print x , y
...
a 1
b 2
c 3
d 4
举例9
for语句结合enumerate( )
功能
enumerate( )用于给传入的可迭代对象索引，返回迭代器
语法
>>> for (x,y) in enumerate(迭代对象):
举例
>>> l1 = ['a','b','c']
>>> for (x,y) in enumerate(l1):
...     print x,y
...
0 a
1 b
2 c
循环控制
break
定义

用于while和for循环中，用于终止整个循环语句
举例
举例1
while语句中使用break，结合if判断，当搜索到某个字符串时，终止遍历
>>> n = 0
>>> while n < 10:
...     n = n + 1
...     if n == 8:
...         break
...     print n
...
1
2
3
4
5
6
7
举例2
for语句中使用break，结合if判断，当搜索到某个字符串时，终止遍历
>>> for i in 'Hello,world!':
...     if i == ',':
...         break
...     print 'The letter is: ',i
...
The letter is:  H
The letter is:  e
The letter is:  l
The letter is:  l
The letter is:  o
continue
定义

用于while和for循环中，用于终止本次循环
举例
>>> for i in 'Hello,world!':
...     if i == ',':
检查到字符串“,”时，直接忽略并继续下面的循环执行
...         continue
...     print 'The letter is: ',i
...
The letter is:  H
The letter is:  e
The letter is:  l
The letter is:  l
The letter is:  o
The letter is:  w
The letter is:  o
The letter is:  r
The letter is:  l
The letter is:  d
The letter is:  !
pass
定义
用于循环语句、条件语句、函数语句中占空，保证语句完整
举例
>>> for i in 'Hello,world!':
...     pass
...
>>> while n < 10:
...     pass
用ctrl + c快捷键终止此循环执行
>>> def f():
...     pass
...
进阶语句
迭代器
定义

迭代
迭代（Iteration）指的是对可迭代对象进行从头到尾访问/遍历的过程
例如for循环的底层原理就是一个迭代
迭代器
迭代器（Itarator）指的是通过iter( )函数所返回的一个支持next( )方法的对象
迭代方法
iter( )
通过iter( )可以获得可迭代对象
默认可迭代对象没有next( )函数，通过iter( )迭代函数赋予next( )
next( )
返回可迭代对象中的下一个元素，并检查StopIteration异常终止迭代
可迭代对象
有哪些可迭代对象？
列表
元祖
字符串
字典
文件
自身有next( )方法
迭代的原理是什么？
可迭代对象（iterable）在进行遍历/迭代的时候，自动调用iter获取迭代器，自动调用next方法获取下一个元素
例如 for i in [1,2,3] Python自动调用iter( )函数获取迭代器，自动调用next( )函数获得下一个元素
next( )函数检查StopIteration异常并终止迭代
语法
iter( L )
next( L )
举例
举例1
手工迭代列表
>>> l = [1,2,3]
>>> I = iter(l)
>>> I
<listiterator object at 0x10d2b8b50>
>>> I.next()
1
>>> I.next()
2
>>> I.next()
3
>>> I.next()
Traceback (most recent call last):
File "<input>", line 1, in <module>
StopIteration
举例2
手工迭代字典
>>> D = {'a':1, 'b':2, 'c':3}
>>> I = iter(D)
>>> I
<dictionary-keyiterator object at 0x10d2bbaf8>
>>> next(I)
'a'
>>> next(I)
'c'
>>> next(I)
'b'
>>> next(I)
Traceback (most recent call last):
File "<input>", line 1, in <module>
StopIteration
...
举例3
通过try...except...语句自动迭代列表
>>> l = [1,2,3,4,5]
>>> i = iter(l)
>>> i
<listiterator object at 0x10d2b8bd0>
>>> try:
...     while True:
...         n = i.next()
...         print n
... except StopIteration:
...     pass
...
1
2
3
4
5
注：等价于for i in l
举例4
通过for语句自动迭代列表
>>> l = [1,2,3,4,5]
>>> for i in l:
...     print i
...
1
2
3
4
5
列表解析
定义
列表解析（List comprehensions）主要用于动态的创建列表
列表生成式
列表解析是迭代技术的一个应用，采用for循环和迭代函数动态生成列表，更简洁方便
语法
[X for Y in Z]
[expr for iter_var in iterable]
for循环通过变量iter_var遍历可迭代对象iterable
expr应用于序列的每个成员，最终结果即产生的列表
[X for Y in Z if J]
if J 为判断条件
X为需要得到的结果
X与Y是相关联的
Y是用于遍历Z的参数
Z是被遍历的对象
Z可以是字符串/元祖/列表/字典/函数等可迭代对象
举例
>>> [x + 1 for x in (1,2,3)]
X即x + 1
Y即x
Z即（1，2，3）
[2, 3, 4]
>>> [x for x in 'hello']
X即x
Y即x
Z即‘hello'
['h', 'e', 'l', 'l', 'o']
>>> [x * x for x in range(1,5)]
[1, 4, 9, 16]
>>> [x + 1 for x in [1,2,3,4,5] if x > 3]
[5, 6]
>>> l1 = ['hello','world']
>>> l2 = [x.upper() for x in l1]
>>> l2
['HELLO', 'WORLD']
生成器表达式
定义
生成器是特定的函数, 允许返回一个值, 然后"暂停"代码的执行, 稍后恢复
生成器函数
在 Python 中，带有 yield 的函数被称之为 generator（生成器）
使用yield语句一次返回一个结果，在每个结果之间挂起和继续它们的状态
生成器表达式是生成器的应用，是列表解析和生成器的结合，也是列表解析的拓展
生成器表达式按需返回产生结果的一个对象，而不是返回或构建一整个结果列表
列表解析是直接生产最终的列表，而生成器表达式按需生产内容，相比而言，后者更加节省内存空间
语法
(expr for iter_var in iterable if cond_expr)
列表解析用[ ] 生成器表达式用（ ）
举例
>>> l1 = [x + 1 for x in (1,2,3)]
利用列表生成式生成列表
>>> l1
列表生成式直接得到最终结果
若可迭代对象体积比较大，则非常占用内存空间
[2, 3, 4]
>>> l2 = (x + 1 for x in (1,2,3))
利用生成器表达式生成列表
>>> l2
<generator object <genexpr> at 0x10d2bf8c0>
生成器表达式不会直接得到最终列表结果，而是按需得到结果
通过next( )函数手工迭代，或者通过for循环工具自动迭代
以此验证生成器是逐步运行逐步挂起，而迭代器是默认全部运行
>>> l2.next()
生成器表达式是可迭代对象，具备next( )函数，用于得到下一个元素
2
>>> l2.next()
3
>>> l2.next()
4
>>> l2.next()
Traceback (most recent call last):
File "<input>", line 1, in <module>
StopIteration

• 点赞
• 收藏
• 分享
• 文章举报