part4-2 流程控制二（循环结构，while、for循环，列表推导式、生成器推导式，常用工具函数，控制循环结构，4个简单实例）

循环语句在循环条件满足时，可反复执行某一段代码，这段被重复执行的代码称为循环体。在循环体中，需要在合适的时候把循环条件设置为假，从而结束循环；否则循环一直执行下去形成死循环。循环语句通常包含如下4个部分。
（1）、初始化语句（init_statements）：在循环开始前执行，有一条或多条语句，用于完成一些起初始化工作。
（2）、循环条件（test_expression）：一个布尔表达式，决定是否执行循环体。
（3）、循环体（body_statements）：循环的主体，根据循环条件是否允许，这个代码块是否重复执行。
（4）、迭代语句（iteration_statements）：一次循环体执行结束后，对循环条件求值之前执行，常用于控制循环条件中的变量，使得循环在合适的时候结束。

一、 while 循环

1、 while 循环语法格式：

[init_statements]
while test_expression:
    body_statements
    [iteration_statements]

在执行循环体前，while 先对 text_expression 循环条件求值，如果值为真，则执行循环体。迭代语句 iteration_statements 总是位于循环体最后，只有当循环体能成功执行时，while 循环才会执行迭代语句 iteration_statements。

在使用 while 循环时，要保证循环条件有变成假的可能，即退出循环的可能，否则循环将进入死循环。

2、while 循环可用于遍历列表和元组
列表和元组可通过索引来获取元素值，这个索引可通过 while 循环时进行传递。

示例：将一个随机整数列表分为3类，能整除3的归为一类列表，除3余1的归另一类列表，除3余2的归到第三类列表。代码如下：

 1 import random
 2 src_list = random.sample(range(10000), 20)
 3 a_list = []         # 存放整除3的元素
 4 b_list = []         # 存放除3余1的元素
 5 c_list = []         # 存放除3余2的元素
 6 
 7 # 根据 src_list 是否为空决定是否继续执行循环体
 8 while len(src_list) > 0:
 9     temp = src_list.pop()       # 默认取最后一个元素
10     if temp % 3 == 0:
11         a_list.append(temp)
12     elif temp % 3 == 1:
13         b_list.append(temp)
14     else:
15         c_list.append(temp)
16 print("整除3：", a_list)
17 print("除3余1：", b_list)
18 print("除3余2：", c_list)



二、 for-in 循环

1、 for-in 循环语法
for-in 循环专门用于遍历范围、列表、元组和字典等可迭代对象包含的元素。语法格式如下：
for 变量 in 字符串|范围|集合等：
    statements

对这个语法格式的两点说明：
（1）、for-in 循环中的变量（循环计数器）的值受 for-in 循环控制，该变量会在每次循环开始时自动被赋值，因此程序不应该在循环中对该变量赋值。
（2）、for-in 循环可用于遍历任何可迭代对象。所谓可迭代对象，是指该对象中包含一个 __iter__ 方法，且该方法的返回值对象具有 next() 方法。

for-in 可遍历范围，例如计算一个指定数的阶乘，示例如下：

1 num = int(input("请输入一个要计算阶乘的整数："))
2 result = 1
3 for i in range(1, num + 1):
4     result *= i
5 print(result)


2、 for-in 循环用于遍历列表和元组
for-in 循环在遍历列表和元组时，列表和元组有几个元素，for-in 循环的循环体就执行几次，针对每个元素执行一次，循环计算器会依次被赋值为元素的值。

示例，遍历列表，计算列表中所有数值元素的总和、平均值。

 1 src_list = [100, 15, -20, 3.14, 0.732, 'python', 10.625, 'linux', 33.33]
 2 num_sum = 0
 3 num_count = 0
 4 for ele in src_list:
 5     # 判断元素是否是整数或者浮点数
 6     if isinstance(ele, int) or isinstance(ele, float):
 7         num_sum += ele      # 累加元素
 8         num_count += 1      # 计数数值元素个数
 9 print("总和是：", num_sum)
10 print("平均数是：", num_sum / num_count)


这里使用 Python 的 isinstance() 函数，这个函数用于判断某个变量是否为指定类型的实例，第一个参数是要判断的变量，第二参数是类型。isinstance() 函数对变量做类型判断时非常方便、有效。

