Python分支结构与流程控制

Python分支结构与流程控制

分支结构

if 语句

---

　　分支结构在任何编程语言中都是至关重要的一环，它最主要的目的是让计算机拥有像人一样的思想，能在不同的情况下做出不同的应对方案，所以if语句不管是在什么时候都是会大量去使用的。我们先来看一下if语句的语法和使用。

# ==== if 的使用 ====
​
'''
if 条件判断：
    逻辑代码...
if 条件判断:
    逻辑代码...
if 条件判断:
    逻辑代码...
'''
​
tag = 1
if tag == 1:
    print("判断为真，tag = 1")
if tag == 2:
    print("判断为真，tag = 2")
if tag:
    print('判断为真，tag为True')
if not tag:
    print('判断为真，tag为False')
​
print('执行完毕...')
​
# ==== 执行结果 ====
​
"""
判断为真，tag = 1
判断为真，tag为True
执行完毕...
"""

　　可以看到，上面一共有4条if判断，对应的逻辑代码也共有4段（4个print()）,从语法层面上来讲Python中只要遇到以冒号 ：结尾的语句下一行必须缩进4个空格。（PEP8规范中并不推荐使用tab），在4个空格后的代码便是上面一个冒号的子代码段。

　　这里只执行了2个逻辑子代码，说明if只在条件为真的情况下执行它自己的子代码段。我们继续来看一个实例分析：

# ==== if 实例分析 ====
​
'''
二狗子要找女朋友，
​
    年龄不能大于25岁,这个是前提！！，
    身高不能超过170或者体重不能超过60公斤。
​
请问下面那个符合二狗子的需求？
'''
​
xiaoli = {'age':30,'height':158,'weight':90}
xiaohua = {'age':22,'height':190,'weight':50} #从上一章中过来的读者注意，age改为22了。
xiaocui = {'age':22,'height':164,'weight':58}
​
# 使用括号，改变优先级。不然会出现bug
​
if xiaoli['age']<25 and (xiaoli['height']<170 or xiaoli['weight']<60):
    print("小丽符合二狗子的要求..小丽和二狗子约会了")
if xiaohua['age']<25 and (xiaohua['height']<170 or xiaohua['weight']<60):
    print("小花符合二狗子的要求..小花和二狗子约会了")
if xiaocui['age']<25 and (xiaocui['height']<170 or xiaocui['weight']<60):
    print("小翠符合二狗子的要求..小翠和二狗子约会了")
print("执行完毕...")
​
# ==== 执行结果 ====
​
"""
小花符合二狗子的要求..小花和二狗子约会了
小翠符合二狗子的要求..小翠和二狗子约会了
执行完毕...
"""

if 实例分析

　　二狗子的做法令二狗子的父母很不满意，他们认为如果和一个姑娘约了会就不该再和其他姑娘继续约会。这是道德问题，如果让女孩子知道了这些事儿，二狗子就会落下一个不好的名声，所以二狗子的父母希望二狗子不要这么做。那么该如何解决呢？

 

if 与 else

---

　　上面遗留问题的我们先来分析一下，只有当二狗子和某一个女孩约会那个女孩不符合二狗子的要求时二狗子才能继续和下一个女孩进行约会，这其中有一个 如果怎么，否则怎样的关系在里面。那么就可以用到if和else的配套使用来解决这个问题，if代表是如果条件成立则执行if语句下的子代码块，而else代表if条件不成立则执行else语句下的子代码块。所以if和else是配套使用的，在同一缩进范畴下的if和else认为是一对。还是先看一下if和else的使用方法，再来解决具体问题：

# ==== if 与 else 的使用 ====
​
'''
if 条件判断：
    逻辑代码...
else：
    逻辑代码...
'''
​
tag = 2  # 注意tag改成了2
if tag == 1:
    print("判断为真，tag = 1")
else:
    print("判断为假，tag != 1")
if tag:
    print('判断为真，tag为True')
else:
    print('判断为假，tag为False')
​
print('执行完毕...')
​
# ==== 执行结果 ====
​
"""
判断为假，tag != 1
判断为真，tag为True
执行完毕...
"""

　　好了，简单的学习了 if 和 else 的使用后我们来解决二狗子爸妈的疑虑。

