Python3（控制语句）

Python学习(控制语句)

前面所学习的基本数据类型和序列等，可以看做数据的组织方式，可以说是“砖块”；现在开始学习流程控制语句，这是代码的组织方式，可以看做是“混凝土”。一个完整的程序，离不开“砖块”和“混凝土”，他们的组合，才能让我们建立从小到大“一个方法”，“大到”操作系统，甚至是建立各种各样的软件。

选择结构

选择结构通过判断条件是否成立，来决定执行哪个分支。选择结构有多种形式，分为︰单分支、双分支、多分支。流程图如下︰

单分支结构

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

a = input("请输入一个小于10的数字： ")   #input输入的是一个字符串  我们需要强转成int

if(int(a)<10):
    print(a)

③条件表达式详解

在选择和循环结构中，条件表达式的值为False的情况如下:False、0、0.0、空值None、空序列对象（空列表、空元祖、空集合、空字典、空字符串)、空range 对象、空迭代对象。
其他情况，均为True。这么看来，Python所有的合法表达式都可以看做条件表达式，甚至包括函数调用的表达式。

a =""  #非空的字符串也是：Ture
if not a:
    print(a)

b = []
if not b:
    print("空的列表是false")

c = True
if c:
    print("c");

d = 0
if not d:
    print("数字0是false")

运行效果:

Tip: 条件表达式中，不能有赋值操作符"="

双分支选择结构

s = input("请输入一个数字: ")

if int(s)<10:
    print("s是小于10的数字")
else:
    print("s是大于10的数字")

运行效果：

三元运算符

Python提供了三元运算符，用来在某些简单双分支赋值的情况。三元条件运算符语法格式如下：
  条件为真时的值 if (条件表达式) else（条件为假时的值）

下面是三元运算符的案例代码：

num = input("请输入一个数字：")
print(num if int(num)<10 else ("数字太大"))

多分支结构

多分支结构，几个分支之间室友逻辑关系的，不能随意颠倒顺序，流程图如下：


案例： 输入分数获得学生的分数等级

#这是完整的条件表达
score = int(input("请输入该学生的分数"))
grade = ''
if(score<60):
    grade = "不及格"
if(60<=score<=80):
    grade = "及格"
if(80<=score<90):
    grade = "良好"
if(90<=score<=100):
    grade = "优秀"

print("分数是{0}，分数等级是{1}".format(score,grade))


#下面用多分支结构表达
score = int(input("请输入该学生的分数"))
grade = ""

if score<60:
    grade = "不及格"
elif score<80:     #表达分数为[60,80)
    grade = "良好"
elif score<=100:    #表达分数为[80,100]
    grade = "优秀"

print("分数是{0}，分数等级是{1}".format(score,grade))

多分支结构，几个分支之间是有逻辑关系的，不能随意颠倒顺序

选择结构嵌套

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

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

循环语句

循环结构用来重复执行一条或多条语句。表达这样的逻辑∶如果符合条件，则反复执行循环体里的语句。在每次执行完后都会判断一次条件是否为True，如果为True则重复执行循环体里的语句。图示如下:

循环体里的语句至少应该包含改变条件表达式的语句，以使循环趋于结束；否则，就会变成一个死循环。

while循环

while循环的语法格式如下：

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

我们通过一些简单的练习，来慢慢熟悉while循环。

①利用while循环打印0-10的数字

num = 0;
while num<=10:
    print(num,end="\t")
    num+=1

②计算1-100累加和

num1 = 100;
sum = 0;
while num1>0:
    sum+=num1;
    num1-=1;
print(sum)  #sum = 5050

for循环和可迭代对象

for循环常用于可迭代循环对象的遍历。for循环的语法格式如下：

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

[操作]遍历一个元组或列表

for x in(20,30,20):
    print(x,end="\t")
    
d= {'name':'asa','age':12,"job":'ssss'}
for x in d:  #其实就是相当于是遍历keys
    print(x)
for x in d.keys():
    print(x,end="\t")
for x in d.values():
    print(x,end="\t")

range 对象

range对象是一个迭代器对象，用来产生指定范围的数字序列。格式为：

range(start,end[,step])   #[]代表可以省略

生成的数值序列从start开始到end结束（不包含end）。若没有填写start，则默认为从0开始。step是可选的步长，默认为1如下是几种典型示范：

[操作]求和

sum_all = 0;
sum_odd = 0;
sum_even = 0;
for x in range(101):
    sum_all+=x;
    if(x%2==0):
        sum_odd+=x;
    elif(x%2!=0):
        sum_even+=x;

print(sum_all);
print(sum_odd);
print(sum_even);
print("1-100和：{0}，1-100奇数和：{1}，1-100偶数和：{2}".format(sum_all,sum_odd,sum_even))

嵌套循环

一个循环体内可以嵌入另一个循环，一般称为“嵌套循环”，或者“多重循环”。
[操作] 打印如下图案

a = 0
for x in range(5):
    for s in range(5):
        print(a,end="\t")
    a+=1
    print()

[操作] 打印九九乘法表

for a in range(9):
    for b in range(a+1):
        print("{0}*{1}={2}".format(a+1,b+1,(a+1)*(b+1)),end="\t")
    print()

[操作]用列表和字典存储下表信息，并打印出表中工资高于1500的数据/font>

