python循环语句（for and while）

        python中提供了两种循环语句，一种是for循环语句，一种是while循环语句。for循环语句通过不断使用next函数访问迭代器实现循环，当迭代器终止时循环结束。while循环通过条件的真假值来实现，条件为真时执行循环语句，条件为假时结束循环。   

for循环语句

基本结构

        for循环的每一次循环都会使用next函数去访问一次迭代器，next函数会从迭代器中取出一个元素，所以for循环中需要一个变量来接收next函数取出的元素，当所有的元素都被取完后迭代器终止，for循环也就结束了。for循环基本结构如下图所示：

        当in后面是一个可迭代对象时，for循环会把可迭代对象转换为迭代器，所以for循环可以遍历输出可迭代对象。

str1 = "abc"
for i in str1:
    print(i)  # 缩进为一个Tab键或者4个空格键

我们使用for循环迭代输出字符串str1，用变量i来接收next函数每次取出的元素。执行结果如下：

第一次循环的时候next函数取出字符a，把字符a赋值给变量i，执行循环体（当前循环体中的语句为： print(i) ）。循环体执行完后进入第二次循环，next函数取出字符b，把字符b赋值给变量i，执行循环体。第三次循环next函数取出字符c，把字符c赋值给变量i，执行循环体。这时str1中所有的字符都被取出来了，迭代终止for循环结束。

提前结束本次循环（continue）

        continue语句在for循环的循环体中使用，当程序执行到continue时可以提前结束循环体。也就是说continue之后的语句在本次循环中不再被执行，直接进入到下一次循环。

list1 = [1, 2, 3, 4, 5, 6]
for i in list1:
    print(f'第{i}次循环')
    if i < 4:
        continue
    print(i)

当满足条件 i < 4 时，就会执行continue，一旦执行continue就会结束本次循环，后面的语句 print(i) 将不会被执行。执行结果如下：

提前结束循环（break）

        break语句在for循环的循环体中使用，当程序执行到break时可以提前结束循环。也就是说执行到break后，不管可迭代对象有没有迭代完都会结束for循环。

tuple1 = (1, 2, 3, 4, 5, 6)
for i in tuple1:
    print(f'第{i}次循环')
    if i == 4:
        break
    print(i)

当满足条件 i == 4 时，就会执行break，一旦执行break就会直接结束循环。执行结果如下：

for循环迭代字典

dict1 = {"name": "小明", "age": 18, "sex": "男", "like": "python"}
for i in dict1:
    print(i)

执行结果如下：

从上面的执行结果，我们可以发现用for循环迭代字典，只能得到每个元素的键。如果我们要得到每个元素的值该怎么办呢？只需要通过字典的键去访问字典的值就行了。

dict1 = {"name": "小明", "age": 18, "sex": "男", "like": "python"}
for i in dict1:
    print(f'{i:>4}: {dict1[i]}')

执行结果如下：

range可迭代对象

        python中的内置函数range可以返回一个可迭代整数序列，range函数可以接收3个参数，第一个参数为起始值（默认为0），第二个参数为终止位置，第三个参数为步长值（默认为1）。我们可以按照如下工作原理去理解range函数：

start为第一个参数起始值，stop为第二个参数终止位置，step为第三个参数步长值。 

it = range(10)  # 使用range函数生成一个可迭代整数序列，起始位置0，终止位置10，步长默认值1
list1 = list(it)  # 用list函数把可迭代对象转换为列表
print(list1)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

当我们只给range函数传一个值时，传入的值默认给第二个参数stop。所以range(10)会从0开始取值，因为步长为1，所以每次取值start+=1。当start == stop时，会直接结束取值，因此终止位置上的值并不会被取出来。

        当我们给range函数传入两个值时，第一个值给第一个参数start，第二个值给第二个参数stop，第三个参数step还是默认值1。

for i in range(1, 6):
    print(i)

执行结果如下：

        当我们给range函数传入3个值时，第一个值给第一个参数start，第二个值给第二个参数stop，第三个值给第三个参数step。

for i in range(5, 0, -1):
    print(i)

执行结果如下：

for循环嵌套结构

        循环是可以无限嵌套的，for循环内可以嵌套for循环和while循环，while循环内也可以嵌套for循环和while循环。

无关系型嵌套

        上一层循环跟下一层循环没有关系，则为无关系型嵌套。

for i in 'ABC':
    print(i, end=' ')
    for n in range(0, 2):
        print(n, end=' ')

如上面这种嵌套结构，外层循环循环一次，内层循环执行完整个循环。但它们之间没有其他关系，外层循环不会影响内层循环的循环次数。执行结果如下：

九九加法表（关系型嵌套）

        for循环的关系型嵌套就是用一个循环的输出去影响另一个循环的循环次数。我们可以使用for循环的关系型嵌套来打印出九九加法表。

for i in range(1, 10):  # 按序列1，2，3，4，5，6，7，8，9逐个输出i
    for n in range(i):  # 按序列0，...，i逐个输出n
        print(f'{n + 1} + {i} = {i + (n + 1):<2}', end='  ')  # 在同一行打印九九加法口诀
    print()  # 外层循环每循环一次就换行

我们用外层循环的输出变量 i 来控制内层循环的循环次数，外层第1次循环 i 的值为1，内层循环只循环1次，输出1 + 1 = 2；外层第2次循环 i 的值为2，内层循环只循环2次， 输出1 + 2 = 3  2 + 2 = 4；以此类推直到外层第9次循环结束。执行结果如下：

        如果你想得到九九乘法表，只需修改第3行print语句中的两个地方。第一把字符串'+'改为'X'，第二把i后面的+号改为*号。