# ==== if 与 else 实例分析 ====
​
'''
二狗子要找女朋友，
​
    年龄不能大于25岁,这个是前提！！，
    身高不能超过170或者体重不能超过60公斤。
​
请问下面那个符合二狗子的需求？
'''
​
xiaoli = {'age':30,'height':158,'weight':90}
xiaohua = {'age':22,'height':190,'weight':50} #从上一章中过来的读者注意，age改为22了。
xiaocui = {'age':22,'height':164,'weight':58}
​
# 使用括号，改变优先级。不然会出现bug
​
if xiaoli['age']<25 and (xiaoli['height']<170 or xiaoli['weight']<60):
    print("小丽符合二狗子的要求..小丽和二狗子约会了")
else:
    print("由于小丽不符合二狗子的要求，二狗子决定和小花约会试试..")
    if xiaohua['age']<25 and (xiaohua['height']<170 or xiaohua['weight']<60):
        print("小花符合二狗子的要求..小花和二狗子约会了")
    else:
        print("由于小花不符合二狗子的要求，二狗子决定和小翠约会试试..")
        if xiaocui['age']<25 and (xiaocui['height']<170 or xiaocui['weight']<60):
            print("小翠符合二狗子的要求..小翠和二狗子约会了")
        else:
            print("所有的女孩子都不符合二狗子的要求，二狗子决定单身一辈子")
print("执行完毕...")
​
# ==== 执行结果 ====
​
"""
由于小丽不符合二狗子的要求，二狗子决定和小花约会试试..
小花符合二狗子的要求..小花和二狗子约会了
执行完毕...
"""

if 与 else 实例分析

　　可以看到二狗子在约会成功后就没有继续再做约会了，完成了二狗子爸妈的需求。但是这段代码看起来实在是太糟糕了，如果有100个女孩和二狗子约会这样一直写 if 和 else 那么到最后岂不是一直往右边飘到天上去了吗？所以我们需要一个在保证这种逻辑判断下并且提高代码可读性的解决方案。

 

if 与 elif 以及 else

---

　　为了解决单纯的if和else嵌套带来的阅读性差的问题。这里出现了elif这个东西，它相当于是else和if的缩写版，我们来看一下他的使用方法：

# ==== if 与 elif 的使用 ====
​
'''
if 条件判断：
    逻辑代码...
​
elif 条件判断:  #如果条件成立，剩下同级别下的elif与else都不将再继续执行。
    逻辑代码...
​
elif 条件判断:
    逻辑代码...
​
else:
    逻辑代码
'''
​
tag = 2  # 注意 tag 改成了2
​
if tag == 1:
    print("判断为真，tag = 1")
elif tag == 2:
    print("判断为真，tag == 2")
elif tag == 3:
    print("判断为真，tag == 3")
else:
    print("判断为假，tag既不等于1也不等于2或者3")
​
print('执行完毕...')
​
# ==== 执行结果 ====
​
"""
判断为真，tag == 2
执行完毕...
"""

　　elif只会执行一个。剩下的elif或者else便会直接跳过，（如果elif下面有if语句，还是会执行if语句的）

 

　　二狗子找女朋友改进版：

# ==== if 与 elif 以及else 实例分析 ====
​
'''
二狗子要找女朋友，
​
    年龄不能大于25岁,这个是前提！！，
    身高不能超过170或者体重不能超过60公斤。
​
请问下面那个符合二狗子的需求？
'''
​
xiaoli = {'age':30,'height':158,'weight':90}
xiaohua = {'age':22,'height':190,'weight':50} #从上一章中过来的读者注意，age改为22了。
xiaocui = {'age':22,'height':164,'weight':58}
​
# 使用括号，改变优先级。不然会出现bug  
​
if xiaoli['age']<25 and (xiaoli['height']<170 or xiaoli['weight']<60):  #if 和 elif 中不能夹杂 print()。所以没办法及时告诉二狗子的父母二狗子本次的情况，只有全部结束后else中才会告诉二狗子的父母。
    print("小丽符合二狗子的要求..小丽和二狗子约会了")
