• 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 小于 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='	')      # 输出: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("33[31;31m%-2s33[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的格式输入:
    ")
    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的格式输入:
    ")
    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("请输入商品的编号:
    ")
     68     # 没有找到对应的商品,条码错误
     69     if code not in repository:
     70         print("条码错误,请重新输入")
     71         return
     72     # 根据代码找商品
     73     goods = repository[code]
     74     # 等待输入数量
     75     number = input("请输入购买数量:
    ")
     76     # 把商品和购买数量封装成 list 后加入购物清单中
     77     shop_list.append([code, int(number)])
     78 
     79 def edit():
     80     """修改购买商品的数量,就是修改代表用户购物清单的 list 列表的元素"""
     81     id = input("请输入要修改的购物明细项的ID:
    ")
     82     index = int(id) - 1
     83     # 根据索引获取某个购物明细项
     84     item = shop_list[index]
     85     # 提示输入新的购买数量
     86     number = input("请输入新的购买数量:
    ")
     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("
    " * 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("请输入操作指令: 
    " +
    111                 "    添加(a)  修改(e)  删除(d)  结算(p)  显示商品(s)
    ")
    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个实例,熟悉掌握流程控制、列表、元组、字典的功能和用法。
  • 相关阅读:
    Oracle between and 边界问题
    多线程——什么是并发与并行
    js:浅拷贝和深拷贝
    JavaScript中数组元素删除的七大方法汇总
    js 去掉字符串前面的0
    chrome总是提示"喔唷,崩溃啦"的解决办法
    智慧城市管理信息系统建设项目的架构分析
    利用DenseUNet深度神经网络数之联河湖遥感大数据的研究
    无人机+数字孪生助力河长制巡查方法探讨
    防汛可视化指挥平台“一张图”技术研究
  • 原文地址:https://www.cnblogs.com/Micro0623/p/11526766.html
Copyright © 2020-2023  润新知