for i in range(1, 10):
    for n in range(i):
        print(f'{n + 1} X {i} = {i * (n + 1):<2}', end='  ')
    print()

执行结果如下：

冒泡排序（关系型嵌套）

        冒泡排序是用来给列表排序的一种排序方式，通过重新排列元素的顺序，把一个无序的列表变成一个有序的列表。冒泡排序的原理就是通过比较前后两个元素的大小，把大的排后面小的排前面。第一次比较第一个和第二个元素的大小，重新排序后进行第二次比较；第二次比较第二个元素和第三个元素的大小，重新排序后进行第三次比较；以此类推直到把最大的元素排到最后时，完成第一轮冒泡。接着以同样的方式进行第二轮冒泡，直到列表变成一个有序列表。原理如下图所示：

由于其排序过程类似于水底冒出的气泡（随着气泡的上升其体积逐渐变大，物理知识：水的压强大小跟深度有关）而得名。每一轮冒泡都可以把未确定顺序的所有元素中的最大元素排到最后位置，列表中有多少个元素就进行多少轮冒泡。第一轮冒泡的比较次数为列表长度减一（9个元素的列表第一轮冒泡只需比较8次），之后的每一轮冒泡，比较次数都比前一次的比较次数少一次。因此我们可以使用for循环嵌套来完成冒泡排序；以9个元素的列表为例，外层循环需循环9次表示9轮冒泡；第1轮冒泡，内层循环需循环8次（比较8次）；第2轮冒泡，内层循环需循环7次（比较7次）；以此类推，第9轮冒泡，内层循环需循环0次（此时只剩下一个元素，不需要比较）。所以冒泡排序是一种典型的关系型嵌套， 外层循环的每一次循环都会影响内层循环的循环次数。

list1 = [7, 3, 5, 8, 1, 4, 9, 2, 6]  # 定义一个具有可比性的无序列表

for i in range(len(list1)):  # 外层for循环，使用len()函数得到列表的长度，再使用range()函数得到可迭代的整数序列[0, 1, 2, 3, 4, 5, 6, 7, 8]
    for n in range(len(list1) - 1 - i):  # 内层for循环，使用len()函数得到列表的长度，再使用range()函数得到可迭代的整数序列，受变量i影响每轮可迭代的整数序列都不同
        if list1[n] > list1[n + 1]:  # 通过下标索引取出列表中的元素，如果前一个元素大于后一个元素
            list1[n], list1[n + 1] = list1[n + 1], list1[n]  # 则交换前后两个元素的位置，就是通过重新给元素赋值来实现list[x]放=号前面为元素、放=号后面为值

print(list1)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

内层的for循环为什么要写成 range(len(list1) - 1 - i) ，我们来思考一下：第一轮冒泡的比较次数为列表长度减一，之后的每一轮冒泡，比较次数都比前一次的比较次数少一次。第1轮冒泡变量i的值为0，len(list1)为9，9 -1 - 0 = 8符合要求；第2轮冒泡变量i的值为1，9 -1 - 1 = 7符合要求；以此类推，第9轮冒泡变量i的值为8，9 -1 - 8 = 0符合要求。我们巧妙的利用了循环的关系型嵌套来轻松的完成了冒泡排序，所以冒泡排序是利用外层循环来控制内层循环的循环次数的关系型嵌套。

while循环

基本结构

        while循环通过条件的真假值来实现，条件为真时执行循环语句，条件为假时结束循环。 

有限循环

        有限循环的循环语句中需要一个用于控制循环次数的控制语句，控制语句必须直接影响条件的真假。当循环到预定的次数时控制语句必须让条件为假，从而使循环结束。举个例子：

number = 0

while number < 5:
    print(number)
    number += 1  # 控制语句

变量number的初始值为0，判断number是否小于5。小于5时条件为真执行循环语句，打印出number的值，然后给number的值加一。如果没有控制语句 number  += 1 循环将无限的执行下去，因为 0 < 5 恒成立；有了控制语句 number  += 1 后，循环就只会进行5次。执行结果如下：

无限循环

        无限循环就是使用恒成立的条件，如 1 == 1 、 1 或者直接使用bool值True。

import time

while True:
    print('hello world')
    time.sleep(1)

以上代码就会无限的打印"hello world"，每间隔1秒打印一次。import为python中的导包函数，它可以把其他的python文件加载到当前的python文件中（对python解释器而言）。time函数库是python中内置的时间函数库，里面有很多跟时间有关的函数，其中sleep为停顿函数， sleep(1) 表示停顿1秒。在这停顿的1秒内CPU不会执行我们代码中的逻辑，而是去做一些跟我们代码逻辑不相干的事情来消耗掉这1秒钟的时间。

提前结束本次循环（continue）

        continue语句在while循环的循环体中使用，当程序执行到continue时可以提前结束循环体。也就是说continue之后的语句在本次循环中不再被执行，直接进入到下一次循环。

number = 0

while number < 5:
    number += 1
    print(f'第{number}次循环')
    if number < 4:
        continue
    print(f'number = {number}')

当满足条件 number < 4 时，就会执行continue，一旦执行continue就会结束本次循环，后面的语句 print(f'number = {number}') 将不会被执行。执行结果如下：

提前结束循环（break）

        break语句在while循环的循环体中使用，当程序执行到break时可以提前结束循环。也就是说执行到break后，即使条件为真也会结束while循环。

number = 0

while number < 5:
    number += 1
    print(f'第{number}次循环')
    if number == 3:
        break
    print(f'number = {number}')

当满足条件 i == 3 时，就会执行break，一旦执行break就会直接结束循环。执行结果如下：