孤傲小二~阿沐

Python的学习心得和知识总结（四）|Python控制语句（选择结构、循环结构）

2020年4月12日11:43:23
前面我们已经把Python的基础：Python的组织格式、内置类型和Python序列过了一遍。对于学习任意一门语言，这些基础虽然简单但是都需要牢固掌握。

控制语句

选择结构

单分支
多分支
选择结构的嵌套

循环结构

while循环
for循环
嵌套循环
break & continue语句
else语句
循环的代码优化
zip()的并行迭代

推导式创建序列

列表推导式
字典推导式
集合推导式
生成器推导式

今天我们学习的内容是 Python控制语句。

注：我这里的Python IDE是VS2019，简单的交互是使用的自带IDLE。我之前也说了，任何一款IDE 都是可以的。（不重要，不影响各位学习Python）。我舍友给我的推荐（主流的开发环境是PyCharm）下载 PyCharm的官网，PyCharm的安装我就不细谈了。安装完成之后，当然开发环境是全英文的，pycharm（windows）安装及其设置中文菜单。这位老哥的博客就是设置成中文的环境。如下：

或者各位也可以稍微修缮一下自己的PyCharm，如下：

注：这些不重要，重要的是学习和掌握Python！（看起来真的不如VS2019好用一些！）

选择结构

选择结构是通过判断条件是否成立来决定进行哪个分支的操作。选择结构主要分为：单分支、双分支和多分支。 这都很简单，我们就不细说了。

单分支

下面看一下单分支选择结构的语法格式：

if 条件表达式：
----语句or语句块
注：上面指的是保持Python的缩进
双分支那就是加上 else模块

Python的这个形式和C还是极其相似的，条件表达式：逻辑表达式、关系表达式和算数表达式等（其实大多数的合法表达式都是可以作为条件表达式的 ）。下面的执行模块要 必须保持正确格式的缩进，来组织代码逻辑。

OK，下面来小结一下，为False的情形如下：

False
0、0.0
空值（NONE）
空的序列对象（空的列表、元组、集合、字典和字符串）
空range对象、空迭代对象

这个太简单了，我们就不一一展示了！

注：同Ｃ一样，也是要避免　＝＝和＝　的误用，赋值运算符还是不要出现在条件表达式中。若是使用了，则直接报错：语法错误。

这里也只有是：＝＝的时候，才可以通过。

下面来看一下在使用上面，更加方便好用的　三元条件运算符：如下

# 功能：输入一个数字,进行判断
number=input("请你输入一个数字：")
if int(number)<10:
    print("你输入的数字小于10")
elif 10<=int(number)<30:
    print("你输入的数字小于30,但大于等于10")

if (20<=int(number)) and (int(number)==21):
    print("你输入的数字是 21")

character=1
if (int(number)==21):
    character+=1

print("number =",end=' ')
print(number)

print("character =",end=' ')
print(character)

# 下面测试一下 三元条件运算符
print(character if int(number)==23 else character+1)

如上图所示：这个三元条件运算符 在某些情形下，可以代替简单的双分支赋值情况。
上面的例子中：两个绿框分别为

前面指的是：条件为真时候的值
后面指的是：条件为假时候的值

多分支

上面我已经展示了一个多分支结构：
下面看一下多分支选择结构的语法格式：

if 条件表达式1：
----语句or语句块
elif 条件表达式2：
----语句or语句块
······
······
else：
----语句or语句块
注：else要是写上的话，后面的冒号：不可少；不写else部分也可以

实例如下：

# 功能：使用多分支结构

while True:
    score=int(input("请你输入分数:"))
    descr=""
    if(score==-1):
        break
    if score<60:
        descr="不及格"
    elif 60<= score <80:
        descr="良好"
    elif 80<=score <100:
        descr="优秀"
    else: descr="学习这么好，妈妈知道吗？"
    
    print("成绩为{0},评语为{1}".format(score,descr))

选择结构的嵌套

选择结构是可以嵌套的，这些都比较简单。只不过需要注意的一点在于：不同级别的代码的缩进问题，毕竟缩进量决定了代码的从属层级。下面我们改造一下上面的代码，完成选择结构的嵌套：

# 功能：使用多分支结构和多层嵌套

while True:
    score=int(input("请你输入分数:"))
    descr=""
    if(score==-1):
        break
    if(score>100):
        print("请输入一个合法的分数，例如：0-100")
    else:
        if score<60:
            descr="不及格"
        elif 60<= score <80:
            descr="良好"
        elif 80<=score <100:
            descr="优秀"
        else: descr="学习这么好，妈妈知道吗？"
        
        print("成绩为{0},评语为{1}".format(score,descr))

当然也可以如下书写代码（我们这里的分数划分太宽泛，否则代码可以更加精简）：

# 功能：使用多分支结构和多层嵌套

while True:
    score=int(input("请你输入分数:"))
    descr=["学习这么好，妈妈知道吗？","优秀","良好","不及格"]
    if(score==-1):
        break
    if(score>100):
        print("请输入一个合法的分数，例如：0-100")
    else:
        index=score//10
        if(index<6):
            index=7
        elif (6<=index<8):
            index=8
        elif (8<=index<10):
            index=9
        print("成绩为{0},评语为{1}".format(score,descr[10-index]))

