python循环

Python for循环

一般程序设计语言的循环可以分为 for 循环 、while 循环 和 do while 循环 ，但是在 Python 中，只支持 for 循环和 while 循环。

Python 的 for 循环使用的是 for in 的格式，类似于其他语言的 foreach 循环，循环条件最后的分割符使用的是 :，类似于 if 语句最后的 :。
Python for循环详解
语法

for iterating_var in sequence:
   statements(s)
   

参数
参数 描述
for for 循环使用的关键字。
iterating_var for 循环每次迭代使用的变量。
in for 循环使用的关键字。
sequence for 循环需要遍历的变量。
statements 每次循环执行的逻辑。
案例
使用 for循环，遍历数值

for i in range(3):
    print('i =', i)
print("Over")

程序运行后，控制台输出如下：

我们定义了一个 for循环结构，计数器 变量 i 从 0 开始，结束条件是 i < 3，每次执行一次循环都打印出 i 的值，并且将 i 的值加 1。

这里使用了 range() 函数，此函数是 Python 内置的 函数，用于生成一系列连续的 整数，多用于 for 循环中。

for循环字符串
使用 for循环，遍历字符串

strHaiCoder = "HaiCoder"
for s in strHaiCoder:
    print(s, end=' ')
print("\nOver")

程序运行后，控制台输出如下：

我们定义了一个 for 循环结构用来遍历 字符串，每次执行一次循环都打印出当前字符串值，同时，我们在 print 函数中，指定了分隔符。

for循环求和
使用 for循环，求 1 到 100 的和

sum = 0
for num in range(101):
    sum += num
print("Sum =", sum)

程序运行后，控制台输出如下：

我们定义了一个 for 循环结构，计数器变量 i 从 0 开始，结束条件是 i < 101，每次执行一次循环都将当前的 i 的值加到变量 sum 上去，并且将 i 的值加 1。

最后，我们打印变量 sum 的值，为 5050，即 1 到 100 的和。

Python for循环总结
Python 的 for 循环使用的是 for in 的格式，类似于其他语言的 foreach 循环，循环条件最后的分割符使用的是 :，类似于 if 语句最后的 :。Python for 循环语法：

for iterating_var in sequence:
   statements(s)

Python for循环集合

Python 的 for 循环 除了可以遍历 数字、字符串 还可以用来遍历 元祖、列表、字典 等数据类型。

案例
for循环元祖
使用 for 循环，遍历元祖

tup = ("Hello", "HaiCoder")
for t in tup:
    print("t =", t)

程序运行后，控制台输出如下：

首先，我们定义了一个元祖类型的 变量 tup，接着使用 for循环来遍历该元祖，每次遍历后都使用 print 函数打印当前的遍历的值。

for循环列表
使用 for 循环，遍历列表

ls = ["Hello", "HaiCoder"]
for l in ls:
    print("l =", l)

程序运行后，控制台输出如下：

首先，我们定义了一个列表类型的变量 ls，接着使用 for 循环来遍历该列表，每次遍历后都使用 print 函数打印当前的遍历的值。

列表的遍历和元祖的遍历几乎是一样的。

for循环字典key
使用 for 循环，遍历字典所有 key

dic = {"Name":"HaiCoder", "Site":"haicoder.net", "Course":"Python"}
for d in dic:
    print("d =", d)

程序运行后，控制台输出如下：

首先，我们定义了一个字典类型的变量 dic，接着使用 for 循环来遍历该字典，每次遍历后都使用 print 函数打印当前的遍历的值。

使用 for 循环，遍历字典，获取的是字典的 key。

dic = {"Name":"HaiCoder", "Site":"haicoder.net", "Course":"Python"}
for key, val in dic.items():
    print("key =", key, "val =", val)

程序运行后，控制台输出如下：

首先，我们定义了一个字典类型的变量 dic，接着使用 for 循环来遍历该字典的 items，每次遍历后都使用 print 函数打印当前的遍历的值。

使用 for 循环，遍历字典的 items 时，返回的是 key 和 value，因此我们在 for 循环里面使用了两个变量来接受。

for循环字典值
使用 for 循环，遍历字典值

dic = {"Name":"HaiCoder", "Site":"haicoder.net", "Course":"Python"}
for val in dic.values():
    print("val =", val)

程序运行后，控制台输出如下：

首先，我们定义了一个字典类型的变量 dic，接着使用 for 循环来遍历该字典的 values，每次遍历后都使用 print 函数打印当前的遍历的值。

使用 for 循环，遍历字典的 values 时，返回的是 value。

Python for循环集合总结
Python 的 for 循环除了可以遍历数字、字符串还可以用来遍历元祖、列表、字典等数据类型。

