零基础小白的Python学习之路（四）控制语句：选择、循环、推导式

参考资料：《Python编程 从入门到实战》+ 尚学堂Python400集

控制语句

• 选择结构
  -单分支
  -双分支
  -多分支
  -选择结构嵌套
• 循环结构
  -while循环
  -for循环
  -嵌套循环
  -break语句
  -continue语句
  -else语句

选择结构

通过判断哪个条件是否成立来决定执行程序的哪个分支
分为单分支、双分支、多分支

单分支

if语句单分支基本语法格式：

if 条件表达式：
 语句 / 语句块

【注】
（1）条件表达式：逻辑、关系、算术表达式均可
（2）语句 / 语句块：可以一条 / 多条，多条时缩进必须对齐一致

num = input("输入一个数字:")
if int(num)<10:
    print(num)

条件表达式详解

对于选择结构，我们在编程中要十分清楚的就是什么情况下条件表达式的值为真，什么情况下为假，这样才能更好的进行后续的复杂操作

在选择和循环结构中，条件表达式的值为False的情况如下：

• False
• 0
• 0.0
• 空值None
• 空序列对象（如，空列表 / 元组 / 集合 / 字典 / 字符串）
• 空range对象
• 空迭代对象

其他情况均为True

【注】条件表达式中不能有“=”出现，会报错

双分支

if-else语句双分支基本语法格式：

if 条件表达式：
 语句1 / 语句块1
else：
 语句2 / 语句块2

如：

a = input("Input a number:")
if int(a)<10:
    print(a)
else:
    print("It's too big")

三元条件运算符

Python提供了三元运算符，用来在某些简单双分支赋值情况
基本语法格式：

条件为真时的值 if (条件表达式) else 条件为假时的值

如：

a = input("Input a number:")
print(a if int(a)<10 else "It's too big")

多分支

if-elif-else语句多分支基本语法格式：

if 条件表达式1：
 语句1 / 语句块1
elif 条件表达式2：
 语句2 / 语句块2
… …
elif 条件表达式n：
 语句n / 语句块n
[else：
 语句n+1 / 语句块n+1
]

【注1】[ ]中语句可选
【注2】多分支结构，几个分支之间有逻辑关系，不能随意颠倒顺序（如果条件范围各自独立可以颠倒顺序）

【例1】

score = int(input("Input score:"))
grade = ""

if score < 60:
    grade = "不及格"
elif 60 <= score < 80:
    grade = "及格"
elif 80 <= score < 90:
    grade = "良好"
else:
    grade = "优秀"

print("Score = {0} , Grade = {1}".format(score,grade))

【例2】

# 输入点坐标，判断在第几象限
x = float(input("Input point x:"))
y = float(input("Input point y:"))

location = ""
if x == 0 and y == 0:
    location = "原点"
elif x == 0:
    location = "y轴"
elif y == 0:
    location = "x轴"
elif x > 0 and y > 0:
    location = "第一象限"
elif x < 0 and y > 0:
    location = "第二象限"
elif x < 0 and y < 0:
    location = "第三象限"
else:
    location = "第四象限"

print("点({0},{1})在{2}".format(x,y,location))

选择结构嵌套

在Python中，选择结构的嵌套在使用是一定注意要控制好不同级别代码块的缩进量，缩进量决定了代码的从属关系
基本语法格式：

if 表达式1：
 语句块1
 if 表达式2：
  语句块2
 else：
  语句块3
else：
 if 表达式4：
  语句块4

【例】还是分数判断，学while循环后有待改进

s = float(input("Input score:"))
grade = ""

if s > 100 or s < 0:
    print("Out of range ! Please Input again!(0~100)")
    s = float(input("Input score:"))
else:
    if s >= 90:
        grade = "A"
    elif s >= 80:
        grade = "B"
    elif s >= 70:
        grade = "C"
    elif s >= 60:
        grade = "D"
    else:
        grade = "E"
    print("Score = {0},Grade = {1}".format(s,grade))

【另方法】

s = float(input("Input score:"))
degree = "ABCDE"
num = 0

if s > 100 or s < 0:
    print("Please input again(0~100)")