elif xiaohua['age']<25 and (xiaohua['height']<170 or xiaohua['weight']<60):
    print("小花符合二狗子的要求..小花和二狗子约会了")
elif xiaocui['age']<25 and (xiaocui['height']<170 or xiaocui['weight']<60):
    print("小翠符合二狗子的要求..小翠和二狗子约会了")
else:
    print("所有的女孩子都不符合二狗子的要求，二狗子决定单身一辈子")
​
print("执行完毕...")
​
# ==== 执行结果 ====
​
"""
小花符合二狗子的要求..小花和二狗子约会了
执行完毕...
"""

 

　　可以看到。当3个语句都有的时候，它的构成是这样的：if 开头，elif夹杂中间，else放在尾部。if 代表开始执行逻辑判断与判断第一条语句，如果第一条语句不成立则判断所有的elif语句，一旦有一条elif语句判断成功则直接跳过接下来同级的elif与else。当if与所有的elif都不成立时才执行else。

 

流程控制之条件循环

条件循环 while

---

　　结构分支让计算机像人一样能够应对不同的情况而做出不同的对应方案，那么循环就是让计算机具有重复做一件事的能力。

　　while循环也是很多编程语言中都存在的，它的使用也非常广泛，while循环是一种基于条件的循环。当条件为真时开始重复执行子代码块中的内容直至条件为假后跳出循环。我们来看一下while循环的语法与简单使用：

# ==== while循环的使用 ====
​
tag = 10
while tag > 5:
    print("tag的数值目前是:{num}".format(num=tag))
    tag -= 1
​
print('while循环执行完毕')
print(tag)
​
# ==== 执行结果 ====
​
"""
tag的数值目前是:10
tag的数值目前是:9
tag的数值目前是:8
tag的数值目前是:7
tag的数值目前是:6
while循环执行完毕
5
"""

　　做一个小案例，来更加清晰的了解while循环的使用：

# ==== while循环 实例分析 ====
​
'''
    小王和小张在打架，小王很愤怒，一旦怒气值达到了100小王就会化身斯巴达...
'''
​
import random  # 生成随机数的一个模块。
anger = 10 #小张骂了小王2句，小王目前怒气值为10...
while anger != 100:
    mode = random.randrange(0,3) # 有 0,1,2三个随机数
    if mode == 0:
        print("小张对小王破口大骂，小王怒气值加5")
        anger += 5
    elif mode == 1:
        print("小张使劲打了小王一拳！小王怒气值加10")
        anger += 10
    else:
        print("小张用尽浑身力气踹了小王一脚，小王怒气值加20")
        anger += 20
​
print("="*30)
print("小王目前怒气值:{}".format(anger))
print("小王化身斯巴达，一屁股坐死了小张...")
print("="*30)
​
# ==== 执行结果 ====
​
'''
小张使劲打了小王一拳！小王怒气值加10
小张对小王破口大骂，小王怒气值加5
小张对小王破口大骂，小王怒气值加5
小张用尽浑身力气踹了小王一脚，小王怒气值加20
小张用尽浑身力气踹了小王一脚，小王怒气值加20
小张用尽浑身力气踹了小王一脚，小王怒气值加20
小张使劲打了小王一拳！小王怒气值加10
==============================
小王目前怒气值:100
小王化身斯巴达，一屁股坐死了小张...
==============================
'''

while循环 实例分析

　　可以看到while在某些情况下应用是非常有效的，比如银行取钱，游戏开箱等等。

 

银行取钱：

1. 有一个变量存储当前输入密码的次数

2. 当变量变为0或者密码输入正确后跳出循环，否则就一直提示需要输入密码，当前输入错误的次数以及剩下的次数等等

 

游戏开箱：

1. 有一个变量存储当前剩余宝箱的数量

2. 当变量为0时退出循环，并且循环中一定存有随机函数掉落随机的物品

 

　　我们来模仿一下银行取钱的程序：