3、 使用 for-in 循环遍历字典
for-in 循环遍历字典时，实际遍历的是普通列表。字典有3个方法可返回对应的列表，分别是：items()、keys()、values()。遍历字典先调用这三个方法之一再进行遍历。示例如下：

 1 persons = {'name': 'michael', 'age': 25, 'id': 91029280}
 2 # 通过 items() 方法遍历字典所有的 key-value 对
 3 # items() 方法返回的列表元素是 key-value 对，因此要声明两个变量
 4 for k, v in persons.items():
 5     print('key: ', k)
 6     print('value: ', v)
 7 # enumerate() 函数可以生成一个编号，默认从0开始，也可指定起始编号
 8 for i, (k, v) in enumerate(persons.items(), 1):
 9     print('%d、key: %s; value: %s' % (i, k, v))
10 # 通过 keys() 方法遍历字典的 key ，通过 key 获取 value
11 for k in persons.keys():
12     print("key: %s; value: %s" % (k, persons[k]))
13 # 通过 values() 方法遍历字典所有的 value
14 for i, v in enumerate(persons.values(), 1):
15     print("%d、%s;" % (i, v))


4、 在循环中使用 else

在 Python 中循环可以定义 else 代码块，当循环条件为 False 时，程序就执行 else 代码块。在 for 循环后面使用 else 代码块时，当 for 循环区间、元组或列表的所有元素后，就会执行 else 代码块，在 else 代码块中，循环计算数器的值依然等于最后一个元素的值。示例如下：
示例1：while 循环中使用 else

 1 count = 0
 2 while count < 5:
 3     print("%d 小于 5；" % count)
 4     count += 1
 5 else:
 6     print("循环计数器最后的数字是：", count)
 7 
 8 运行代码，输出如下：
 9 0 小于 5；
10 1 小于 5；
11 2 小于 5；
12 3 小于 5；
13 4 小于 5；
14 循环计数器最后的数字是： 5


示例2：for 循环中使用 else

 1 for i in range(5):
 2     print("当前数字是：", i)
 3 else:
 4     print("循环计数器最后的数字时：", i)
 5 
 6 运行代码，输出如下：
 7 当前数字是： 0
 8 当前数字是： 1
 9 当前数字是： 2
10 当前数字是： 3
11 当前数字是： 4
12 循环计数器最后的数字时： 4


从上面两个示例可知，只要循环语句成功执行完，后面的 else 代码块都会被执行，并且循环计数器是最后一次循环或者结束循环时的值。

5、 嵌套循环
把一个循环放在另一个循环体内就形成嵌套循环。嵌套循环可以是 for-in 循环嵌套 while 循环，也可以是 while 循环嵌套 for-in 循环......,各种类型的循环都可以做为外层循环，同时也可做为内层循环。

对于循环次数问题，假设外层循环的循环次数为 n 次，内层循环的循环次数为 m 次，那么内层循环的循环体实际执行次数是 n*m 次。
示例如下：

 1 for i in range(5):      # 外层循环
 2     j = 0
 3     while j < 3:        # 内层循环
 4         print("外层循环的值是：%d，内层循环的值是：%d；" % (i, j))
 5         j += 1
 6 运行这段代码，输出如下：
 7 外层循环的值是：0，内层循环的值是：0；
 8 外层循环的值是：0，内层循环的值是：1；
 9 外层循环的值是：0，内层循环的值是：2；
10 外层循环的值是：1，内层循环的值是：0；
11 ......

循环嵌套可以有多层，如三层、四层......，不管怎样嵌套，内层循环体都当成外层循的循环体来对待。

6、 for 表达式（列表推导式、生成器推导式）
for 表达式用于将其他区间、元组、列表等可迭代对象创建新的列表，语法如下：
[表达式 for 循环计数器 in 可迭代对象 [if条件]]

for 表达式与普通 for 循环区别：
（1）、在 for 关键字之前定义一个表达式，该表达式通常会包含循环计数器。
（2）、for 表达式没有循环体，因此不需要冒号。实际上表达式就是循环体。

