标签:赋值 提示 目的 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 小于 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个实例,熟悉掌握流程控制、列表、元组、字典的功能和用法。
part4-2 流程控制二(循环结构,while、for循环,列表推导式、生成器推导式,常用工具函数,控制循环结构,4个简单实例)
标签:赋值 提示 目的 random def repos 类型 大小 商品
原文地址:https://www.cnblogs.com/Micro0623/p/11526766.html