使用 for 循环，遍历字典，获取的是字典的 key，如果使用 for 循环来遍历字典的 items 时，则获取的是字典的 key 和 value，如果使用 for 循环来遍历字典的 values 时，则获取的是字典的 value。

for循环嵌套

Python 的 for 循环 也可以实现嵌套的效果，即 for 循环里面嵌套一个或多个 for 循环。这种写法就类似于 python 的 if 语句 、else if 语句 和 else 语句 的嵌套。

Python for循环嵌套详解
语法

for i in cond1 {
    # do something
    for j in cond2 {
        for k in cond3{
        	# do something
    	}
    }
}

说明
这里，我们定义了三个 for 循环的嵌套，当然，我们可以嵌套任意多个的 for 循环。

案例
循环嵌套
使用循环嵌套，打印计数器

i = 0
j = 0
for i in range(3):
    print("i =", i)
    for j in range(2):
        print("\tj =", j)
print("Over")

程序运行后，控制台输出如下：

首先，我们定义了一个最外层的 for 循环嵌套，计数器 变量 i 从 0 开始，结束条件是 i < 3，每次执行一次循环将 i 的值加 1，并打印当前 i 的值。

在最外层循环的里面，同时又定义了一个内部循环，计数器变量 j 从 0 开始，结束条件是 i < 2，每次执行一次循环将 j 的值加 1，并打印当前 j 的值。

循环嵌套打印数列
使用循环嵌套，打印数列

i = 0
j = 0
for i in range(3):
    print("i =", i)
    for j in range(i):
        print("\tj =", j)
print("Over")

程序运行后，控制台输出如下：

首先，我们定义了一个最外层的 for 循环嵌套，计数器变量 i 从 1 开始，结束条件是 i < 3，每次执行一次循环将 i 的值加 1，并打印当前 i 的值。

在最外层循环的里面，同时又定义了一个内部循环，计数器变量 j 从 0 开始，结束条件是 j < i，每次执行一次循环将 j 的值加 1，并打印当前 j 的值。

Python for循环嵌套总结
Python 的 for 循环也可以实现嵌套的效果，即 for 循环里面嵌套一个或多个 for 循环。

打印乘法表

使用 for 循环嵌套，打印乘法表

使用 for循环嵌套，打印乘法表

for row in range(1, 10):
    for col in range(1, row+1):
        print("{0}x{1}={2:2}  ".format(col, row, row * col), end="")
    print("")

程序运行后，控制台输出如下：

首先，我们定义了一个外层循环，从 1 开始到 9 结束，表示一共需要打印的行数。接着，我们在该循坏里面继续定义了一个循环，从1 开始到 当前行的大小结束，表示需要打印的列数据。

我们在每一列的遍历里面，打印当前行的索引与列的索引的乘积，同时，每一行结束后，我们都打印一个换行。

Python while循环

说明
当 cond 条件为真时，一直执行缩进里面的代码块，直到 cond 条件为假，循环结束。

案例
while循环数字
使用 while 循环，遍历数字

num = 0
while num < 3:
    print('Num =', num)
    num = num + 1

程序运行后，控制台输出如下：

首先，我们定义了一个 整型类型 的 变量 num，并且赋值为 0，接着使用 while 循环来判断变量 num 是否小于 3，如果小于，则一直执行 print 的代码块，并且每次执行后都将 num 变量加 1。

while求和
使用 while 循环，求和

num = 0
sum = 0
while num <= 100:
    sum += num
    num += 1
print("Sum =", sum)

程序运行后，控制台输出如下：

首先，我们定义了一个整型类型变量 num 和 sum，并且都赋值为 0，接着使用 while 循环来判断变量 num 是否小于等于 100，如果成立，则一直将当前 sum 的值加上 num，并且每次执行后都将 num 变量加 1。

整个 while 循环执行完毕后，执行 print 的代码块，输出 Sum 的值。因为 print 语句不是在 while 循环的缩进代码块里面，而是跟 while 是平级的，因此 print 是 while 循环执行完毕才会执行的。

while循环列表
使用 while 循环，遍历列表

ls = ["Hello", "HaiCoder"]
i = 0
while i < len(ls):
    print(ls[i])
    i += 1
print("Over")

首先，我们定义了一个 列表类型 的变量 ls 和一个整型变量 i，接着使用 while 循环来遍历该列表，遍历的条件是当前的 i 的值小于列表的长度。

每次遍历后都使用 print 函数打印当前的遍历的值并且将变量 i 的值加 1。

使用 while循环，遍历元祖

tup = ("Hello", "HaiCoder")
i = 0
while i < len(tup):
    print(tup[i])
    i += 1
print("Over")

程序运行后，控制台输出如下：