for 循环的循环次数由可迭代对象中的对象个数决定。for 表达式最终返回的是列表，因此 for 表达式也被称为列表推导式。示例如下：
# 计算数字的平方
num_list = [i * i for i in range(10)]
print(num_list)     # 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

在 for 表达式后面可以接 if 条件，这样for 表达式将只迭代那些符合条件的元素。示例如下：
# 计算偶数的平方
num_list = [i * i for i in range(10) if i % 2 == 0]
print(num_list)     # 输出：[0, 4, 16, 36, 64]

将 for 表达式的方括号改为圆括号，for 表达式生成的不再是列表，而是生成一个生成器（generator），生成器可用于 for 循环迭代。也叫作生成器推导式。示例如下：

1 # 使用 for 表达式创建生成器
2 a_generator = (x * x for x in range(10) if x % 2 == 0)
3 print(type(a_generator))        # 输出：<class 'generator'>
4 # 使用for循环迭代生成器
5 for i in a_generator:
6     print(i, end='\t')      # 输出：0       4       16      36      64
7 print()

在 for 表达式中还可以使用多个循环，就像嵌套循环一样。例如下面的示例中使用两个 for 循环，示例如下：
b_list = [(i, j) for i in range(3) for j in range(2)]
print(b_list)       # 输出：[(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]

这里 i 是第一个循环遍历 range(3) 的计数器，因此 i 可迭代 3 次；j 是第二个循环遍历 range(2) 的计数器，因此 j 可迭代 2 次。最终 (x, y)表达式会迭代 6 次。上面的 for 表达式等价于下面嵌套循环：

1 bb_list = []
2 for i in range(3):
3     for j in range(2):
4         bb_list.append((i, j))


同样的，for 循环支持的三层嵌套表达式示例如下：
c_list = [[i, j, k] for i in range(3) for j in range(4) for k in range(5)]
print(len(c_list))          # 输出：60

对于包含多个循环的 for 表达式，同样可指定 if 条件。for 循环表达式应用：现在将两个列表中的数值按“能否整除”进行配对，比如第一个列表 src_a 中的15与第二个列表 src_b 中的 5 可以整除，就将这两个数配对在一起。对于这个需求，用 for 表达式来实现比较容易，示例如下：
src_a = [15, 51, 144, 67, 83, 76, 96]
src_b = [2, 3, 5, 12]
results = [(i, j) for i in src_a for j in src_b if i % j == 0]
print(results)
运行这段代码，输出如下：
[(15, 3), (15, 5), (51, 3), (144, 2), (144, 3), (144, 12), (76, 2), (96, 2), (96, 3), (96, 12)]

7、 常用工具函数

（1）、 zip()函数
可将多个列表、元组、字符串序列“压缩”成一个 zip 对象（可迭代对象），这样可以用一个循环并行遍历多个列表、元组、字符串。如果zip()函数压缩的多个序列长度不相等，则以长度更短的序列为准。如果 zip() 函数压缩N个序列，那么 zip() 函数返回的可迭代对象的元素是长度为N的元组。示例如下：
a = ('a', 'b')
b = (1, 2)
print([i for i in zip(a, b)])       # 输出：[('a', 1), ('b', 2)]
c = 'abc'
d = '123'
print([i for i in zip(c, d)])       # 输出：[('a', '1'), ('b', '2'), ('c', '3')]
print([i for i in zip(a, d)])       # 压缩元组和字符串，输出：[('a', '1'), ('b', '2')]

在 Python 2.x 版本中，zip() 函数返回是列表，不是 zip 对象。最终得到的元素是相同的。简单应用示例：

1 subjects = ['语文', '数学', '英语']
2 scores = [83, 95, 90]
3 # 使用 zip() 函数压缩两个列表，实现并行遍历
4 for i in zip(subjects, scores):
5     print("%s 的分数是 %5.2f" % (i[0], i[1]))
6 运行上面的代码，输出如下所示：
7 语文 的分数是 83.00
8 数学 的分数是 95.00
9 英语 的分数是 90.00