# ==== 银行取钱 ====
​
money = "100" # 用str类型，可以不用再做input输入后的转换。
count = 5
username = "yunya"
passwd = "12345"  # 用str类型，可以不用再做input输入后的转换。
while count:
    print("您总共可输入{0}次密码，当前还剩余{1}次输入机会".format(5,count))
    username_input = input("请输入用户名\n>>>")
    passwd_input = input("请输入密码\n>>>")
    if username == username_input and passwd == passwd_input:
        select = input('您好，{0}！\n您当前账户余额为:{1},请选择您的操作方式:\n1.取款\n2.退出\n>>>'.format(username,money))
        if select == "1":
            num = input('请输入取款金额:')
            if num > money:
                print("您的余额不足，取款失败")
                count = 0
            else:
                print("取款成功")
                count = 0
​
        else:
            print("正在退出...请稍候")
            count = 0
    else:
        count -= 1
​
print("期待您的下次光临")

银行取钱

 

基于条件的退出

---

　　面已经介绍过while本身是基于条件的循环。如果条件为False时则不再继续执行while循环体内的代码，从上面3个程序的演示就已经看得出来了。那为什么还要单独拿出来讲呢？因为基于条件的退出就算条件被改变也一定会执行接下来的while循环体中的代码。我们来看一看：

# ==== 基于条件的退出 ====
​
count = 5
​
while count != 10:
    count = 10 #修改条件后。不会立刻退出
    print("当前count的数值为:",count)
    print("----> 执行中")
​
print("执行完毕..")
​
# ==== 执行结果 ====
​
"""
当前count的数值为: 10
----> 执行中
执行完毕..
"""

 

while 与 break

---

　　break代表立马结束本层循环。不会执行当前break后的代码。

# ==== while 与 break ====
​
count = 5
​
while count != 10:
    break #立刻退出
    print("当前count的数值为:",count)
    print("----> 执行中")
​
print("执行完毕..")
​
# ==== 执行结果 ====
​
"""
执行完毕..
"""

 

while 与 continue

---

　　continue代表跳出本次循环。执行下一次循环。

# ==== while 与 continue ====

count = 5
​
while count != 10:
    if count == 8:
        count += 1  #必须放在前面。不然会产生死循环
        continue
        print(count) #不会执行countinue后的代码。
    print(count)
    count += 1
​
print("执行完毕..")
​
# ==== 执行结果 ====
​
"""
5
6
7
9
执行完毕..
"""

 

while 与 else

---

　　else是非常装逼的一个玩法（个人感觉），因为与else搭配最多的是if语句。所以与while搭配的else一般不会太常用。

　　while与else的搭配中，只要while循环不是由break跳出的就在循环完成后执行else子代码块。

# ==== while 与 else ====
​
# 正常退出while循环。紧接着执行else子代码块
tag  = 1
while tag < 5:
    print(tag)
    tag += 1
​
else:
    print("else代码块:\n    tag --> ",tag)
​
print("执行完毕..")
​
# ==== 执行结果 ====
​
"""
1
2
3
4
else代码块:
    tag -->  5
执行完毕..
"""

 

while 循环嵌套

---

　　while循环中允许多层嵌套。当在多层嵌套的while循环中有以下几点需要注意：

 

　　1.如果是使用 基于条件退出 那么所有的while循环都必须遵循同一个条件才能退出。

　　2.break只针对当前的while循环体退出，对于非当前的while循环体不生效。

　　3.continue只针对当前while循环体跳过，对于非当前的while循环体不生效。

 

# ==== 多层while循环基于条件退出注意事项 ====
​
# 错误示范
​
tag1 = 1
tag2 = 2
while tag1 == 1:
    print("一层..")
    while tag2 == 2:
        print("    二层..")
        while tag2 == 2:
            print("        三层..")
            tag2 = 3  #由于条件不同。只退出 第二层和第三层。
​
# ==== 执行结果 ====
​
"""
一层..
    二层..
        三层..
一层..
一层..
一层..
（无限打印）
"""
​
# ==============================================手动分割线==============================================
​
#正确示范
​
tag3 = 3
while tag3:
    print("一层..")
    while tag3:
        print("    二层..")
        while tag3:
            print("        三层..")
            tag3 = False  # 可以看到全部退出了。
​
# ==== 执行结果 ====
​
"""
一层..
    二层..
        三层..
"""
 