r1 = dict(name = "aaa",age = 18,salary = 331231)
r2 = dict(name = "bbb",age = 12,salary = 123)
r3 = dict(name = "ccc",age = 13,salary = 344124)
tb = [r1,r2,r3]   #随手写的，表达意思

for x in tb:   
    if x.get("salary")>15000:
        print(x)

break语句

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

[操作]使用break语句结束循环

a = 10
while True:
    b = input("请输入一个字母Y/y，来结束循环：")
    if b.upper()=="Y":
    	print("循环已经退出")
        break;
    else:
        print(a)

continue语句

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

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

num = 0
salary = []
all_salary = 0
while True:
    s = input("请输入员工的薪资：(按Q结束录入)")

    if s.upper()=="Q":
        print("录入已经完成，已经退出了")
        break;
    if int(s)<0:
        continue
    num+=1
    salary.append(int(s))
    all_salary+=int(s)

print("员工数量： {0}".format(num))
print("录入的薪资：{0}".format(salary))
print("平均薪资：{0}".format(all_salary/num))

else语句

while、for循环可以附带一个else语句(可选)。如果for、while语句没有被break语句结束，则会执行else子句，否则不执行。语法格式如下∶

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

或者:

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

如果循环体里的语句被break语句中断，else里的语句是不会执行的，若循环正常的退出，则else里的代码会被执行
[操作]【操作】员工一共4人。录入这4位员工的薪资。全部录入后，打印提示“您已经全部录入4名员工的薪资”。最后，打印输出录入的薪资和平均薪资

salary = []
num = 0
all_salary = 0
for i in range(4):
    s = input("输入员工的薪资：（按下Q退出录入）")

    if s.upper()=="Q":
        print("你已经退出了输入")
        break;
    else:
        num+=1
        salary.append(int(s))
        all_salary+=int(s)
else:
    print("你完成了本次的录入")

print("录入薪资{0}".format(salary))
print("平均薪资{0}".format(all_salary))

循环代码优化

虽然计算机越来越快，空间也越来越大，我们仍然要在性能问题上“斤斤计较”。编写循环
时，遵守下面三个原则可以大大提高运行效率，避免不必要的低效计算∶
1．尽量减少循环内部不必要的计算
2.  嵌套循环中，尽量减少内层循环的计算，尽可能向外提。
3．局部变量查询较快，尽量使用局部变量

其他优化手段

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

使用zip()并行迭代

我们可以通过zip()函数对多个序列进行并行迭代，zip()函数在最短序列"用完"时就会停止。
[操作]测试zip()并行迭代

names = ('aaa','bbb','ccc','ddd')
ages = (12,23,3,13)
jobs = ('teacher','studnet','programmer')

for name,age,job in zip(names,ages,jobs):   #只能迭代三次
    print("{0},{1},{2}".format(name,age,job))

推导式创建序列

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

列表推导式

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

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

>>> a = [x for x in range(1,5)]
>>> print (a)
[1, 2, 3, 4]
>>> b = [x*2 for x in range(1,5)]
>>> print(b)
[2, 4, 6, 8]
>>> c = [a for a in "asdasdada"]
>>> c
['a', 's', 'd', 'a', 's', 'd', 'a', 'd', 'a']
>>> b = [x*2 for x in range(1,10) if(x%2==0)]
>>> b
[4, 8, 12, 16]
>>>cells = [(row,col) for row in range(1,10) for col in range(1,10)]
>>>print(cells)
[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9)]

字典推导式

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

{key_expression_) value_expression ( for表达式in可迭代对象

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

[操作]统计文本中字符出现的次数

>>>my_text = 'i love you,i love sxt, i love yyy'
>>>char_count  = {c:my_text.count(c) for c in my_text}
>>>print(char_count)
{'i': 3, ' ': 7, 'l': 3, 'o': 4, 'v': 3, 'e': 3, 'y': 4, 'u': 1, ',': 2, 's': 1, 'x': 1, 't': 1}

集合推导式

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

{表达式 for item in 可迭代对象}

或者：

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

>>> b = {x for x in range(1,100) if x%9==0}
>>> print(b)
{99, 36, 72, 9, 45, 81, 18, 54, 90, 27, 63}

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

初学者（比如我）都会有一个疑问：都有推导式，元组没有？，能不能用小括号呢？

>>> (x for x in range(1,10) if x&9==0)
<generator object <genexpr> at 0x000001E9E9488D60>

我们发现提示的是一个“生成器对象”。显然，元组是没有推导式的。

一个生成器只能运行一次。第一次迭代可以得到数据，第二次迭代发现数据已经没有了。

gnt = (x for x in range(1,100) if x%9==0)
for x in gnt:
    print(x,end = " ")
# 9 18 27 36 45 54 63 72 81 90 99 
for x in gnt:    #指针已经跳出了   所以是无法继续得到数据的
    print(x,end=" ")
#(输出为空)


>>> gnt = (x for x in range(1,100) if x%6==0)
>>> for c in gnt:
	print(c,end=" ")
6 12 18 24 30 36 42 48 54 60 66 72 78 84 90 96 
>>> print(c)
96
>>> print(gnt)
<generator object <genexpr> at 0x000001E9E93FFB30>
>>> print(tuple(gnt))
()