3.1 条件语句
3.1.1 条件表达式3.1.2 单分支选择结构3.1.3 双分支选择结构3.1.4 多分支选择结构3.1.5 选择结构的嵌套3.1.6 三元表达式 3.2 循环语句
3.2.1 while循环3.2.2 while else循环3.2.3 for 循环3.2.4 for else循环 3.3 循环控制语句
3.3.1 break语句3.3.2 continue语句3.3.3 pass语句 3.4 迭代器
3.4.1 可迭代对象3.4.2 迭代器的定义3.4.3 迭代器的创建 3.5 生成器
3.5.1 生成器的定义3.5.2 生成器的创建 3.6 与条件语句、循环语句相关的内置函数
3.6.1 range函数3.6.2 enumerate函数3.6.3 reversed函数3.6.4 zip函数3.6.5 *zip函数3.6.6 sorted函数 3.7 总结
程序有三种基本的控制结构：顺序结构、选择结构、循环结构。
顺序结构：
选择结构（分支结构）：
循环结构：
条件语句是通过判断条件是否成立，根据条件表达式的结果做出决策，控制不同代码块的执行。
3.1.1 条件表达式条件表达式由运算符和操作数组成
例如：a<4，其中a、4都是操作数，小于符号<是运算符
判断条件可以是具有布尔属性的任意元素，包括数据、变量或由变量与运算符组成的表达式，若其布尔属性为True，条件成立；若布尔属性为False，条件不成立。
除了非空常量外，Python还常使用关系操作符和成员运算符构成判断条件 。
条件表达式常用的运算符有：
算术运算符：+、-、*、/、//、%、**
关系运算符：
Python支持通过保留字not、and和or对判断条件进行逻辑组合：
not，表示单个条件的“否”关系。如果“条件”的布尔属性为True，“not 条件”的布尔属性就为False；如果“条件”的布尔属性为False，“not 条件”的布尔属性就为True。and，表示多个条件之间的“与”关系。当且仅当使用and连接的所有条件的布尔属性都为True时，逻辑表达式的布尔属性为True，否则为False。or，表示多个条件之间的“或”关系。当且仅当使用or连接的所有条件的布尔属性都是False时，逻辑表达式的布尔属性为False，否则为True。 3.1.2 单分支选择结构
若if语句中的判断条件成立，执行if语句后的代码段；若判断条件不成立，则跳过if语句后的代码段。单分支结构中的代码段只有“执行”与“跳过”两种情况。
示例：使用单分支结构判断当天是否是星期天。
day = int(input("今天是工作日吗（请输入整数1~7）？"))if day in [1,2,3,4,5]:print("今天是工作日。")if day in [6,7]:print("今天非工作日。")
3.1.3 双分支选择结构若if语句中的判断条件成立，执行代码段1若判断条件不成立，则执行代码段2
示例：使用二分支结构判断当天是否是工作日。
day = int(input("今天是工作日吗（请输入整数1~7）？"))if day in [1,2,3,4,5]:print("今天是工作日。")else:print("今天非工作日。")
3.1.4 多分支选择结构
选择结构的嵌套是指选择结构的内部包含选择结构
python中没有c语言中的三目运算符，但是可以通过以下的形式实现三目运算符的功能
格式：条件判断为真时的结果 if 判断条件 else 条件为假时的结果
示例：x=x-1 if x>0 else x=x+1
等价于：
if x > 0: x = x - 1else: x = x + 1
我们可以利用三元表达式来实现裴波那契数列：
def fun(n): return n if n < 2 else fun(n - 1) + fun(n - 2)
还有一种用法，用bool方法选择相应的值，例如：
x = 1print([2, 3][bool(x)])x = 0print([2, 3][bool(x)])
结果：
32
3.2 循环语句在实际应用中有些需要重复进行的操作，可以用循环语句实现。
循环语句有：
while、do while、for
若循环条件为True，则循环执行while循环中的代码段；若循环条件为False，终止while循环。若while循环的条件总是True，这种情况叫做死循环 。
例如：使用while循环实现计算n的阶乘
n = int(input("请输入一个整数："))fact = 1i = 1while i<= n:fact = fact*ii = i + 1print("n!={}".format(fact))
3.2.2 while else循环Python的while循环也支持使用保留字else产生分支。
示例2：使用while-else循环实现计算n的阶乘
n = int(input("请输入一个整数："))fact = 1i = 1print("n!计算中……")while i<= n:fact = fact*ii = i + 1else:print("n!计算完成 ，循环正常结束")print("n!={}".format(fact))
3.2.3 for 循环目标可以是字符串、文件、range()函数或组合数据类型等；循环变量用于保存本次循环中访问到的遍历结构中的元素；for循环的循环次数取决于遍历的目标元素个数。
示例1：遍历字符串中的每个字符
string = input("请输入一个字符串：")for c in string:print(c)
3.2.4 for else循环for…else循环的具体实现形式：
for 循环变量 in 目标: 循环体else: 代码块
用法与while…else相同，如果循环体结束后没有碰到break语句，就会执行else语句块，如果结束之前碰到了break语句，就会跳出整个for循环，因此else语句块也就不会执行。
3.3 循环控制语句·在循环语句中，有时候需要达到中断循环，或者跳过本次循环，执行下次循环的情况，因此就需要有循环控制语句
python中使用break、continue语句控制循环的执行过程
break用于跳出整个循环
continue用于跳出本次循环，继续执行下次循环
pass的意思是过，pass掉就是淘汰掉的意思。
在python中，pass的意思是空语句，pass语句不做任何事情，只是为了保持程序结构的完整性。
3.4 迭代器迭代器是访问集合元素的一种方式。迭代器从集合的第一个元素开始访问，直到所有的元素被访问完才结束。
3.4.1 可迭代对象可迭代对象和迭代器是不同的概念。
python中，如果一个对象有__iter__() 和__getitem__()方法，则称这个对象为可迭代对象。
python中，用内置函数dir()，查看对象的属性、方法列表。
例如，打印出元组对象的属性和方法：
list_temp = ('a', 'b', 'c')print(dir(list_temp))
输出：
'__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__ getitem __', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', ' __iter __', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
列表、元组、字典、字符串等数据类型都是可迭代的（这里注意集合不是可迭代对象）
例如,打印出集合对象的属性和方法：
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
当然，自定义的类中只要实现了__iter__() 和__getitem__()方法，就也是可迭代的。
iter() :作用让对象可循环遍历
getitem()：作用是可通过实例名[index]方式访问实例中的元素
在python中，如果一个对象有__iter__()和__next__()方法，则称这个对象时迭代器。
其中__next__()方法的作用是让对象可通过该next(实例名)访问下一个元素
列表、元组、字典、字符串等数据类型是可迭代的，但是都不是迭代器，因为都没有__next__()方法。
是不是迭代器，也可以通过python内置函数isinstance进行测试
例如：
from collections import Iterablefrom collections import Iterator# 列表、元组、字典、字符串都是可迭代的print(isinstance([], Iterable))print(isinstance((), Iterable))print(isinstance({}, Iterable))print(isinstance('', Iterable))# 列表、元组、字典、字符串都不是迭代器print('-----------------------')print(isinstance([], Iterator))print(isinstance((), Iterator))print(isinstance({}, Iterator))print(isinstance('', Iterator))
输出：
TrueTrueTrueTrue-----------------------FalseFalseFalseFalse
迭代器都是可迭代的，但可迭代的不一定是迭代器
迭代器和可迭代对象的区别：
可迭代对象中提前存储了所有的元素，而迭代器只有迭代到某个元素的时候，该元素才生成，迭代前可以不存在，迭代后可以销毁，因此，迭代器在处理大量数据或无限数据时，具有加载数据快，内存占用小的优点。
1、内建工厂函数
内建工厂函数iter返回一个迭代器，可以将可迭代对象转换为迭代器，例如：
a = [5, 6, 7, 8]b = ('m', 'n', 'k')c = 'hello'print(iter(a))print(iter(b))print(iter(c))d = iter(a)print(next(d))print(next(d))print(next(d))
结果：
还有自定义迭代器，用的不是太多，这里就不讲了，用到的时候再讲。
3.5 生成器列表在创建的时候会将所有的元素全部创建好，再供用户使用，那如果你的元素有几十亿个，python就要在内存中开辟足够的空间存储，这就有可能导致内存不够的问题。如果只需要访问前面几个数据，那后面的绝大多数元素占用的空间就浪费了。
为了解决这种问题，python引入了生成器，根据事先设计好的规则开辟内存空间，创建对象供用户使用。
3.5.1 生成器的定义生成器是一种特殊的迭代器，通过调用一个返回迭代器的函数yield来实现迭代操作。yeild相当于为函数封装了__iter__()和__next__()。
3.5.2 生成器的创建 1、使用列表推导式定义列表
与列表推导式类似，只不过是[]换成()
# 使用列表推导式定义列表list_a = [x for x in range(10)]print(list_a)# 使用生成器推导式定义生成器generator_b = (x for x in range(10))print(generator_b)print(next(generator_b))print(next(generator_b))print(next(generator_b))print('---------------------')for n in generator_b: print(n)
输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2、使用yeild关键字
如果一个函数的定义中包含yeild关键字，那这个函数就不再是一个简单的函数了，而是一个生成器。
举个例子，生成裴波那契数列的函数如下：
def fib(max): n, a, b = 0, 0, 1 while n < max: print(b) a, b = b, a + b n = n + 1fib(10)
输出：
11235813213455
如果将代码中的print(b)换成yeild(b)，则这个fib函数就编程了生成器：
def fib(max): n, a, b = 0, 0, 1 while n < max: yield (b) a, b = b, a + b n = n + 1f = fib(10)print(f)for i in f: print(i)
结果：
range的作用是返回一个可迭代对象，规则如下：
range([star,]end[,step])
其中star是初始位置，默认从0开始，end是结束位置，但不包含end,计算区间是[star,end)，step是步长，step也可以为负数，反向遍历，range对象可用list转换成列表。
a = range(10)print(a)b = list(range(5))print(b)print(list(range(1, 8, 2)))print(list(range(8, 1, -2)))
结果：
range(0, 10)[0, 1, 2, 3, 4][1, 3, 5, 7][8, 6, 4, 2]
3.6.2 enumerate函数enumerate函数返回的是一个enumerate对象，作用是枚举可迭代对象的每一个元素，将他们组成一个索引序列，可以同时获得索引和值。
a = list(range(9, 1, -2))print(a)b = enumerate(a)print(b)for index, value in b: print(index, value)
结果：
[9, 7, 5, 3]
reversed作用是进行反向遍历，该函数可接收各种序列（元组、列表、字符串、区间等），然后返回一个反向的课迭代对象，需注意该函数对参数本身没有影响。
a = list(range(9, 1, -2))print(a)b = reversed(a)print(b)c = list(reversed(a))print(c)
结果：、
[9, 7, 5, 3][3, 5, 7, 9]
但是需要注意，如果第二次再使用reversed的，则会返回空置。
3.6.4 zip函数zip函数将多个可迭代对象打包乘一个元组，返回个zip对象
list_1 = ['a', 'b', 'c']list_2 = [1, 2, 3]print(list(zip(list_1)))print('----------------')a = zip(list_1, list_2)print(a)print(list(a))print('----------------')for (x, y) in zip(list_1, list_2): print(x, y)
结果：
[('a',), ('b',), ('c',)]----------------
*zip是zip函数的反过程，将zip对象还原为组合前的数据
list_1 = ['a', 'b', 'c']list_2 = [1, 2, 3]a = zip(list_1, list_2)print(a)print(list(a))c, d = zip(*zip(list_1, list_2))print(c)print(d)
结果：
sorted函数可以对所有的可迭代对象进行排序，返回的是一个新的可迭代对象，而不是在原来的基础上进行操作。
list_1 = ['c', 'b', 'a']print(list_1)print(id(list_1))b = sorted(list_1)print(id(b))print(b)
结果：
['c', 'b', 'a']30442596297043044276555912['a', 'b', 'c']
需注意sort和sorted的区别，sort主要用于列表，而sorted对所有课迭代对象都起作用。
3.7 总结本章介绍了python中的选择结构和循环结构，又介绍了迭代器和生成器，最后介绍了一些python的内置函数。