# ==== 多层while循环基于break退出注意事项 ====
​
# 错误示范
​
tag1 = 1
tag2 = 2
while tag1 == 1:
    print("一层..")
    while tag2 == 2:
        print("    二层..")
        while tag2 == 2:
            print("        三层..")
            break  # 跳出三层。回到二层。执行三层。跳出三层。回到二层。执行三层。
​
# ==== 执行结果 ====
​
"""
一层..
    二层..
        三层..
    二层..
        三层..
    二层..
        三层..
    （无限打印）
"""
​
# ==============================================手动分割线==============================================
​
# 正确示范
​
tag3 = 3
while tag3:
    print("一层..")
    while tag3:
        print("    二层..")
        while tag3:
            print("        三层..")
            break  # 跳出三层
        break  # 跳出二层
    break  # 跳出一层
​
# ==== 执行结果 ====
​
"""
一层..
    二层..
        三层..
"""

多层while循环基于条件退出注意事项

 

　　那么现在的while循环内容都学过了。我们针对银行取钱程序做一次优化升级，让它更符合逻辑（代码初学者必读）：

# ==== 银行取钱程序终极版 ====
​
'''
​
   银行取钱改进需求：
       1.当输入密码正确后取款完成后不会再次要求输入密码
       2.当输入密码正确后取款失败后也不会再次要求输入密码
       3.针对使用 输入 2 退出的正常操作流程和输入密码错误超过上限被迫退出的流程做不同的回应
       4.取款后总额扣除取款的相应金额
​
    解决方案：
        对于 1,2 来说都可以增加一层while循环。
        对于 3 来说。正常退出不走else提示（基于break提示提出），被迫退出则走else（基于条件退出）
        对于 4 来说。只需要做一次四则运算即可
'''
money = 100  # 有了真正的取钱，就用int类型。因为str没办法做减法
count = 5
username = "yunya"
passwd = "12345"  # 用str类型，可以不用再做input输入后的转换。
select = None  # 选择记录。
​
while count:
​
    if select:  # 如果是没有成功登陆过。这里就是None，通过break退出不会执行else。
        break
​
    print("您总共可输入{0}次密码，当前还剩余{1}次输入机会".format(5, count))
    username_input = input("请输入用户名\n>>>")
    passwd_input = input("请输入密码\n>>>")
​
    if username == username_input and passwd == passwd_input:
        while True:
            select = input('您好，{0}！\n您当前账户余额为:{1},请选择您的操作方式:\n1.取款\n2.退出\n>>>'.format(username, money))
            if select == "1":
                num = int(input('请输入取款金额:'))  # 这里也接收为int类型
                if num > money:
                    print("您的余额不足，取款失败")
                else:
                    print("取款成功")
                    money = money - num
​
            elif select == "2":
                print("正在退出...请稍候")
                break
​
    else:
        count -= 1  # 如果是条件退出。则会执行else
​
​
​
else:
    print('您的密码输入次数过多，系统已强制退出')
print("期待您的下次光临")

银行取钱程序终极版

 

死循环带来的性能损耗

---

　　死循环既永远跳不出的循环。

　　因为在计算机硬件基础中讲到，CPU的运行速度是绝对会被I/O操作所拖慢的（因为硬盘速度慢，内存速度也赶不上CPU的处理速度）。所以当在while死循环中使用I/O操作的时候CPU是有休息时间的，而一旦没有I/O操作只是做单纯的计算操作CPU的压力会无比巨大。所以在死循环中，千万要注意规避没有I/O操作而只有单纯的计算操作这种傻逼行为。

# ==== 死循环带来的性能损耗 ====
​
x = 2
while 1:  # 使用while 1 比while True 会带来微乎其微的性能提升（计算机内部都是二进制。如果用字符True会经历转换过程）
    x **= 12  # SB行为，CPU不断的运算只会让它肾虚
​
#===============================================
​
while 1:
    print("====") #这种死循环没事。因为CPU要调用显示器来显示，所以CPU会有休息时间

 

 

流程控制之取值循环

取值循环 for

---

　　Python中提供了while循环，还提供了一种for循环机制。（for循环本身就是基于while循环做出来，后面会讲到）。for循环对于某些操作来说比while循环更加省事省力，也是我们以后会经常使用的东西。

　　应用场景：取值，如list，tuple