（2）、reversed()函数
该函数可接收各种序列（字符串、元组、列表、区间）参数，返回一个“反序排列”的迭代器，该函数对参数本身不会产生任何影响。示例如下：
s = 'abcde'
# 使用 reversed()函数反转字符串，字符串本身不会发生改变
print([i for i in reversed(s)])     # 输出：['e', 'd', 'c', 'b', 'a']

（3）、 sorted()函数
该函数实现排序功能，参数是一个可迭代对象，返回一个对元素排序的列表。默认是降序排序（从大到小），可指定 reverse=True 参数表明按升序排序（从小到大）。此外，该函数还可传入一个 key 参数，参数值是一个函数名，根据一个指定函数来生成排序的关键值，例如对字符串按长度排序时，key 参数可传入 len 函数。示例如下：
s = 'abcde'
sorted(s)                               # 对字符串排序，输出：['a', 'b', 'c', 'd', 'e']
sorted(s, reverse=True)       # 反向排序，输出：['e', 'd', 'c', 'b', 'a']
s_lists = ['python', 'linux', 'java', 'c', 'c++', 'go', 'sh']
sorted(s_lists, key=len)        # key 参数是值是函数名 len，输出如下：
['c', 'go', 'sh', 'c++', 'java', 'linux', 'python']
for i in sorted(s_lists, key=len):      # 对排序后的结果进行迭代
    print(s)

三、控制循环结构

Python 没有提供 goto 语句控制程序跳转，但是提供了 continue 和 break 来控制循环结构。此外，使用 return 可以结束整个方法。

1、使用 break 结束循环
break 用于完全结束一个循环，跳出循环体。不管哪种循环体，只要在循环中遇到 break，系统就完全结束循环，开始执行循环之后的代码。示例如下：

1 for i in range(10):
2     print("i 的当前值是：", i)
3     if i == 3:
4         break   # 执行到该语句退出循环
5     else:
6         print("else 代码块：", i)

运行这段代码，循环计数器 i 等于 3 时就结束循环，后面的 else 代码块也不会再执行。但是循环体后面的代码还是会继续执行。

另外，break 语句中止的是本次循环，对于有嵌套循环的，不可以结束嵌套循环的外层循环。如果要跳出外层循环，通常要使用某个标志来判断是否跳出外层循环，然后在内外层循环中分别使用两条 break 语句来实现。示例如下：

1 flag = False
2 for i in range(5):
3     for j in range(3):
4         print("i 的值为：%d，j 的值为：%d" % (i, j))
5         if j == 1:
6             flag = True
7             break       # 结束内层循环
8     if flag:
9         break       # 结束包层循环


2、 使用 continue 忽略本次循环的剩下语句
countinue 只忽略当次循环剩下的语句，接着开始下一次循环，并不会中止循环。示例如下：

 1 for i in range(3):
 2     print("i 的值是：", i)
 3     if i == 1:
 4         continue        # 忽略本次循环剩下的语句
 5     print("continue 后的输出语句")
 6 输出如下：
 7 i 的值是： 0
 8 continue 后的输出语句
 9 i 的值是： 1
10 i 的值是： 2
11 continue 后的输出语句


3、 使用 return 结束方法
return 用于从包围它的最直接方法、函数或匿名函数返回。当函数或方法执行到一条 return 语句时（return 关键字后可以跟变量、常量、表达式），这个函数或方法将被结束执行。return 不管处于多少个循环内，都会直接结束整个函数或方法。示例如下：

1 def foo():
2     for i in range(10):
3         for j in range(10):
4             print("i 的值是：%d, j 的值是：%d" % (i, j))
5             if j == 1:
6                 return
7             print("return 后的输出语句")
8 foo()


四、简单运用

1、数字转人民币读法
功能：将一个浮点数转换成人民币读法的字符串。
思路：首先把浮点数分成整数部分和小数部分，整数部分可通过强制转换成一个整数即可，至于小数部分，可用这个浮点数减去整数得到。接下分开处理整数部分和小数部分，对小数部分的处理，直接保留两位小数，转换成几角几分的字符串。对整数部分的处理要复杂点，整数可分为4个数字一组进行处理，从右边开始，将数字分组，例如第一组的读法是几千几百几十，至于要添加的单位，出现在右边第一组的4位数字添加“元”；出现在第二组（5~8位）则添加单位“万”；出现第三组（9~12位）则添加单位“亿”；多于12位暂时不考虑。程序如下：

 1 """
 2 把一个浮点数分解成整数部分和小数部分字符串
 3 num 是需要分解的浮点数
 4 返回分解出来的整数部分和小数部分
 5 第一个数组元素是整数部分，第二数组元素是小数部分
 6 """
 7 def divide(num):
 8     if isinstance(num, float):
 9         # 将浮点数强制转化成为 int 类型，得到整数部分
