码迷,mamicode.com
首页 > 其他好文 > 详细

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

时间:2019-09-16 14:40:57      阅读:114      评论:0      收藏:0      [点我收藏+]

标签:赋值   提示   目的   random   def   repos   类型   大小   商品   

循环语句在循环条件满足时,可反复执行某一段代码,这段被重复执行的代码称为循环体。在循环体中,需要在合适的时候把循环条件设置为假,从而结束循环;否则循环一直执行下去形成死循环。循环语句通常包含如下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 小于 510 1 小于 511 2 小于 512 3 小于 513 4 小于 514 循环计数器最后的数字是: 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,内层循环的值是:210 外层循环的值是: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个实例,熟悉掌握流程控制、列表、元组、字典的功能和用法。

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

标签:赋值   提示   目的   random   def   repos   类型   大小   商品   

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

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!