# ==== for 循环的使用 ====
​
'''
​
for 迭代变量 in 迭代器(或者认为可迭代对象，不深究)
    逻辑操作...
    
'''
​
li1 = [1,2,3,4,5,6,7]
for i in li1:
    print(i)
​
# ==== 执行结果 ====
​
"""
1
2
3
4
5
6
7
"""

　　可以看到。i这个迭代变量拿到的正是列表中的具体元素（这点尤其重要，和其他的编程语言有点不一样，如JavaScript）。还记得集合吗？在介绍集合的时候没有详细说集合中的元素该怎么拿出来。是因为那时候没学for循环，（集合没有key，无法通过键值对取值，也没有index，无法通过索引取值），那么集合的取值方法就是通过for循环。

 

　　如果对字典进行for循环，迭代变量保存的值是字典的key，这点尤其要注意。

# ==== 对字典的 for 循环 ====
​
d1 = {"k1": "v1", "k2": "v2", "k3": "v3"}
for k in d1:
    print(k)
    print(d1[k])  # 可以使用该方法取出字典的 value
​
# ==== 执行结果 ====
​
"""
k1
v1
k2
v2
k3
v3
"""

 

　　如果对str进行迭代，那么任何字符串子串（字符）都会被当拿出来。包括空格

# ==== 对 str 的 for 循环 ====
​
s1 = "- - - - - -"
for i in s1:
    print(i)
    
# ==== 执行结果 ====
​
"""
-
​
-
​
-
​
-
​
-
​
-
"""

 

for 循环的退出

---

　　for循环的退出，一般是在迭代（或者称之为遍历）完整个被迭代对象后就自动退出了。一定要注意在这里讲的for循环其实是比较浅层次的，关于深层次的for循环会在后面讲到。关于for循环的退出无法通过条件退出，因为他根本不是基于条件运行的。

 

for 与 break

---

　　for循环中的break与while循环中的相同。但是使用的不是很多，对于for循环来说我们使用最多的就是它取值的便捷性而已。

# ==== for 与 break ====
​
s1 = "ABCDEFGHIJKLMN"
for i in s1:
    if i=="J":
        break
    else:
        print(i)
        
# ==== 执行结果 ====
​
"""
A
B
C
D
E
F
G
H
I
"""

 

for 与 continue

---

　　for循环与continue的操作与while循环与continue的操作也是一样的。（我也很少使用for和continue的组合）

# ==== for 与 continue ====
​
s1 = "ABCDEFGHIJKLMN"
for i in s1:
    if i=="J":
        continue
    else:
        print(i)
        
# ==== 执行结果 ==== Ps:没有 J
​
"""
C
D
E
F
G
H
I
K
L
M
N
"""

 

for 与 else

---

　　同while循环一样。break跳出循环操作不会走else子代码块，而只有正常结束循环的操作才会走else子代码块（装逼玩法）：

# ==== for 与 else ====
​
s1 = "ABCDEFGHIJKLMN"
for i in s1:
    if i=="J":
        break
    else:
        print(i)
else:
    print("没有break走else")
print("如果break结束for循环就不走else")
​
# ==== 执行结果 ==== Ps:没有 J
​
"""
A
B
C
D
E
F
G
H
I
如果break结束for循环就不走else
"""

 

len()方法

---

　　上面已经说过，for循环的正常结束是遍历完整个可迭代对象。那么换而言之也就取决于被迭代对象中的元素个数，如何查看for循环中的元素个数？使用len()方法查看。（len即是length的缩写，代表长度的意思。）

>>> li1 = [1,2,3,4,5,6,7]
>>> print(len(li1))
7
>>>

 

for 与 range()方法

---

　　下面再介绍一个新的方法：range()方法，range()方法可用于生成一个装满整形的列表。比如range(10)则代表生成一个列表,元素为[0,1,2,3,4,5,6,7,8,9].（注意：不包含尾部，姑且认为生成的是列表。但在Python2中它的确生成的是列表）。所以我们可以通过range()方法可以让for循环做很多事。

# ==== for 与 range() 组合使用 ====
​
#打印 十次 hello,world
​
for i in range(10):
    print("hello,world")