首先，我们定义了一个 元祖类型 的变量 tup 和一个整型变量 i，接着使用 while 循环来遍历该元祖，遍历的条件是当前的 i 的值小于元祖的长度。

每次遍历后都使用 print 函数打印当前的遍历的值并且将变量 i 的值加 1。

Python while循环总结
Python 的 while 循环跟 if 条件判断类似，都是在特定条件满足的情况下，执行相对应的代码，不过，while 循环是只要条件满足，会一直执行缩进里面的代码块，这点又类似于 for 循环 。Python while 循环语法：

while cond：
    # do something

Python while循环嵌套详解

语法

while cond1:
    # do something
    while cond2:
        while cond3:
        	# do something

说明
这里，我们定义了三个 while 循环的嵌套，当然，我们可以嵌套任意多个的 while 循环。

案例
循环嵌套
使用循环嵌套，打印计数器

i = 0
while i < 3:
    print("i =", i)
    j = 0
    while j < 2:
        print("\tj =", j)
        j += 1
    i += 1
print("Over")

程序运行后，控制台输出如下：

首先，我们定义了一个最外层的 while 循环嵌套，计数器 变量 i 从 0 开始，结束条件是 i < 3，每次执行一次循环将 i 的值加 1，并打印当前 i 的值。

在最外层循环的里面，同时又定义了一个内部循环，计数器变量 j 从 0 开始，结束条件是 i < 2，每次执行一次循环将 j 的值加 1，并打印当前 j 的值。

循环嵌套打印数列
使用循环嵌套，打印数列

i = 0
while i < 3:
    print("i =", i)
    j = 0
    while j < i:
        print("\tj =", j)
        j += 1
    i += 1
print("Over")

程序运行后，控制台输出如下：

首先，我们定义了一个最外层的 while 循环嵌套，计数器变量 i 从 1 开始，结束条件是 i < 3，每次执行一次循环将 i 的值加 1，并打印当前 i 的值。

在最外层循环的里面，同时又定义了一个内部循环，计数器变量 j 从 0 开始，结束条件是 j < i，每次执行一次循环将 j 的值加 1，并打印当前 j 的值。

Python while循环嵌套总结
Python 的 while 循环也可以实现嵌套的效果，即 while 循环里面嵌套一个或多个 while 循环。

python while循环打印乘法表

我们使用 Python 的 while 循环 实现打印乘法表的功能。

打印乘法表
使用 while循环嵌套，打印乘法表

Python while循环打印乘法表

i = 1
while i<= 9:
    j = 1
    while j <= i:
        sum = j*i
        print("%dx%d=%2d" % (j,i,sum), end=("\t"))
        j += 1
    print()
    i += 1

程序运行后，控制台输出如下：

首先，我们定义了一个外层循环，从 1 开始到 9 结束，表示一共需要打印的行数。接着，我们在该循坏里面继续定义了一个循环，从1 开始到 当前行的大小结束，表示需要打印的列数据。

我们在每一列的遍历里面，打印当前行的索引与列的索引的乘积，同时，每一行结束后，我们都打印一个换行。

python break 语句

for i in range(10):
    if i >= 3:
        break
    print("i =", i)

程序运行后，控制台输出如下：

首先，我们定义了一个 for 循环，该循环从 0 开始到 10 结束，每次循环循环控制 变量 加 1，并打印当前循环控制变量的值。

但，我们这里使用了 if 语句 判断，如果循环控制变量的值已经大于等于 3 了，那么我们就使用 break 语句来终止循环，因此最终结果只输出了 0,1,2，因为到 3 的时候，整个循环被 break 语句终止了。

break语句终止双重循环
使用 break 语句，终止双重循环

print(“嗨客网(www.haicoder.net)”)

使用 break语句，终止双重循环

例如：

for i in range(3):
    for j in range(20):
        if j >= 2:
            break
        print("i =", i, "j =", j)
print("Over")

程序运行后，控制台输出如下：

首先，我们定义了一个 for 循环，该循环从 0 开始到 3 结束，每次循环循环控制变量加 1。

同时，我们在外层的 for 循环里面又定义了一个 for 循环，该循环从 0 开始到 20 结束，每次循环循环控制变量加 1，并在该循环里面打印循环控制变量 i 和 j 的值。

我们在第二层循环里面使用了 if 语句判断，如果循环控制变量的值已经大于等于 2 了，那么我们就使用 break 语句来终止循环，我们看到最终 j 的值最大只能输出到 1，但 i 的值可以全部输出，因为这的 break 语句只能终止内层的 for 循环，外层的 for 循环该 break 语句是无法终止的。
Python break语句总结
在 Python 中，终止循环的继续运行使用的关键字为 break。Python break 语句语法：

