Python之控制语句基础

单分支选择结构

if 语句单分支结构的语法形式如下：
if 条件表达式:
语句/语句块
其中：
1 ．条件表达式：可以是逻辑表达式、关系表达式、算术表达式等等。
2 ．语句/语句块：可以是一条语句，也可以是多条语句。多条语句，缩进必须对齐一致

操作】输入一个数字，小于 10，则打印这个数字(if_test01.py)

条件表达式中，不能有赋值操作符“=”
在 Python 中，条件表达式不能出现赋值操作符“=”，避免了其他语言中经常误将关系运算符“==”写作赋值运算符“=”带来的困扰。如下代码将会报语法错误：
if 3<c and (c=20):
print("赋值符不能出现在条件表达式中")

三元条件运算符

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

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

多分支选择结构

结果：

选择结构可以嵌套，使用时一定要注意控制好不同级别代码块的缩进量，因为缩进量决定了代码的从属关系。语法格式如下：

【操作】输入一个分数。分数在 0-100 之间。90 以上是 A,80 以上是 B，70 以上是 C，60》以上是 D。60 以下是 E

range 对象

range 对象是一个迭代器对象，用来产生指定范围的数字序列。格式为：range(start, end [,step])生成的数值序列从 start 开始到 end 结束（不包含 end）。若没有填写 start，则默认从 0开始。step 是可选的步长，默认为 1。如下是几种典型示例：
for i in range(10) 产生序列：0 1 2 3 4 5 6 7 8 9
for i in range(3,10) 产生序列：3 4 5 6 7 8 9
for i in range(3,10,2) 产生序列：3 5 7 9

【操作】利用 for 循环，计算 1-100 之间数字的累加和；计算 1-100 之间偶数的累加和，计算 1-100 之间奇数的累加和

sum_all = 0
sum_odd = 0
sum_even = 0
for i in range(101):
    sum_all = sum_all+i
    if i%2 == 0:
        sum_even = sum_even + i
    else:
        sum_odd = sum_odd + i
print('输入的总数是{0}，偶数总和是{1},奇数总和是{2}'.format(sum_all,sum_even,sum_odd))

嵌套循环和综合练习

 

for x in range(5):
    for y in range(5):
        # 当x=0的时候，y=0,1,2,3,4，但是输入的是x，始终为0
        print(x,end='\t')
    # 当y内循环完毕后，换行继续x循环
    print('\n')

结果：

【操作】利用嵌套循环打印九九乘法表

# 九九乘法表
for m in range(1,10):
    # n 是m+1中循环
    for n in range(1,m+1):
        print('{0}*{1}={2}'.format(m,n,m*n),end='\t')
    print('\n')

结果：

【操作】用列表和字典存储下表信息，并打印出表中工资高于 15000 的数据

姓名	年龄	薪资	城市
高小一	18	30000	北京
高小二	19	20000	上海
高小五	20	10000	深圳

# 打印表格，且薪资大于15000的
r1 = {'name':'fan','age': 18, 'salar':30000, 'city':'北京'}
r2 = {'name':'tao','age': 19, 'salar':20000, 'city':'上海'}
r3 = {'name':'lang','age': 30, 'salar':10000, 'city':'深圳'}
tab = [r1, r2, r3]

for x in tab:
    if x.get('salar')>=15000:
        print(x)

结果：

break 语句

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

【操作】使用 break 语句结束循环

# 测试break语句
while True:
    a = input('请输入一个字符（输入 Q 或 q 结束）：')
    if a == 'Q' or a == 'q':
        break
    else:
        print('请输出a')

continue 语句

continue 语句用于结束本次循环，继续下一次。多个循环嵌套时，continue 也是应用于最近的一层循环

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

empNum = 0
salars = []
salarSum = 0
while True:
    a = input('请输入员工的工资：')
    if a == 'Q' or a == 'q':
        print('录入完成，请退出')
        break
    if float(a) < 0:
        print('输入工资不合法，请重新输入')
        continue
    empNum = empNum + 1
    salars.append(float(a))
    salarSum = salarSum + float(a)
print('员工数{0}'.format(empNum))
print('录入薪资：', salars)
print('平均薪资{0}'.format(salarSum/empNum))

【操作】员工一共 4 人。录入这 4 位员工的薪资。全部录入后，打印提示“您已经全部录入 4 名员工的薪资”。最后，打印输出录入的薪资和平均薪资

salaries = []
empNum = 0
salarySum = 0
for i in range(4):
    a = input('请输入工资（输入Q或者q时输入结束）:')
    if a =='Q' or a == 'q':
        break
    if float(a) < 0:
        continue
    empNum += 1
    salaries.append(float(a))
    salarySum += float(a)
print('员工数{0}'.format(empNum))
print('录入薪资：', salaries)
print('平均薪资{0}'.format(salarySum/empNum))

循环代码优化

编写循环时，遵守下面三个原则可以大大提高运行效率，避免不必要的低效计算：
1. 尽量减少循环内部不必要的计算
2. 嵌套循环中，尽量减少内层循环的计算，尽可能向外提。
3. 局部变量查询较快，尽量使用局部变量

# 循环代码优化测试
import time
start = time.time()
for m in range(1000):
    result = []
    for n in range(1000):
        result.append(m*1000+n*1000)
end = time.time()
print('耗时：{0}'.format(end-start))

start2 = time.time()
for x in range(1000):
    result = []
    s = x*1000
    for y in range(1000):
        result.append(s + y*1000)
end2 = time.time()
print('耗时：{0}'.format(end2-start2))

其他优化手段

推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合，从而避免冗长的代码。推导式是典型的 Python 风格，会使用它代表你已经超过 Python 初学者的水平

列表推导式

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

                                      [表达式 for item in 可迭代对象 ]
                      或者：{表达式 for item in 可迭代对象 if 条件判断}

# 切片，包头不包尾
a = [x*2 for x in range(1,5)]
print(a)

s = [x*2 for x in range(1,20) if x%5 == 0]
print(s)

s = [x for x in 'abcdef']
print(s)
# 可以使用两个循环
lisA = [(x,y) for x in range(1,10) for y in range(1,5)]
print(lisA)
print('********************************************************')

for x in lisA:
    print(x)

字典推导式

字典的推导式生成字典对象，格式如下：

                          {key_expression : value_expression for 表达式 in 可迭代对象}

类似于列表推导式，字典推导也可以增加 if 条件判断、多个 for 循环

# 统计文本中字符出现的次数：
my_text = ' i love you, i love sxt, i love Fan'
char_count = {c:my_text.count(c) for c in my_text}
print(char_count)

集合推导式

集合推导式生成集合，和列表推导式的语法格式类似：

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

a = {x*2 for x in range(1,100) if x%9==0}
print(a)

【操作】绘制多个同心圆

# 绘制多个同心圆
import turtle
t = turtle.Pen()
t.width(5)
myColors = ("red","green","yellow","black")
for i in range(10):
    # 抬笔
    t.penup()
    t.goto(0,-i*15)
    # 下笔
    t.pendown()
    # 把颜色传入进去
    t.color(myColors[i%len(myColors)])
    t.circle((i+1)*15)
#####################################################
# # 思考步骤
# t.circle(100)
# # 抬笔
# t.penup()
# t.goto(0,-100)
# # 下笔
# t.pendown()
# t.circle(200)
#
# t.penup()
# t.goto(0,-200)
# t.pendown()
# t.circle(300)
#
# t.penup()
# t.goto(0,-300)
# t.pendown()
# t.circle(400)