10         integer = int(num)
11         # 浮点数减去整数部分，得到小数部分，小数乘以100后再取整，得到2位小数
12         fraction = round((num - integer) * 100)
13         # 把数字转换为字符串返回，并用元组形式返回
14         return (str(integer), str(fraction))
15     else:
16         print("%s 不是浮点数，请使用正确的浮点数！")
17         return
18 
19 han_list = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"]
20 unit_list = ["拾", "百", "千"]
21 jf_list = ["角", "分"]
22 
23 """
24 把一个4位的数字字符串就汉字字符串，
25 num_str 是要被转换的 4 位数字字符串
26 返回 4 位数字字符串被转换成汉字字符串
27 """
28 def is_zero(n):
29     return True if n == 0 else False
30 
31 def four_to_hanstr(num_str):        # 12, 0123, 0012,10300567，末尾有0不读，头部有0读一次，中间有0要读，中间有多个0读一次
32     result = ""
33     if int(num_str) == 0:       # 数字为全0，则都不用读
34         return result
35     num_len = len(num_str)
36     # 依次遍历数字字符串的每一位数字
37     for i in range(num_len):
38         # 把字符串转换成数值
39         num = int(num_str[i])
40         # 如果不是最后一位数字，而且数字不为零，则需要添加单位（千、百、十）
41         if i != num_len - 1 and num != 0:
42             result += han_list[num] + unit_list[num_len - 2 - i]
43         # 否则不添加单位
44         else:
45             result += han_list[num]
46     return result
47 
48 """
49 把数字字符串变成汉字字符串
50 num_str 是需要被转换的数字字符串
51 返回数字字符串被转换汉字字符串
52 """
53 def integer_to_str(num_str, num2_str):
54     str_len = len(num_str)
55     str2_len = len(num2_str)
56     jf_str = ""
57     if str2_len == 1 and int(num2_str) != 0:
58         jf_str += han_list[int(num2_str)] + "分"
59     elif str2_len > 1:
60         if int(num2_str[0]) > 0:
61             jf_str += han_list[int(num2_str[0])] + "角"
62         if int(num2_str[1]) > 0:
63             jf_str += han_list[int(num2_str[1])] + "分"
64     if str_len > 12:
65         print("数字太大，不能翻译！")
66         return
67     # 如果数字大于8位，包含单位：亿
68     elif str_len > 8:
69         return four_to_hanstr(num_str[:-8]) + "亿" + \
70             four_to_hanstr(num_str[-8: -4]) + "万" + \
71             four_to_hanstr(num_str[-4:]) + "元" + jf_str
72     # 如果大于4位，包含单位：万
73     elif str_len > 4:
74         return four_to_hanstr(num_str[:-4]) + "万" + \
75             four_to_hanstr(num_str[-4:]) + "元" + jf_str
76     else:
77         return four_to_hanstr(num_str) + "元" + jf_str
78 
79 num = float(input("请输入一个浮点数："))
80 integer, fraction = divide(num)     # 调用函数，将浮点数分成整数和小数部分
81 print(integer_to_str(integer, fraction))


运行程序，结果如下：
请输入一个浮点数：250683001.378
贰亿伍千零陆拾捌万叁千零零壹元叁角捌分

在这个程序中，对0的处理还不够完善，还需要进一步修改代码以便对0进行处理。

2、数字绕圈圈
要求是：给定一个数，按照指定的数输出指定形式的数据。例如。
给定4，应输出如下形式的数据：
01 12 11 10
02 13 16 09
03 14 15 08
04 05 06 07

给定5，应输出如下形式的数据：
01 16 15 14 13
02 17 24 23 12
03 18 25 22 11
04 19 20 21 10
05 06 07 08 09
......