for i in range(num):
    # do something
	if condition:
        break

python continue语句

在我们使用 for 循环 时，在某种条件满足的情况下，需要跳过本次循环，继续执行下一次循环，在 Python 中，跳过本次循环的继续运行下一次循环使用的 关键字 为 continue。

注意 continue 与 break 的区别，break 是直接终止了当前的循环，当前的循环不会再运行，而 continue 只是跳过本次循环，当前循环的后续循环还会继续运行。

Python continue语句详解
语法

for i in range(num):
    # do something
	if condition:
        continue

说明
上面的循环是在 condition 条件满足的情况下，跳过本次 for 循环，继续执行下一次循环。

案例
continue语句跳过本次循环

for i in range(5):
    if i == 3:
        continue
    print("i =", i)
print("Over")

程序运行后，控制台输出如下：

首先，我们定义了一个 for 循环，该循环从 0 开始到 5 结束，每次循环循环控制 变量 加 1，并打印当前循环控制变量的值。

但，我们这里使用了 if 语句 判断，如果循环控制变量的值等于 3，那么我们就使用 continue 语句来跳过本次循环，因此最终结果只输出了 0,1,2,4 。

因为到 3 的时候，该次循环被 continue 语句跳过了，但后续的 4 还是会继续执行，如果这换成 break 语句，那么就不会输出 4。

continue语句跳过双重循环
使用 continue 语句，跳过双重循环

for i in range(3):
    for j in range(3):
        if j == 1:
            continue
        print("i =", i, "j =", j)
print("Over")

程序运行后，控制台输出如下：

首先，我们定义了一个 for 循环，该循环从 0 开始到 3 结束，每次循环循环控制变量加 1。

同时，我们在外层的 for 循环里面又定义了一个 for 循环，该循环从 0 开始到 3 结束，每次循环循环控制变量加 1，并在该循环里面打印循环控制变量 i 和 j 的值。

我们在第二层循环里面使用了 if 语句判断，如果循环控制变量的值等于 1，那么我们就使用 continue 语句来跳过本次循环，我们看到最终 j 的值输出了 0 和 2，但 i 的值可以全部输出。

因为这的 continue 语句只是跳过 j 为 1 的情况，所以 j 为 2 的循环可以继续运行。

Python continue语句总结
在 Python 中，跳过本次循环的继续运行下一次循环使用的关键字为 continue。Python continue 语句语法：

for i in range(num):
    # do something
	if condition:
        continue

Python break while 循环 *** 作

在我们使用 while 循环 时，在某种条件满足的情况下，需要终止循环的继续执行，在 Python 中，终止循环的继续运行使用的 关键字 为 break。

在 while 中，使用 break 结束循环的用法跟在 for 循环 中几乎是一样的。

Python break while循环详解
语法

while condition:
    # do something
	if condition1:
        break

说明
上面的循环是在 condition 条件满足的情况下，终止 while 循环。

案例
break语句终止while循环
使用 break 语句，终止 while 循环

i = 0
while i < 10:
    if i >= 3:
        break
    print("i =", i)
    i += 1

程序运行后，控制台输出如下：

首先，我们定义了一个 while 循环，该循环从 0 开始到 10 结束，每次循环循环控制 变量 加 1，并打印当前循环控制变量的值。

但，我们这里使用了 if 语句 判断，如果循环控制变量的值已经大于等于 3 了，那么我们就使用 break 语句来终止循环，因此最终结果只输出了 0,1,2，因为到 3 的时候，整个循环被 break 语句终止了。

break语句终止双重while循环
使用 break 语句，终止双重 while 循环

i = 0
while i < 3:
    j = 0
    while j < 20:
        if j >= 2:
            break
        print("i =", i, "j =", j)
        j += 1
    i += 1
print("Over")

程序运行后，控制台输出如下：

首先，我们定义了一个 while 循环，该循环从 0 开始到 3 结束，每次循环循环控制变量加 1。

同时，我们在外层的 while 循环里面又定义了一个 while 循环，该循环从 0 开始到 20 结束，每次循环循环控制变量加 1，并在该循环里面打印循环控制变量 i 和 j 的值。

我们在第二层循环里面使用了 if 语句判断，如果循环控制变量的值已经大于等于 2 了，那么我们就使用 break 语句来终止循环，我们看到最终 j 的值最大只能输出到 1，但 i 的值可以全部输出。

因为这的 break 语句只能终止内层的 while 循环，外层的 while 循环该 break 语句是无法终止的。

Python break while循环总结
在 Python 中，终止 while 循环的继续运行使用的关键字为 break。Python break 语句语法：

while condition:
    # do something
	if condition1:
        break