else:
    num = int(s) // 10
    if num < 6:
        num = 5
    print("Score = {0},Grade = {1}".format(s,degree[9-num]))

【注】这里将得到的分数取出其十位数字（9，8，7，6…）对应不同等级
9——>A
8——>B
7——>C
6——>D
5及5以下——.>5——>E

循环结构

循环结构用来重复执行一条或多条语句。
如果条件符合，则反复执行循环体中的语句。
在每次执行完之后都会判断一次条件是否为True，如果为True则重复执行循环体里的语句。

while循环

while循环基本语法格式：

while 条件表达式：
 循环体语句

【例1】循环打印0~10

# 循环打印0~10
num = 0
while num <= 10:
    print(num,end = ' ')
    num += 1 # 结束条件判断，使之不会成为一个死循环

【例2】1~100求和

# 1~100求和
s = 0
num = 1
while num <= 100:
    s += num
    num += 1
print("1 ~ 100 Sum = {0}".format(s))

for循环

for循环通常用于可迭代对象的遍历
for循环基本语法格式：

for 变量 in 可迭代对象：
 循环体语句

【例】遍历一个元组 / 字符串 / 字典等

# 遍历元组
for x in (2,3,4):
    print(x**3,end = ' ')
print()

# 遍历字符串
for x in "gfdgyu":
    print("{0}-{1}".format(x,ord(x)),end = ' ')
print()

# 遍历字典
d = {'name':'Stefan','age':24,'address':'New York'}
# 遍历字典所有的keys
for x in d:
    print(x,end = ' ')
print()
# 遍历字典所有的keys
for x in d.keys():
    print(x,end = ' ')
print()
# 遍历字典所有的值
for x in d.values():
    print(x,end = ' ')
print()
# 遍历字典所有的键值对
for x in d.items():
    print(x,end = ' ')
print()

可迭代对象

Python中包含以下几种可迭代对象：

1. 序列（字符串、列表、元组）
2. 字典
3. 迭代器对象（iterator）
4. 生成器函数（generator）
5. 文件对象

range对象

range对象是一个迭代器对象，用来产生指定范围的数字序列
基本格式：
range(start , end [,step])

• start：起始数值，默认为0
• end：结束数值（不包括end，包头不包尾）
• step：可选，步长，默认为1

【例1】

# range对象
for i in range(10):
    print(i,end = ' ')
print()
for i in range(3,10):
    print(i,end = ' ')
print()
for i in range(3,10,2):
    print(i,end = ' ')
print()

【例2】for循环 计算1~100之间数字累加和、偶数累加和、奇数累加和

# for循环 计算1~100之间数字累加和、偶数累加和、奇数累加和
s = 0
s_even = 0 # 偶数
s_odd = 0 # 奇数
for n in range(101):
    s += n
    if n % 2 == 0:
        s_even += n
    else:
        s_odd += n
print("1~100所有数累加和:",s)
print("1~100所有偶数累加和:",s_even)
print("1~100所有奇数累加和:",s_odd)

嵌套循环

【例1】打印

for i in range(5):
    for j in range(5):
        print(i,end = '\t')
    print()

【例2】打印99乘法表

for i in range(1,10):
    for j in range(1,i+1):
        print("{0}×{1}={2}".format(i,j,i*j),end = '\t')
    print()

【例3】打印表格数据

# 打印表格数据
r1 = {'name':'李飞','age':18,'salary':30000,'city':'北京'}
r2 = {'name':'王刚','age':19,'salary':20000,'city':'上海'}
r3 = {'name':'李白','age':20,'salary':10000,'city':'深圳'}

tb = [r1,r2,r3]

# 获得第二行人的薪资
print(tb[1].get('salary'))

# 打印表中所有薪资
for i in range(len(tb)):
    print(tb[i].get('salary'))

# 打印工资高于15000的人的数据
for i in tb:
    if i.get("salary") > 15000:
        print(i)

# 打印表中所有数据
for i in range(len(tb)):
    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('salary'),tb[i].get('city'))

break语句

break语句用于while和for循环中，用来结束整个循环。
当有嵌套循环时，break语句只能跳出最近一层的循环

【例1】

while True:
    a = input("Input a str:(输入Q或q结束)")
    if a.upper() == 'Q':
        print("循环结束，退出")
        break
    else:
        print(a)