从上面2个数的规律可以现，程序是在“绕圈圈”填入整数，可将右上角到左下角划分为一号转弯线，在右上角是向左转，在左下角是向右转。将右下角到中心划分为二号转弯线，在右下角是向上转。将左上角到中心划分为三号转弯线，在左上角是向下转。有了这个规律，可使用嵌套列表（二维列表）来存储这些整数，将数值存入嵌套列表要遵守这种“绕圈圈”的规则，最后以二维方式将列表打印出来。

绕圈程序的关键点就是控制绕圈的拐弯点。根据一、二、三号转弯线，可以发现下面规律：
（1）、在一号转弯线上的行索引与列索引之和等于 n-1（即给定整数值减 1）。
（2）、在二号转弯线上的行索引与列索引相等。
（3）、在三号转弯线上的行索引等于列索引减1。
有了这个规律，下面开始正式编写程序。

 1 def num_round(n):
 2     array = [[0] * n]
 3     # 创建一个 n 行 * n 列的列表
 4     for i in range(n - 1):
 5         array += [[0] * n]
 6     # orient 代表绕圈方向，0 代表向下，1 代表向右，2 代表向左，3 代表向上
 7     orient = 0      # 初始默认向下
 8     # 控制将 1 ~ n*n 的数值填入二维列表中
 9     # j 控制行索引，k 控制列索引
10     j, k = 0, 0
11     for i in range(1, n * n + 1):
12         array[j][k] = i
13         # 如果位于 1 号转弯线上的情况
14         if j + k == n - 1:
15             # j > k 时，位于左下角
16             if j > k:
17                 orient = 1  # 改变绕圈方向向右
18             # 位于右上角的情况
19             else:
20                 orient = 2  # 改变绕圈方向向左
21         # 如果位于 2 号转弯线上并且在左下角的情况
22         elif (k == j) and (k >= n / 2):
23             orient = 3      # 改变绕圈方向向上
24         # 如果位于 3 号转弯线上的情况
25         elif (j == k - 1) and (k <= n / 2):
26             orient = 0      # 改变绕圈方向向下
27         # 根据方向来控制行索引、列索引的改变
28         # 如果方向为向下绕圈
29         if orient == 0:
30             j += 1
31         # 如果方向为向右绕圈
32         elif orient == 1:
33             k += 1
34         # 如果方向为向左绕圈
35         elif orient == 2:
36             k -= 1
37         # 如果方向为向上绕圈
38         elif orient == 3:
39             j -= 1
40     return array
41 
42 def print_array(n, array):
43     # 采用遍历方式输出二维列表
44     for i in range(n):
45         for j in range(n):
46             print('%02d ' % array[i][j], end="")
47         print()
48 
49 
50 n = int(input("请输入一个整数："))
51 arr = num_round(n)
52 print_array(n, arr)

这段程序的重点是在 num_round 函数中 for 循环后面的第一个 if判断及后面两个elif 判断语句，这几行代码控制当处于转弯线上时绕圈的方向。只要正确控制了绕圈方向，就可通过对 j、k 索引的增减来控制绕圈。

3、 控制台五子棋
用二维列表来实现五子棋。首先定义一个二维列表作为棋盘，当玩家下一步棋时，也就是给二给维列表的一个数组元素赋值。代码如下：

 1 BOARD_SIZE = 16         # 定义棋盘大小
 2 board = []              # 定义一个二维列表做棋盘
 3 def initBoard():
 4     # 把每个元素赋为"┼"，用于在控制台画出棋盘
 5     for i in range(BOARD_SIZE):
 6         row = ["┼"] * BOARD_SIZE
 7         board.append(row)
 8         # 给棋盘添加横坐标和纵坐标
 9         board[0][i] = i
