一、选择结构
简单的 if 语句 示例代码：
# 单分支
age = 10
if age == 0:
print('True')
# 条件表达式
if 0 < age < 10:
print('boy')
# 双分支
if age > 18:
print('young')
else:
print('boy')
# 三元运算符
# 格式: 条件为真时的值 if (条件表达式) else 条件为假时的值
print(age if age > 18 else 'boy')
# 多分支选择结构 样式如下：
# if 条件表达式
# 语句1/语句块1
# elif 条件表达式2:
# 语句2/语句块2
# ...
# elif 条件表达式n:
# 语句n/语句块n
# [ else:
# 语句n+1/语句块n+1 ]
score = 78
grade = ''
if (score < 60):
grade = 'D'
elif (60 <= score < 70):
grade = 'C'
elif (70 <= score <90):
grade = 'B'
elif (90 <= score):
grade = 'A'
else:
grade = 'AAA'
print('grade:' + grade)
# 选择结构嵌套
sex = input('请输入性别（男/女）:')
if '男' == sex or '女' == sex:
if '男' == sex:
print('性别：' + sex)
elif '女' == sex:
print('性别：' + sex)
else:
sex = input('输入有误，请重新输入性别（男/女）')
print('你输入的值：' + sex)
=================运算结果=======================================
boy
boy
grade:B
请输入性别（男/女）:女
性别：女
=================运算结果=======================================
简单的循环结构
循环结构用来重复执行一条或多条语句。表达这样的逻辑：如果符合条件，则反复执行循环体里的语句。
在每次执行完后都会判断一次条件是否为 True，如果为 True 则重复执行循环体里的语句。图示如下：
循环体里面的语句至少应该包含改变条件表达式的语句，以使循环趋于结束；
否 则，就会变成一个死循环。
示例代码
# while 循环
num = 0
sum = 0
while num <= 50:
sum += num
num += 1
print('0 到 50之和sum：' + str(sum))
# for 循环和可迭代对象遍历
for x in range(3):
print('res:' + str(x * 3))
# Python 包含以下几种可迭代对象：
# 1. 序列。包含：字符串、列表、元组
# 2. 字典
# 3. 迭代器对象（iterator）
# 4. 生成器函数（generator）
# 5. 文件对象
# 嵌套循环：一个循环体内可以嵌入另一个循环，一般称为“嵌套循环”，或者“多重循环”。
for x in range(4):
for y in range(3):
print(x, end='\t')
print() # 用于换行
# 打印九九乘法表
for m in range(1, 10):
for n in range(1, m + 1):
print('{0} * {1} = {2}'.format(m, n, m * n), end='\t')
print() # 换行
# break 语句
# break 语句可用于 while 和 for 循环，用来结束整个循环。
# 当有嵌套循环时，break 语句只 能跳出最近一层的循环。
a = int(input('请输入1-20之间的数字：'))
while True:
if a == 100:
print('循环结束，退出！！！')
break
else:
a += 1
# continue 语句
# continue 语句用于结束本次循环，继续下一次。
# 多个循环嵌套时，continue 也是应用于最 近的一层循环。
empNum = 0
salarySum = 0
salarys = []
while True:
money = input('请输入员工的薪资（按Q或去退出）：')
if 'Q' == money.upper():
print('录入完成！！！')
break
if float(money) < 0:
continue
empNum += 1
salarys.append(money)
salarySum += float(money)
print('员工数：{0} 人'.format(empNum))
print('录入薪资：', salarys)
print('平均薪资{0}'.format(salarySum / empNum))
# 循环里的else语句
# while、for 循环可以附带一个 else 语句（可选）。
# 如果 for、while 语句没有被 break 语句 结束，则会执行 else 子句，否则不执行。
# 语法格式如下：
# while 条件表达式：
# 循环体
# else:语句块
# 或者：
# for 变量 in 可迭代对象：
# 循环体
# else:
# 语句块
# 员工一共 4 人。录入这 4 位员工的薪资。
# 全部录入后，打印提示“您已经全部录 入 4 名员工的薪资”。
# 最后，打印输出录入的薪资和平均薪资
salarySum = 0
salarys = []
for i in range(4):
money = input('请输入一共 4 名员工的薪资（按 Q 或 q 中途结束）:')
if 'Q' == money.upper():
print('录入完成，退出！！！')
break
if float(money) < 0:
continue
salarys.append(float(money))
salarySum += float(money)
else:
print("您已经全部录入 4 名员工的薪资")
print('录入薪资：', salarys)
print('平均薪资{0}'.format(salarySum / 4))
===================运行结果==============================
0 到 50之和sum：1275
res:0
res:3
res:6
0 0 0
1 1 1
2 2 2
3 3 3
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
请输入1-20之间的数字：11
循环结束，退出！！！
请输入员工的薪资（按Q或去退出）：12343.44
请输入员工的薪资（按Q或去退出）：23452.55
请输入员工的薪资（按Q或去退出）：452522.32
请输入员工的薪资（按Q或去退出）：54632.55
请输入员工的薪资（按Q或去退出）：Q
录入完成！！！
员工数：4 人
录入薪资： ['12343.44', '23452.55', '452522.32', '54632.55']
平均薪资135737.715
请输入一共 4 名员工的薪资（按 Q 或 q 中途结束）:23432.55
请输入一共 4 名员工的薪资（按 Q 或 q 中途结束）:35453.66
请输入一共 4 名员工的薪资（按 Q 或 q 中途结束）:34353.74
请输入一共 4 名员工的薪资（按 Q 或 q 中途结束）:56436.90
您已经全部录入 4 名员工的薪资
录入薪资： [23432.55, 35453.66, 34353.74, 56436.9]
平均薪资37419.2125
===================运行结果==============================
循环代码优化
虽然计算机越来越快，空间也越来越大，我们仍然要在性能问题上“斤斤计较”。
编写循环时，遵守下面三个原则可以大大提高运行效率，避免不必要的低效计算：
1. 尽量减少循环内部不必要的计算
2. 嵌套循环中，尽量减少内层循环的计算，尽可能向外提。
3. 局部变量查询较快，尽量使用局部变量
******其他优化手段******
4. 连接多个字符串，使用 join()而不使用+
5. 列表进行元素插入和删除，尽量在列表尾部操作
使用 zip()并行迭代
我们可以通过 zip()函数对多个序列进行并行迭代，zip()函数在最短序列“用完”时就会停止。
names = ("jack","marry","tony","rose")
ages = (18,16,20,25)
jobs = ("老师","IT","公务员")
for name, age, job in zip(names,ages,jobs):
print('{0} - {1} - {2}'.format(name, age, job))
===================运行结果==============================
jack - 18 - 老师
marry - 16 - IT
tony - 20 - 公务员
===================运行结果==============================
# 很明显zip()函数在最短序列“用完”时就会停止
推导式创建序列
推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合， 从而避免
冗长的代码。推导式是典型的 Python 风格，会使用它代表你已经超过 Python 初 学者的水平。
列表推导式
列表推导式生成列表对象，语法如下：
[表达式 for item in 可迭代对象 ] 或者：
{表达式 for item in 可迭代对象 if 条件判断}
>>> [x for x in range(1,5)]
[1, 2, 3, 4]
>>> [x*2 for x in range(1,5)]
[2, 4, 6, 8]
>>> [x*2 for x in range(1,20) if x%5==0 ]
[10, 20, 30]
>>> [a for a in "abcdefg"]
['a', 'b', 'c', 'd', 'e', 'f', 'g']
字典推导式
字典的推导式生成字典对象，格式如下：
{key_expression : value_expression for 表达式 in 可迭代对象}
类似于列表推导式，字典推导也可以增加 if 条件判断、多个 for 循环。
# 统计文本中字符出现的次数：
>>> text = 'you are very beautiful，i love you！'
>>> char_count = {c:text.count(c) for c in text}
>>> char_count
{'y': 3, 'o': 3, 'u': 4, ' ': 5, 'a': 2, 'r': 2, 'e': 4,
'v': 2, 'b': 1, 't': 1, 'i': 2, 'f': 1, 'l': 2, '，': 1, '！': 1}
集合推导式
集合推导式生成集合，和列表推导式的语法格式类似：
{表达式 for item in 可迭代对象 } 或者：
{表达式 for item in 可迭代对象 if 条件判断}
>>> {x for x in range(1,100) if x%9==0}
{99, 36, 72, 9, 45, 81, 18, 54, 90, 27, 63}
生成器推导式（生成元组）
# 元组推导式有没有呢？接下来就测试
>>> (x for x in range(1,100) if x%9==0)
<generator object <genexpr> at 0x00000265AE0DD9E8>
# 我们发现提示的是“一个生成器对象”。显然，元组是没有推导式的。
# 一个生成器只能运行一次。第一次迭代可以得到数据，第二次迭代发现数据已经没有了。
res = (x for x in range(1,100) if x%9==0)
print(type(res))
for x in res:
print(x, end=' ')
print('\n==========')
for x in res:
print(x, end='end')
print('==========')
===================运行结果==============================
<class 'generator'>
9 18 27 36 45 54 63 72 81 90 99
==========
==========
===================运行结果==============================
# 很明显第二个for循环没有输出，所以一个生成器只能运行一次。
学习来自：北京尚学堂高琪老师 Python 400集