【例2】判断素数

# 判断素数
num = int(input("Input a number:"))
flag = True
for n in range(2,num):
    if num % n == 0:
        flag = False
        break
if flag == True:
    print("{0}是素数".format(num))
else:
    print("{0}不是素数".format(num))

【例3】输出100以内所有素数

# 输出100以内所有素数
num = 2
while num <= 100:
    flag = 1
    for n in range(2,num):
        if num % n == 0:
            flag = 0
            break
    if flag == 1:
        print(num,end = '\t')
    num += 1

continue语句

continue语句用于结束本次循环，但是下一次循环还会继续执行。
多个循环嵌套时，同样应用于最近的一层循环

【例】输入员工薪资，若薪资小于0则重新输入，最后打印出录入员工的数量和薪资明细，以及平均工资

num = 0
sum_s = 0
salary = []
while True:
    s = input("Input salary:(按Q或q结束)")
    if s.upper() == 'Q':
        print("录入完成--退出")
        break
    if int(s) < 0:
        continue # 小于0视为无效数据，跳过本次循环
    num += 1
    salary.append(int(s))
    sum_s += int(s)
print()
print("员工数：",num)
print("---薪资明细---")
for i in range(len(salary)):
    print("{0}号员工--薪资：{1}".format(i+1,salary[i]))
print("平均薪资：",sum_s / num)

else语句

while、for循环可以附带一个else语句（可选），如果for、while语句没有被break语句结束，则会执行else语句，否则不执行
基本语法格式：

while 条件表达式：
 循环体
else：
 语句块

或者：
for 变量 in 可迭代对象：
 循环体
else：
 语句块

【例】录入4位员工的薪资，全部录入后，打印提示“您已全部录入”，最后，打印输出录入的薪资和平均薪资

sum_s = 0
salary = []
for i in range(4):
    s = input("Input 4 members' salary:(按Q或q结束)")
    if s.upper() == 'Q':
        print("录入完成--退出")
        break
    if int(s) < 0:
        continue
    salary.append(int(s))
    sum_s += int(s)
else:
    print("您已全部录入员工信息！")
print()
print("---薪资明细---")
for i in range(len(salary)):
    print("{0}号员工--薪资：{1}".format(i+1,salary[i]))
print("平均薪资：",sum_s / 4)

【注】与上一个例子不同的是，上一个员工录入是没有限制录入多少个的，只能通过输入Q或q来结束录入；而本例对员工的录入数量有了限制，只要for循环中的break语句没有被执行（即没有输入Q或q来使录入提前结束），那么则会一直将4位员工全部录入完毕，跳转到else语句处执行打印提示，否则提前结束录入不会有打印提示

循环代码优化技巧（※）

编写循环时，遵守下面三个原则可以大大提高程序的运行效率，避免不必要的低效计算：

1. 尽量减少循环内部不必要的计算
2. 嵌套循环中，尽量减少内层循环的计算（越内层越频繁），尽可能向外提
3. 局部变量查询较快，尽量使用局部变量

【测试】

import time

start1 = time.time()
for i in range(1000):
    result = []
    for j in range(10000):
        result.append(i * 1000 + j * 100)
end1 = time.time()
print("耗时：{0}".format(end1-start1))

start2 = time.time()
for i in range(1000):
    result = []
    c = i*1000 # 把内层的内部循环拿到内循环外层
    for j in range(10000):
        result.append(c + j * 100)
end2 = time.time()
print("耗时：{0}".format(end2-start2))

【其他优化手段小结】

1. 连接多个字符串，用join()方法而不使用拼接符“+”
2. 列表进行元素插入和删除，尽量在列表尾部操作

使用zip()方法并行迭代

我们可以通过zip()方法对多个序列进行并行迭代
zip()函数在最短序列“用完”时就会停止

【例】

# 测试并行迭代 同时遍历多个序列
name_tuple = ("王强","李飞","张三","罗西")
age_tuple = (25,40,18,23)
job_tuple = ("老师","校长","程序员") # 取决于最短序列
# 使用zip()
print("----使用zip()----")
for name,age,job in zip(name_tuple,age_tuple,job_tuple):
    print("{0}--{1}--{2}".format(name,age,job))
