循环语句在循环条件满足时，可反复执行某一段代码，这段被重复执行的代码称为循环体。在循环体中，需要在合适的时候把循环条件设置为假，从而结束循环；否则循环一直执行下去形成死循环。循环语句通常包含如下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 1002 13 16 0903 14 15 0804 05 06 07给定5，应输出如下形式的数据：01 16 15 14 1302 17 24 23 1203 18 25 22 1104 19 20 21 1005 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个实例，熟悉掌握流程控制、列表、元组、字典的功能和用法。