​
# ==== 执行结果 ====
​
"""
hello,world
hello,world
hello,world
hello,world
hello,world
hello,world
hello,world
hello,world
hello,world
hello,world
"""

 

　　可以通过与len()方法的结合，拿到元素的index。

# ==== for range() len() 的组合使用 ====
​
li1 = ["a", "b", "c",]
for i in range(len(li1)):  # len返回的是一个数字。长度为3，rang则恰恰是 0,1,2 不取3.
    print(i)
    print(li1[i])
​
​
# ==== 执行结果 ====
​
"""
0
a
1
b
2
c
"""

 

for 循环嵌套

---

　　for循环同样支持嵌套。外层执行1次，内层的for循环要全部循环完成才回到外层执行第2次。

# ==== for 循环嵌套 ====
​
li1 = ["a", "b"]
li2 = range(2) # 0,1
for i in li1:
    print("============")
    print("外层循环")
    print(i)
    for j in li2:
        print("    内层循环")
        print("    ",j)
​
# ==== 执行结果 ====
​
"""
============
外层循环
a
    内层循环
     0
    内层循环
     1
============
外层循环
b
    内层循环
     0
    内层循环
     1
"""

 

range() 方法详解

Python2中的range()与xrange()

---

　　Python2中有range()和xrange()两种方法。xrange()和Python3中的range()是一模一样的。这个待会再介绍，我们先来看看range()有哪些参数。注意：以下操作均是使用Python2中的range()进行示例：

 

range()参数有3，分别代表开始start，结束stop，步长step。

 

　　start

　　　　- 由于range()生成的是一个包含整形的列表（Python2 range()），所以列表的第一个元素就是开始。默认是0

　　stop

　　　　- 列表的最后一个元素 ，必须手动填写。

　　step

　　　　- 步长代表跨几个拿一次元素，如果步长是2则代表从开始的数字数起来，每次数到2则加一个元素进列表。开始是0，向后数到2加进列表，数到4再加进列表。步长默认初始值为1。

 

# 如果要使用 步长 。则必须填入3个参数，否则会认为 第一个参数是开始，第二个参数是步长。
>>> range(1,10,2)
[1, 3, 5, 7, 9]
>>>

 

　　range()生成的是一个列表，而xrange()或者说Python3中的range()生成的不是一个列表，而是一个经过优化的可迭代对象（对其调用循环时创建一个专属迭代器）。为什么要这么做呢？其实这一节的详细内容应该在学习过迭代器和生成器后再开始讲的。这里提一嘴：xrange()和Python3的range()创建的可迭代对象中并不存储具体的值，故称为经过优化的可迭代对象。当for循环对其遍历时首先创建专属迭代器，再执行其__next__方法。在该方法中通过一些计算手法能够做到和生成器相同的效果（xrange()和Python3中的range()创建出的迭代器也不属于生成器范畴）。换句话说，你创建xrange()对象时不论其中有多少数值都不会占据非常大的内存空间，并且你可以多次循环遍历xrange()对象。故很多教程中对xrange()和Python3中的range()解释为返回一个生成器。这是不准确的。

 

>>> type(xrange(10000000)) #xrange()的参数和使用都与range()相同。不同的是生成值的
'xrange'>
>>> type(range(10))
'list'>
>>>

 

Python3中的range()

---

　　Python3的range()和Python2的xrange()是一模一样的。Python3中没有xrange()。如何将一个range()这一个经过优化的可迭代对象转换为一个列表呢？

　　通过：list(经过优化的可迭代对象名) 即可完成转换。

>>> # === 如何转换一个经过优化的可迭代对象为列表 ====
>>>
>>> type(range(10))
<class 'range'>
>>> range(10)
range(0, 10)
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

 

　　测试：使用for循环嵌套与range()函数写出一个 9 * 9 乘法表：

# ==== 9 * 9 乘法表 ====
​
for i in range(1,10):
    for j in range(1,i+1):
        print("{0}*{1}={2}".format(i,j,(i*j)),end=" | ") #内层的循环每一次不换行而作为一排。
    print(" ") #占行使用。多层循环特性。外层循环一层内层全部循环完
    
# ==== 执行结果 ====
​
"""
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 |
"""

9 * 9 乘法表