print()

# 不使用zip() 传统方式
print("----不使用zip()----")
for i in range(3):
    print("{0}--{1}--{2}".format(name_tuple[i], age_tuple[i], job_tuple[i]))
print()

推导式（※）

推导式创建序列

推导式是从一个或者多个迭代器快速创建序列的一种方法。
可以将循环和条件判断结合，从而避免冗长的代码。
推导式是典型的Python风格。

列表推导式

列表推导式生成列表对象，基本语法如下：

[表达式 for 变量 in 可迭代对象]
或者
[表达式 for 变量 in 可迭代对象 if 条件判断]

【例】

# 测试推导式

# 列表推导式
y = [x**2 for x in range(2,20)]
print(y)
# for循环
y = []
for x in range(2,20):
    y.append(x**2)
print(y)
# 条件过滤
y = [x**2 for x in range(2,20) if x%2 == 0]
print(y)
# 两层推导
cells = [(row,col) for row in range(1,10) for col in range(1,10) if row + col == 10]
print(cells)

字典推导式

基本格式：

{键表达式：值表达式 for 表达式 in 可迭代对象}

也可增加if判断、for循环

【例】统计字符串中各字符出现次数

# 字典推导式
my_text = 'It is my book.'
char_count = {c:my_text.count(c) for c in my_text}
print(char_count.keys())
print(char_count.values())
print(char_count.items())

普通循环实现上例字符统计（有些问题）

my_text = 'It is my book.'
for c in my_text:
    print("{0}--{1}".format(c,my_text.count(c)))

集合推导式

基本语法：

{表达式 for 变量 in 可迭代对象}
或者
{表达式 for 变量 in 可迭代对象 if 条件判断}

与列表类似

# 集合推导式 注意集合里面是无序的，且会去重复
a = {x for x in range(1,100) if x % 9 == 0}
print(a)

生成器推导式（生成元组）

注意元组如果用小括号形式，返回的并不是一个元组的这样的序列，而是一个“生成器对象”，显然，元组没有推导式

# 元组
a = (x for x in range(1,100) if x % 9 == 0)
print(a)

【注】一个生成器只能运行一次，第一次迭代可以得到数据，第二次迭代数据就已经没有了

# 生成元组
a = (x for x in range(4))
print(tuple(a))
print(tuple(a)) # 第二次就没了

# 循环
for x in a: # a是生成器对象，生成器是可迭代的对象
    print(x,end = "\t")
print(tuple(a))

【综合小练习】

绘制不同颜色同心圆

【第一步先画几个试试找规律】

import turtle

t = turtle.Pen()
t.goto(0,0)
t.circle(50)

t.goto(0,-50)
t.circle(100)

t.goto(0,-100)
t.circle(150)

turtle.done() # 程序执行完，窗口依然在，便于分析

【用while循环实现】

import turtle

t = turtle.Pen()
i = 0
y = 0
r = 50
while i < 5:
    t.penup() # 抬笔
    t.goto(0,y)
    t.pendown() # 落笔
    t.circle(r)
    y -= 50
    r += 50
    i += 1

turtle.done() # 程序执行完，窗口依然在，便于分析

【上颜色，通过元组存颜色】

import turtle

t = turtle.Pen()
i = 0
y = 0
r = 20
my_color = ("red","yellow","blue","pink","green")
t.width(4) # 控制线条宽度
t.speed(10) # 控制线条画图速度
while i < 10:
    t.penup()
    t.goto(0,y)
    t.pendown()
    t.color(my_color[i % len(my_color)]) # 循环上色
    t.circle(r)
    y -= 20
    r += 20
    i += 1

turtle.done() # 程序执行完，窗口依然在，便于分析

【用for循环】

import turtle

t = turtle.Pen()
my_color = ("red","yellow","blue","pink","green")
t.width(4)
t.speed(10)
for i in range(10):
    t.penup()
    t.goto(0,-i * 10)
    t.pendown()
    t.color(my_color[i % len(my_color)])
    t.circle(15 + i * 10)

turtle.done() # 程序执行完，窗口依然在，便于分析

画棋盘