循环结构

注：大家细看上面的程序，那里其实我已经使用了while循环。

循环结构：用来重复多次执行一条 or 一块代码逻辑。使用的时候：若是满足循环条件，则反复执行循环体里面的语句。（每次执行完成之后，就会去判断一下条件是否还满足）

循环体里面应该有 改变条件表达式的语句，使得循环趋向于结束（即：破坏掉循环的条件，使循环结束）。否则会变成一个死循环（死循环也没有什么大不了的）。

while循环

上面的例子就是一个简单的while循环，其语法格式如下：

while 条件表达式：
----循环体（一条 or 一块）

下面看几个实例：

# 计算前100的累加和
sum=0
n=1
while n<=100:
    sum+=n
    n+=1

print("************")
print("sum = ",sum)
print("************")

for循环

相比之下，我们用的最多的还是for循环。for循环的语法格式如下：

for 变量 in 可迭代的对象：
----循环体（一条 or 一块）

下面使用一下 for循环来做一下上面的例子：

# 计算前100的累加和
sum=0
n=1
while n<=100:
    sum+=n
    n+=1

print("************")
print("sum = ",sum)
print("************")

sum=0
for i in range(101):
    sum+=i
print("************")
print("sum = ",sum)
print("************")

上面说到的这个可迭代对象，主要是：

序列：字符串、列表和元组
字典（默认是只得到键；可以借助于d.keys()或者d.values()、d.items()来指定部分）
迭代器对象（iterator）
生成器函数（generator）

我们之前也讲过range 对象，它是一个迭代器对象，用来产生指定范围的数字序列。其格式为：

range(start,end,step)
生成的序列是从start开始，到end结束（包头不包尾）。若是没有填start，则默认从0开始；step是步长

# 计算前100的累加和,奇数和，偶数和
sum=0
sum_1=0
sum_2=0
for i in range(101):
    sum+=i
    if i%2==0:
        sum_1+=i
    else: sum_2+=i

print("前100的累加和{0},奇数和{1}，偶数和{2}".format(sum,sum_1,sum_2))

嵌套循环

嵌套循环：也称作多重循环。指的是：一个循环体里面可以嵌入另一个循环。下面我们就利用嵌套循环来完成九九乘法表：

上面是我在学习Shell的时候，写的一个乘法口诀表。下面是Python实现版本：

# 乘法口诀表
for i in range(1,10):
    for j in range(1,10):
        if i<=j:
            result=i*j
            if result<10:
                print('{0}*{1}={2}'.format(i,j,result),end='   ')
            else:print('{0}*{1}={2}'.format(i,j,result),end='  ')
    print()

上面我的i j制约是用了一个if 判断，当然也可以直接下面：（这样更简洁，更高效）

# 乘法口诀表
for i in range(1,10):
    for j in range(1,i+1):
        result=i*j
        if result<10:
            print('{0}*{1}={2}'.format(i,j,result),end='   ')
        else:print('{0}*{1}={2}'.format(i,j,result),end='  ')
    print()

下面使用for循环来操作一下表格数据，如下：

# 使用字典对象来表示一行数据
r1={'name':'一','Chinese':90,'math':95,'score':185}
r2={'name':'二','Chinese':85,'math':92,'score':177}
r3={'name':'三','Chinese':86,'math':95,'score':181}
r4={'name':'四','Chinese':92,'math':90,'score':182}

# 下面把整个表格组织起来
form=[r1,r2,r3,r4]

# 下面我想知道阿三的语文考了多少分
print(form[2].get('Chinese'))
print('---------------------------------')

# 下面遍历所有人的总成绩
for i in range(len(form)):
    print(form[i].get('score'),end=' ')
print()
print('---------------------------------')

# 下面打印表的全部数据
for i in range(len(form)):
    print(form[i].get('name'),form[i].get('Chinese'),form[i].get('math'),form[i].get('score'))
print('---------------------------------')

# 下面就是打印整个表格：
for i in form:
    print(i)
print('---------------------------------')

# 下面是打印总成绩高于180分的人的姓名：
for i in form:
    if i.get("score")>=180:
        print(i.get('name'))
print('---------------------------------')

break & continue语句

我们上面已经展示了一个使用break语句的while循环。break语句主要是用于while和for循环，用来结束整个循环。当有嵌套循环的时候，break是只能够跳出最近一层的循环。

continue语句则是用于结束本次循环，然后进行下一轮的循环。当有嵌套循环的时候，continue也是只能够结束最近一层的循环。不影响外一层的循环

下面看一个例子：

# 功能：使用多分支结构和多层嵌套

while True:
    score=int(input("请你输入分数:"))
    descr=["学习这么好，妈妈知道吗？","优秀","良好","不及格"]
    if(score==-1):
        print("这个分数值是-1,用来演示break")
        break
    if(score == 101):
        print("这个分数值是101,用来演示continue")
        continue
    if(score>100):
        print("请输入一个合法的分数，例如：0-100")
    else:
        index=score//10
        if(index<6):
            index=7
        elif (6<=index<8):
            index=8
        elif (8<=index<10):
            index=9
        print("成绩为{0},评语为{1}".format(score,descr[10-index]))