10         board[i][0] = i
11 
12 def printBoard():
13     """在控制台输出棋盘的方法"""
14     # 打印每个列表元素
15     for i in range(BOARD_SIZE):
16         for j in range(BOARD_SIZE):
17             if board[i][j] == "●":
18                 # 给棋子加上颜色，end="" 表示不换行
19                 print("\033[31;31m%-2s\033[0m" % board[i][j], end="")
20             else:
21                 print("%-2s" % board[i][j], end="")
22         print()     # 打印完一行，输出一个换行符
23 
24 def main():
25     initBoard()
26     printBoard()
27     inputStr = input("请输入下棋的坐标，以x, y的格式输入：\n")
28     while inputStr != None:
29         x_str, y_str = inputStr.split(sep=",")
30         # board[int(x_str) - 1][int(y_str) - 1] = "●"    # 为对应的元素赋值 "●"
31         board[int(x_str)][int(y_str)] = "●"    # 为对应的元素赋值 "●"
32         '''
33         这里还需要实现的功能是：电脑随机生成两个整数，作为电脑下棋的坐标，赋值给board列表，要做到下面3点：
34         1、坐标的有效性，只能是数字，不能超出棋盘范围；
35         2、下棋的点，不能重复下棋；
36         3、每次下棋后，需要扫描谁赢了
37         '''
38         printBoard()
39         inputStr = input("请输入下棋的坐标，以x, y的格式输入：\n")
40 
41 main()

这段代码未完成电脑下棋，或者双人对战的情况。要完成这个功能，需要判断玩家和电脑下棋的坐标上不能有棋子，并且还需要进行4次循环扫描，判断横、竖、左斜、右斜是否有5颗棋子连在一起来判定胜负。

4、 控制台超市系统
控制台超市系统可让用户为程序提供命令进行购物。目的在于练习列表、字典、元组等数据结构用法，代码中用到的数据如下：
（1）、用元组代表商品，元组中包含商品编号、名称、单价。
（2）、用字典表示系统中当前仓库中的所有商品，字典的键是商品编号，值是商品元组。
（3）、用列表来记录用户的购物清单，列表的元素代表购物明细项，每个明细项也是一个列表。

该程序的主要功能如下：
（1）、显示当前超市的商品清单：遍历字典的 values() 方法返回值即可。
（2）、显示用户的购物清单：遍历代表用户购物清单的列表，可显示用户的购物清单。
（3）、用户修改购买商品的数量：修改代表用户购物清单的列表中的元素。
（4）、用户删除已购买的商品：删除代表用户购物清单列表中的元素。
代码如下：

  1 repository = dict()         # 定义仓库
  2 shop_list = []              # 定义购物清单对象
  3 
  4 def init_repository():
  5     """用一个函数来初始化商品"""
  6     # 每个元组爱代表一个商品
  7     goods1 = ('10000001', 'Python基础入门', 59.9)
  8     goods2 = ('10000002', 'Python入门到提高', 65.9)
  9     goods3 = ('10000003', 'Python进阶开发', 69.9)
 10     goods4 = ('10000004', 'Python网络编程', 77.9)
 11     goods5 = ('10000005', 'Python核心编程', 79.9)
 12     goods6 = ('10000006', 'Python从入门到放弃', 113.9)
 13     # 把商品放入字典中
 14     repository[goods1[0]] = goods1
 15     repository[goods2[0]] = goods2
 16     repository[goods3[0]] = goods3
 17     repository[goods4[0]] = goods4
 18     repository[goods5[0]] = goods5
 19     repository[goods6[0]] = goods6
 20 
 21 def show_goods():
 22     """遍历代表仓库的字典，显示超市的商品清单"""
 23     print("Welecome Python Shopmarkt")
 24     print("Python Shop lists:")
 25     print("%13s%40s%10s" % ('条码', '商品名称', '单价'))
 26     # 遍历 repository 字典中所有值来显示商品清单
 27     for goods in repository.values():
 28         print("%15s%40s%12s" % goods)
 29 
 30 def show_list():
 31     """显示购物清单，即遍历代表购物清单的list列表"""
 32     print("=" * 100)
 33     # 如果清单不为空，则输出清单的内容
 34     if not shop_list:
 35         print("未购物任何商品")
 36     else:
 37         title = "%-5s|%15s|%40s|%10s|%4s|%10s" % \
 38                 ("ID", "条码", "商品名称", "单价", "数量", "小计")
 39         print(title)
 40         print("-" * 100)
 41         # 计录总计的价钱
 42         sum = 0
 43         # 遍历代表购物清单的 list 列表
 44         for i, item in enumerate(shop_list, 1):
 45             # 获取该购物明细项的第1个元素：商品编号
 46             code = item[0]
 47             # 根据商号获取商品及商品名称
 48             name = repository[code][1]
 49             # 获取商品价格
 50             price = repository[code][2]
 51             # 获取商品数量
 52             number = item[1]
 53             # 小计
 54             amount = price * number
 55             sum = sum + amount
 56             line = "%-5s|%17s|%40s|%12s|%6s|%12.2f" % \
 57                    (i, code, name, price, number, amount)
 58             print(line)
 59         print("-" * 100)
 60         s = "总计: " + str("%.2f" % sum)
 61         print("%98s" % s)
 62     print("=" * 100)
 63 
 64 def add():
 65     """添加购买的商品，就是向代表用户购物清单的 list 列表中添加一项"""
 66     # 等待输入编号
 67     code = input("请输入商品的编号：\n")
 68     # 没有找到对应的商品，条码错误
 69     if code not in repository:
 70         print("条码错误，请重新输入")
 71         return
 72     # 根据代码找商品
 73     goods = repository[code]
 74     # 等待输入数量
 75     number = input("请输入购买数量：\n")
 76     # 把商品和购买数量封装成 list 后加入购物清单中
 77     shop_list.append([code, int(number)])
 78 
 79 def edit():
 80     """修改购买商品的数量，就是修改代表用户购物清单的 list 列表的元素"""
 81     id = input("请输入要修改的购物明细项的ID：\n")
 82     index = int(id) - 1
 83     # 根据索引获取某个购物明细项
 84     item = shop_list[index]
 85     # 提示输入新的购买数量
 86     number = input("请输入新的购买数量：\n")
 87     # 修改 item 里面的 number
 88     item[1] = int(number)
 89 
 90 def delete():
 91     """删除已购买的商品明细项，就是删除代表用户购物清单的 list 列表的元素"""
 92     id = input("请输入要删除的购物明细项的 ID: ")
 93     index = int(id) - 1
 94     # 直接根据索引从清单里面删除购物明细项
 95     del shop_list[index]
 96 
 97 def payment():
 98     # 先打印清单
 99     show_list()