下面演示一个实例：

要求输入员工的薪资，若是员工的薪资小于0，则重新输入。最后再打印出成功录入的员工个数和薪资明细、平均薪资

# 功能：使用多层嵌套,continue break

number=0
salarySum=0
average=[]
while True:
    str=input("请输入员工的工资金额，键入EXIT or exit退出录入：")

    if(str.upper()=='EXIT'):
        print("录入信息完成，正常退出")
        break
    if(float(str)<0):
        print("你输入的数字小于0，我们不可能扣员工工资")
        continue
    number+=1 #计算员工个数
    average.append(float(str)) #录入员工工资
    salarySum+=float(str)
print('----------------------------------------------------')
print("员工个数：",number)
print("录入的工资为：",average)
print("平均薪资{0}".format(salarySum/number))

else语句

有人会说 else语句，放在这里会有些突兀。因为按照常理不是应该放在if 语句那里一起结束了吗？但是在Python里面，和我熟知的C C++不太一样。上面的while、for循环是可以附带一个else语句（它是可选的）。

它的作用如下：

若是我们的while、for循环是正常结束的（不是被break干掉的），那么它就会去执行else模块。其语法格式如下：

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

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

改造上面的实例如下：

要求输入3名员工的薪资，最后再打印出成功录入的员工个数和薪资明细、平均薪资

# 功能：使用多层嵌套,continue break

number=0
salarySum=0
average=[]
for i in range(3):
    str=input("请输入员工的工资金额，键入EXIT or exit退出录入：")

    if(str.upper()=='EXIT'): 
        print("录入信息完成，正常退出")
        break
    number+=1 #计算员工个数
    average.append(float(str)) #录入员工工资
    salarySum+=float(str)
else:
    print("你已经成功录入3名有效员工的工资")

print('----------------------------------------------------')
print("员工个数：",number)
print("录入的工资为：",average)
print("平均薪资{0}".format(salarySum/number))

若是上面的break被触发，那么下面的else 模块将不会执行。

循环的代码优化

有一个良好的代码优化能力，可以在程序员开发的道路上走的更远。毕竟细节决定成败，避免不必要的低效能重复计算，将会大大提高运行效率。（考虑一个算法或者哪怕一段简单的代码，时空的限制大家要时刻在意）。主要有以下几点注意事项：

1、尽量减少循环内部的不必要计算
2、嵌套循环中，尽量将内层的循环往外面提 来确保减少内层循环的计算量
3、局部变量的查询效率更高要尽量多使用
4、连接多个字符串的时候使用join() 而非+。不会产生新的字符串对象
5、列表进行元素插入删除的时候，尽量在尾部去做

第一条的实例演示：（尽量减少循环内部的不必要计算）

若是循环的次数再向上增加，可能差距会更大。将数据提到外面进行计算：就少算了

10000*10000-10000 次

zip()的并行迭代

可以使用zip()来完成对多个序列的并行迭代。注：zip()会在最短的序列迭代完成之后停止。 实例如下：

因为scores里面只有3个元素，所以循环3次只把三个序列的前3个元素遍历出来了。

推导式创建序列

之前我们也说过了：推导式是从一个 or 多个迭代器快速创建序列的一种方法。它可以将循环和条件判断进行结合，从而避免冗余的代码。

列表推导式

列表推导式主要是用来生成列表对象，语法格式如下：

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

>>> [x for x in range(1,10)]# 先for 产生9个数字的列表 然后每次循环完 给x赋值
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [x*2 for x in range(1,10)] #赋完值之后，乘以2  再放到新的列表对象里面
[2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> [x*2 for x in range(1,10) if x%3==0] #if过滤 乘以2后面的新值，满足的放到新的列表对象
[6, 12, 18]
>>> [s for s in "abcdefgh"]
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> cells=[(row,col) for row in range(1,4) for col in range(1,5)]#这里是在运行 两重循环
>>> cells
[(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4)]
>>> for cell in cells:
	print(cell)

	
(1, 1)
(1, 2)
(1, 3)
(1, 4)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 1)
(3, 2)
(3, 3)
(3, 4)
>>>

字典推导式

字典推导式主要是用来生成字典对象，语法格式如下：

【键对象表达式：值对象表达式 for 表达式 in 可迭代对象】
当然上面也是可以加上 if条件判断、多个for循环

实例如下：（统计字符串里面每个字符出现的次数）

>>> text='songbaobaosongbaibaiyishengyishi'
>>> character_count={char:text.count(char) for char in text}
>>> character_count
{'s': 4, 'o': 4, 'n': 3, 'g': 3, 'b': 4, 'a': 4, 'i': 5, 'y': 2, 'h': 2, 'e': 1}
>>>

上面的键值对是{字符，字符出现的次数}

这个若是使用循环的话，就是下面的做法：

集合推导式

集合推导式生成集合对象，其语法格式如下：