100     print("\n" * 2)
101     print("欢迎下次光临！")
102     # 退出程序
103     import os
104     os._exit(0)
105 
106 cmd_dict = {'a': add, 'e': edit, 'd': delete, 'p':payment, 's': show_goods}
107 
108 def show_command():
109     """显示命令提示"""
110     cmd = input("请输入操作指令： \n" +
111                 "    添加(a)  修改(e)  删除(d)  结算(p)  显示商品(s)\n")
112     # 如果输入的指令未找到
113     if cmd not in cmd_dict:
114         print("输入的指令未知。")
115     else:
116         cmd_dict[cmd]()     # 根据输入的指令调用相应的函数
117 
118 init_repository()
119 show_goods()
120 # 显示清单和操作命令提示
121 while True:
122     show_list()
123     show_command()

在这个超市控制台程序中，使用了 def 关键字定义的几个函数，用于将程序各功能划分到单独的函数中。
show_goods()：显示超市商品清单，通过遍历仓库的 repository 中的 values() 返回值完成。
show_list()：显示用户的购物清单，通过遍历代表用户购物清单的 shop_list完成。
add()：添加购买商品，通过代表用户购物清单的 shop_list 中添加元素来完成。
edit()：修改商品数量，通过修改代表用户购物清单的 shop_list 中的元素完成。
delete()：删除已购买的商品，通过删除代表用户购物清单的 shop_list 中的元素完成。

此外，还可以通过输入命令进行相应的操作，这样简单实现了交互效果。

五、小结

1、Python常用的两种程序流程结构：分支结构和循环结构。
2、if 分支结构可作为语句使用，也可作为表达式使用，要灵活使用。
3、注意区别和联系 while 和 for-in 循环结构。
4、break、continue 用于控制循环，其中 break 用于跳出本次循环；continue 用于忽略当次循环剩下的语句，重新开始下一次循环。
5、通过4个实例，熟悉掌握流程控制、列表、元组、字典的功能和用法。

原文地址：https://www.cnblogs.com/Micro0623/p/11526766.html