疯狂Python讲义学习笔记（含习题）之流程控制

最新推荐文章于 2022-08-10 14:13:59 发布

zhouyong80

最新推荐文章于 2022-08-10 14:13:59 发布

阅读量932

点赞数 2

分类专栏： Python3学习文章标签： Python 控制流程疯狂Python讲义习题答案

本文链接：https://blog.csdn.net/zhouyong80/article/details/102559552

版权

Python3学习专栏收录该内容

17 篇文章 7 订阅

订阅专栏

Python支持两种基本流程控制结构：分支结构和循环结构。分支结构用于实现根据条件来选择性地执行某段代码；循环结构用户实现根据循环条件重复执行某段代码。

Python使用if语句提供分支支持，使用while、for-in提供循环支持，同时也提供了break和continue来控制循环。

一、顺序结构

顺序结构就是程序从上到下一行行地执行，中间没有任何判断和跳转。

二、if分支结构

if分支使用布尔表达式或布尔值作为分支条件来进行分支控制。

三种形式：

if expression:
    statements....

if expression:
    statements...
else:
    statements...

if expression:
    statements...
elif expression:
    statements...
...// 可以有零条或多条elif语句
else:
    statement...

Python的代码块是通过缩进来标记的（大部分语言都使用花括号或end作为代码块的标记），具有相同缩进的多行代码属于同一个代码块。

Python通常建议缩进4个空格。

if、else、elif后的条件执行体必须使用相同缩进的代码块，将这个代码块作为条件执行体。

位于同一个代码块中的所有语句必须保持相同的缩进，既不能多，也不能少。

从Python语法解释器的角度来看，Python冒号精确表示代码块的开始点。

一下值：False、None、0、""、（）、[]、{}会被解释器当做False处理。

在使用if else语句时有一条基本规则：总是优先把包含范围小的条件放在前面处理。

Python的pass语句就是空语句。

三、断言

用于对一个bool表达式进行断言，如果bool表达式为True，该程序可以继续向下运行；否则程序会引发AssertionError异常。

s_age = input("请输入您的年龄：")
age = int(s_age)
assert 20 < age < 80
print("您输入的年龄在20和80之间")

运行结果：

请输入您的年龄：23
您输入的年龄在20和80之间

请输入您的年龄：1
Traceback (most recent call last):
  File "g:/code/python/crazy_python/chapter4/assert_test.py", line 3, in <module>
    assert 20 < age < 80
AssertionError

断言可以对逻辑表达式进行判断，实际上断言也相当于一种特殊的分支。

assert断言的执行逻辑是：

if 条件为False:

程序引发AssertionError错误

四、循环结构

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被成为循环体。当反复执行这个循环体时，需要在合适的时候把循环条件改为假，从而结束循环；否则将形成死循环。循环语句可能包含如下4个部分：

● 初始化语句（init_statements）：一条或多条语句，用于完成一些初始化工作。初始化语句在循环开始之前执行。

● 循环条件（test_expression)：一个布尔表达式，这个表达式能决定是否执行循环体。

● 循环体（body_statements）：循环的主体，如果循环条件允许，这个代码块将被重复执行。

● 迭代语句（iteration_statements）：在一次执行循环体结束后，对循环条件求值之前执行，通常用于控制循环条件中的变量，是的循环适时结束。

（一）while循环

语法格式：

[init_statements]
while test_expression:
    body_statements
    [iteration_statements]

（二）for-in循环

语法格式：

for 变量 in 字符串|范围|集合等:
    statements

● for-in循环中的变量的值受for-in循环控制，该变量将会在每次循环开始时自动被赋值，因此程序不应该在循环中对该变量赋值

● for-in循环可用于遍历任何可迭代对象。所谓可迭代对象，就是指该对象中包含一个__iter__方法，切该方法的返回值对象具有next()方法。

（三）循环使用else

Python的循环都可以定义else代码块，当循环条件为False时，程序会执行else代码块。

count_i = 0
while count_i < 5:
    print('count_i小于5：', count_i)
    count_i += 1
else:
    print('count_i大于或等于5：', count_i)

运行结果：

count_i小于5： 0
count_i小于5： 1
count_i小于5： 2
count_i小于5： 3
count_i小于5： 4
count_i大于或等于5： 5

for循环同样可以使用else代码块，当for循环把区间、元组或列表的所有元素遍历一次之后，for循环会执行else代码块，在else代码块中，循环计数器的值依然等于最后一个元素的值。

a_list = [330, 1.4, 50, 'fkit', -3.5]
for ele in a_list:
    print('元素：', ele)
else:
    # 访问循环计数器的值，依然等于最后一个元素的值
    print('else块：', ele)

运行结果：

元素： 330
元素： 1.4
元素： 50
元素： fkit
元素： -3.5
else块： -3.5

（四）嵌套循环

把一个循环放在另一个循环体内就形成了嵌套循环。

（五）for表达式

语法格式：

[表达式 for 循环计数器 in 可迭代对象]

将for表达式的方括号改为圆括号，for表达式将不再生成列表，而是生成一个生成器（generator），该生成器同样可使用for循环迭代。

for表达式可以使用多个循环，就先嵌套循环一样：

d_list = [(x, y) for x in range(5) for y in range(4)]
# d_list列表包含20个元素
print(d_list)

（六）常用工具函数

使用zip()函数可以把两个列表“压缩”成一个zip对象（可迭代对象）,这样可以使用一个循环并行遍历两个列表。

※ Python2.x的zip()函数直接返回列表，而不是zip对象

如果zip()函数压缩的两个列表长度不相等，那么zip()函数将以长度更短的列表为准。

zip()函数不仅可以压缩两个列表，也可以压缩多个列表。

使用reversed()函数，可以返回一个“反序排列”的迭代器，该函数对参数本身不会产生任何影响。

sorted()函数接收一个可迭代对象作为参数，返回一个对元素排序的列表，同样也不会改变传入的可迭代对象本身。在使用sorted()函数时，还可以传入一个reverse参数，如果将该参数设置为True，则表示反向排序。还可以传入一个key参数，该参数指定一个函数来生成排序的关键值。

五、控制循环结构

Python提供了continue和break来控制循环结构。使用return可以结束整个方法。

（一）使用break结束循环

break用于完全结束一个循环，跳出循环体。对于带有else块的循环，使用break强制中止循环，将不会执行else块。

（二）使用continue语句忽略本次循环的剩下语句

continue只是忽略当次循环剩下的语句，接着开始下一次循环，并不会中止循环。

（三）使用return结束方法

return用于从包围它的最直接方法、函数或匿名函数返回。

六、牛刀小试

（一）数字转人民币读法

'''
把一个浮点数分解成整数部分和小数部分字符串
num是需要被分解的浮点数
返回分解出来的整数部分和小数部分
第一个数组元素是整数部分，第二个数组元素是小数部分
'''


def divide(num):
    # 将一个浮点数强制类型转换为int类型，即得到它的整数部分
    integer = int(num)
    # 浮点数减去整数部分，得到小数部分，小数部分×100再取整得到2位小数
    fraction = round((num - integer) * 100)
    # 下面把整数转换为字符串
    return (str(integer), str(fraction))


han_list = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒",
            "捌", "玖"]
unit_list = ["十", "佰", "千"]


def four_to_hanstr(num_str):
    '''
    把一个4位的数字字符串变成汉字字符串
    num_str是需要被转换的4位数字字符串
    返回4位数字字符串被转换成汉子字符串
    '''
    result = ""
    num_len = len(num_str)
    # 依次遍历数字字符串的每一位数字
    for i in range(num_len):
        # 吧字符串转换成数值
        num = int(num_str[i])
        # 如果不是最后一位数字，而且数字不是零，则需要添加单位
        if i != num_len - 1 and num != 0:
            result += han_list[num] + unit_list[num_len - 2 - i]
        # 否则不需要添加单位
        else:
            result += han_list[num]
    return result


def integer_to_str(num_str):
    '''
    把数字字符串变成汉子字符串
    num_str是需要被转换的数字字符串
    返回数字字符串被转换成汉子字符串
    '''
    str_len = len(num_str)
    if str_len > 12:
        print('数字太大，翻译不了')
        return
    # 如果大于8位，包含单位“亿”
    elif str_len > 8:
        return four_to_hanstr(num_str[:-8]) + "亿" +\
            four_to_hanstr(num_str[-8: -4]) + "万" +\
            four_to_hanstr(num_str[-4:])
    # 如果大于4位，傲寒单位“万”
    elif str_len > 4:
        return four_to_hanstr(num_str[:-4]) + "万" +\
            four_to_hanstr(num_str[-4:])
    else:
        return four_to_hanstr(num_str)


if __name__ == '__main__':
    num = float(input("请输入一个浮点数："))
    # 测试把一个浮点数分解成整数部分和小数部分
    integer, fraction = divide(num)
    # 测试把一个4位数字字符串变成汉子字符串
    print(integer_to_str(integer))
    print(fraction)

（二）绕圈圈

给定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

仔细观察上面的问题，不难发现程序就是“绕圈圈”填入整数：

通过观察可以发现如下规律：

● ①号转弯线的行索引与列索引总和为n-1（n为给定整数）

● ②号转弯线的行索引与列索引相等

● ③号转弯线的行索引等于列索引减1

SIZE = int(input('请输入一个整数（3-9）之间：'))
array = [[0] * SIZE]
# 创建一个长度为SIZE * SIZE的二维列表
for i in range(SIZE - 1):
    array += [[0] * SIZE]
# 该orient代表绕圈的方向
# 其中0代表向下，1代表向右，2代表向左，3代表向上
orient = 0
# 控制将 1 ~ SIZE * SIZE的数值填入二维列表中
# 其中j控制行索引，k控制列索引
j = 0
k = 0
for i in range(1, SIZE * SIZE + 1):
    array[j][k] = i
    # 如果位于图4.2中①号转弯线上
    if j + k == SIZE - 1:
        # j > k，位于左下角
        if j > k:
            orient = 1
        # 位于右上角
        else:
            orient = 2
    # 如果位于图4.2中②号转弯线上
    elif (k == j) and (k >= SIZE / 2):
        orient = 3
    # 如果位于图4.2中③号转弯线上
    elif (j == k - 1) and (k <= SIZE / 2):
        orient = 0
    # 根据方向来控制行索引、列索引的改变
    # 如果方向为向下绕圈
    if orient == 0:
        j += 1
    # 如果方向为向右绕圈
    elif orient == 1:
        k += 1
    # 如果方向为向左绕圈
    elif orient == 2:
        k -= 1
    # 如果方向为向上绕圈
    elif orient == 3:
        j -= 1
# 采用遍历输出上面的二维列表
for i in range(SIZE):
    for j in range(SIZE):
        print('%02d ' % array[i][j], end="")
    print("")

（三）控制台五子棋

# 定义棋盘的大小
BOARD_SIZE = 15
# 定义个而为列表来填充棋盘
board = []


def initBoard():
    # 为每个元素赋值“╋”，用于在控制台画出棋盘
    for i in range(BOARD_SIZE):
        row = ["╋"] * BOARD_SIZE
        board.append(row)


# 在控制台输出棋盘的方法
def printBoard():
    # 打印每个列表的元素
    for i in range(BOARD_SIZE):
        for j in range(BOARD_SIZE):
            # 打印列表元素后不换行
            print(board[i][j], end="")
        # 每打印一行列表元素后输出一个换行
        print()


initBoard()
printBoard()
inputStr = input("请输入您下棋的坐标，应以x,y格式输入：\n")
while inputStr is not None:
    # 将用户输入的字符串以逗号（，）作为分隔符，分隔成两个字符串
    x_str, y_str = inputStr.split(sep=',')
    # 为对应的列表元素赋值“●”
    board[int(y_str) - 1][int(x_str) - 1] = '●'
    '''
    电脑随机生成两个整数，作为电脑下棋的坐标，赋值给board列表
    还涉及
        1.坐标的有效性，只能是数字，不能超出棋盘范围
        2.下的棋的点，不能重复下棋
        3.每次下棋后，需要扫描谁赢了
    '''
    printBoard()
    inputStr = input("请输入您下棋的坐标，应以x,y格式输入：\n")

（四）控制台超市系统

# 定义仓库
repository = dict()
# 定义购物清单对象
shop_list = []


# 定义一个函数来初始化商品
def init_repository():
    # 初始化很多商品，每个元组代表一个商品
    goods1 = ('1000001', '疯狂Ruby讲义', 88.0)
    goods2 = ('1000002', '疯狂Swift讲义', 69.0)
    goods3 = ('1000003', '疯狂Kotlin讲义', 59.0)
    goods4 = ('1000004', '疯狂Java讲义', 109.0)
    goods5 = ('1000005', '疯狂Android讲义', 108.0)
    goods6 = ('1000006', '疯狂IOS讲义', 77.0)
    # 把商品入库（放入dict中），条码作为key
    repository[goods1[0]] = goods1
    repository[goods2[0]] = goods2
    repository[goods3[0]] = goods3
    repository[goods4[0]] = goods4
    repository[goods5[0]] = goods5
    repository[goods6[0]] = goods6


# 显示超市的商品清单，就是遍历代表仓库的dict字典
def show_goods():
    print("欢迎光临 疯狂超市")
    print('疯狂超市的商品清单：')
    print("%13s%40s%10s" % ("条码", "商品名称", "单价"))
    # 遍历repository中的所有value来显示商品清单
    for goods in repository.values():
        print("%15s%40s%12s" % goods)


# 显示购物清单，就是遍历代表购物清单的list列表
def show_list():
    print("=" * 100)
    # 如果清单不为空，则输出清单内容
    if not shop_list:
        print("还未购买商品")
    else:
        title = "%-5s|%15s|%40s|%10s|%4s|%10s" % \
            ("ID", "条码", "商品名称", "单价", "数量", "小计")
        print(title)
        print("-" * 100)
        # 记录总计的价钱
        sum = 0
        # 遍历代表购物清单的list列表
        for i, item in enumerate(shop_list):
            # 转换id为索引加1
            id = i + 1
            # 获取该购物明细项的第一个元素：商品条码
            code = item[0]
            # 获取商品条码读取商品，再获取商品名称
            name = repository[code][1]
            # 获取商品条码读取商品，再获取商品价格
            price = repository[code][2]
            # 获取该购物明细项的第2个元素，商品数量
            number = item[1]
            # 小计
            amount = price * number
            # 计算总计
            sum = sum + amount
            line = "%-5s|%15s|%40s|%10s|%4s|%10s" % \
                (id, code, name, price, number, amount)
            print(line)
        print("-" * 100)
        print("                          总计: " , sum)
    print("=" * 100)


# 添加购买的商品，就是向代表用户购物清单的列表中添加一项
def add():
    # 等待输入条码
    code = input("请输入商品的条码:\n")
    # 没有找到对应的商品，条码错误
    if code not in repository:
        print("条码错误，请重新输入")
        return        
    # 根据条码找商品
    goods = repository[code]
    # 等待输入数量
    number = input("请输入购买数量:\n")
    # 把商品和购买数量封装成list后加入购物清单
    shop_list.append([code, int(number)])


# 修改购买商品的数量，就是修改代表用户购物清单的list列表的元素
def edit():
    id = input("请输入要修改的购物明细项的ID:\n")
    # id减1得到购物明细项的索引
    index = int(id) - 1
    # 根据索引获取某个购物明细项
    item = shop_list[index]
    # 提示输入新的购买数量
    number = input("请输入新的购买数量:\n")
    # 修改item里面的number
    item[1] = int(number)


# 删除购买的商品明细项，就是删除代表用户购物清单的list列表的一个元素。
def delete():
    id = input("请输入要删除的购物明细项的ID: ")
    index = int(id) - 1
    # 直接根据索引从清单里面删除掉购物明细项
    del shop_list[index]


def payment():
    # 先打印清单
    show_list()
    print('\n' * 3)
    print("欢迎下次光临")
    # 退出程序
    import os
    os._exit(0)


cmd_dict = {'a': add, 'e': edit, 'd': delete, 'p': payment, 's': show_goods}


# 显示命令提示
def show_command():
    # 等待命令
    cmd = input("请输入操作指令: \n" +
        "    添加(a)  修改(e)  删除(d)  结算(p)  超市商品(s)\n")
    # 如果用户输入的字符没有对应的命令   
    if cmd not in cmd_dict:
        print("不要玩，好不好！")
    else:
        cmd_dict[cmd]()


init_repository()
show_goods()
# 显示清单和操作命令提示
while True:
    show_list()
    show_command()

习题：

l. 使用循环输出九九乘法表。输出如下结果：

1 x 1=1

1 × 2 =2, 2 × 2 = 4

l × 3 = 3, 2 × 3 = 6, 3 × 3= 9

.........

l × 9 =9, 2 × 9 = 18 , 3 × 9 = 27, … , 9 x 9 = 81

for i in range(10):
    for j in range(1, i + 1):
        print('%d×%d=%d' % (j, i, i * j), end="")
        if i == 1:
            pass
        elif i == j:
            pass
        else:
            print(',', end="")
    print()

2. 使用循环输出等腰三角形。例如给定4 ，输出如下结果：

***

*****

*******

number = 4
# 最长的字符串长度为number * 2 - 1
for i in range(number):
    # 每行打印的星号字符串
    s_str = '*'*(i * 2 + 1)
    # 前后添加同样数量的空白，让星号居中
    space_str = ' ' * (number - i)
    # 组合成最终打印的字符串
    s_str = space_str + s_str + space_str
    print(s_str)

3. 给定奇数3 ，输出（横、坚、斜的总和相等）：

08 01 06

03 05 07

04 09 02

给定奇数5 ，输出（横、坚、斜的总和相等）：

17 24 01 08 15

23 05 07 14 16

04 06 13 20 22

10 12 19 21 03

11 18 25 02 09

依此类推。

size = int(input("输入要打印的SIZE(奇数):"))
array = [[0] * size]
# 创建一个长度size * size的二维列表
for i in range(size - 1):
    array += [[0] * size]
row, col = 0, size // 2
for i in range(1, size * size + 1):
    array[row][col] = i
    if i % size == 0:
        row += 1
    elif row == 0:
        row = size - 1
        col += 1
    elif col == size - 1:
        row -= 1
        col = 0
    else:
        row -= 1
        col += 1
for i in range(size):
    for j in range(size):
        print('%02d' % array[i][j], end=" ")
    print()

4. 使用循环输出菱形。例如用户输入7 （用户输入偶数，则提示不能打印〉，输出如下结果：

***

*****

*******

*****

***

lines = int(input("输入要打印的行数(奇数):"))
if lines % 2 == 0:
    print('请输入奇数')
    import sys
    sys.exit(0)
half_lines = lines // 2 + 1
# 打印上半
for i in range(half_lines):
    print(" " * (half_lines - i), end="")
    print("*" * (2 * i + 1))
# 打印下半
for i in range(half_lines - 1):
    print(" " * (i + 2), end="")
    print("*" * (lines - 2 - 2 * i))

5. 使用循环输出空心菱形。例如用户输入7 （用户输入偶数，则提示不能打印），输出如下结果：

* *

lines = int(input('请输入要打印的行数（只能是奇数）：'))
if lines % 2 == 0:
    print('请输入一个奇数！')
    import sys
    sys.exit(0)
half_lines = lines // 2 + 1
# 打印空心菱形的上半部分
for i in range(half_lines):
    # 先打印空白
    print(' ' * (half_lines - i), end='')
    if i == 0:
        print('*')
    else:
        print('*', end='')
        print(' ' * (2 * i - 1), end='')
        print('*')
# 打印空心菱形的下班部分
for i in range(half_lines - 1):
    # 先打印空白
    print(' ' * (i + 2), end='')
    if i == half_lines - 2:
        print('*')
    else:
        print('*', end='')
        print(' ' * (lines - 4 - 2 * i), end='')
        print('*')

6. 用户输入自己的成绩，程序会自动判断该成绩的类型：成绩≥90 分用A 表示， 8 0～89 分用B 表示， 7 0～7 9 分用C 表示，其他的用D 表示。

score = int(input('请输入您的成绩：'))
if score >= 90:
    print('您的成绩为A')
elif score < 90 and score >= 80:
    print('您的成绩为B')
elif score < 80 and score >= 70:
    print('您的成绩为C')
else:
    print('您的成绩为D')

7. 判断101 ~200 之间有多少个素数，并输出所有的质数。

# 产生一个101~200之间的整数列表
num_list = [i for i in range(101, 201)]
# 新建一个列表存储所有质数
prime_list = []
# 循环遍历num_list，找出所有质数
for num in num_list:
    for i in range(2, num):
        if num % i == 0:
            break
    else:
        prime_list.append(num)
print('101~200之间的质数共有：%d 个' % len(prime_list))
print(prime_list)

8 . 打印出所有的“水仙花数”。所谓“水仙花数”，是指一个三位数，其各位数字的立方和等于该数本身。例如， 15 3 是一个“水仙花数”，因为153 = 13 +53+33 。

# 产生一个101~200之间的整数列表
num_list = [i for i in range(101, 999)]
# 新建一个列表存储所有水仙花数
narcissistic_number_list = []
# 遍历数字列表
for num in num_list:
    # 判断一个数是否是水仙花数
    # 先将数字转换为字符串
    str_num = str(num)
    temp_num = 0
    for i in range(len(str_num)):
        temp_num += pow(int(str_num[i]), 3)
    if int(str_num) == temp_num:
        narcissistic_number_list.append(int(str_num))
print(narcissistic_number_list)

9. 输入一行字符，分别统计出其中英文字母、空格、数字和其他字符的个数。

input_str = input('请输入一行字符：')
blank_count = 0
letter_count = 0
number_count = 0
other_count = 0
# 循环遍历所有字符
for i in range(len(input_str)):
    # 如果不经过编码处理，中文也会被认为是字母
    if input_str[i].encode('UTF-8').isalpha():
        letter_count += 1
    elif input_str[i].isdigit():
        number_count += 1
    elif input_str[i].isspace():
        blank_count += 1
    else:
        other_count += 1
print('输入字符中共有字母%d个，数字%d个，空格%d个，其他字符%d个' %
      (letter_count, number_count, blank_count, other_count))

radius = int(input("请输入半径: "))
for i in range(2 * radius + 1):
    half = round((radius ** 2 - (radius - i) ** 2) ** 0.5)
    print("  " * (radius - half), end="")
    print("*", end="")
    print("  " * half * 2, end="")
    print("*")

11. 给定3 ， 输出：

----c----

--c-b-c--

c-b-a-b-c

--c-b-c--

----c----

给定4，输出：

------d------

----d-c-d----

--d-c-b-c-d--

d-c-b-a-b-c-d

--d-c-b-c-d--

----d-c-d----

------d------

给定5，输出：

--------e--------

------e-d-e------

----e-d-c-d-e----

--e-d-c-b-c-d-e--

e-d-c-b-a-b-c-d-e

--e-d-c-b-c-d-e--

----e-d-c-d-e----

------e-d-e------

--------e--------

以此类推。

lines = int(input("请输入一半的行数: "))
# 打印上半
for i in range(lines):
    print("-" * (lines * 2 - 2 - 2 * i), end="")
    my_list = []
    for j in range(i + 1):
        my_list.append(chr(96 + lines - j))
    for j in range(i):
        my_list.append(chr(ord(my_list[-1]) + 1))
    print('-'.join(my_list), end="")
    print("-" * (lines * 2 - 2 - 2 * i))
# 打印下半
for i in range(lines - 1):
    print("-" * (2 * (i + 1)), end="")
    # 换一种方式初始化list列表
    my_list = [chr(96 + lines - j) for j in range(lines - 1 - i)]
    for j in range(lines - 2 - i):
        my_list.append(chr(ord(my_list[-1]) + 1))
    print('-'.join(my_list), end="")
    print("-" * (2 * (i + 1)))

12. 完善数字转人民币读法的程序。

'''
把一个浮点数分解成整数部分和小数部分字符串
num是需要被分解的浮点数
返回分解出来的整数部分和小数部分
第一个数组元素是整数部分，第二个数组元素是小数部分
'''


def divide(num):
    # 将一个浮点数强制类型转换为int类型，即得到它的整数部分
    integer = int(num)
    # 浮点数减去整数部分，得到小数部分，小数部分×100再取整得到2位小数
    fraction = round((num - integer) * 100)
    # 下面把整数转换为字符串
    return (str(integer), str(fraction))


han_list = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒",
            "捌", "玖"]
unit_list = ["十", "佰", "千"]


def four_to_hanstr(num_str):
    '''
    把一个4位的数字字符串变成汉字字符串
    num_str是需要被转换的4位数字字符串
    返回4位数字字符串被转换成汉子字符串
    '''
    result = ""
    num_len = len(num_str)
    # 依次遍历数字字符串的每一位数字
    for i in range(num_len):
        # 吧字符串转换成数值
        num = int(num_str[i])
        # 如果不是最后一位数字，而且数字不是零，则需要添加单位
        if i != num_len - 1 and num != 0:
            result += han_list[num] + unit_list[num_len - 2 - i]
        # 否则不需要添加单位
        else:
            result += han_list[num]
    return result


def integer_to_str(num_str):
    '''
    把数字字符串变成汉子字符串
    num_str是需要被转换的数字字符串
    返回数字字符串被转换成汉子字符串
    '''
    str_len = len(num_str)
    if str_len > 12:
        print('数字太大，翻译不了')
        return
    # 如果大于8位，包含单位“亿”
    elif str_len > 8:
        return four_to_hanstr(num_str[:-8]) + "亿" +\
            four_to_hanstr(num_str[-8: -4]) + "万" +\
            four_to_hanstr(num_str[-4:])
    # 如果大于4位，傲寒单位“万”
    elif str_len > 4:
        return four_to_hanstr(num_str[:-4]) + "万" +\
            four_to_hanstr(num_str[-4:])
    else:
        return four_to_hanstr(num_str)


def fraction_to_str(num_str):
    '''
    把小数部分转换为字符串
    '''
    str_len = len(num_str)
    result = "点"
    for i in range(str_len):
        num = int(num_str[i])
        result += han_list[num]
    return result


def removezero(han_str):
    '''
    处理汉字字符串中零连续出现的问题
    '''
    str_len = len(han_str)
    result = ''
    for i in range(str_len):
        if han_str[i] == '零':
            if han_str[i + 1] == '零':
                continue
        result += han_str[i]
    return result


if __name__ == '__main__':
    num = float(input("请输入一个浮点数："))
    # 测试把一个浮点数分解成整数部分和小数部分
    integer, fraction = divide(num)
    # 测试把一个4位数字字符串变成汉子字符串
    print(integer_to_str(integer))
    print(fraction)
    print(integer_to_str(integer) + fraction_to_str(fraction))
    print(removezero(integer_to_str(integer) + fraction_to_str(fraction)))

zhouyong80

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
疯狂Python讲义学习笔记（含习题）之流程控制

Python支持两种基本流程控制结构：分支结构和循环结构。分支结构用于实现根据条件来选择性地执行某段代码；循环结构用户实现根据循环条件重复执行某段代码。Python使用if语句提供分支支持，使用while、for-in提供循环支持，同时也提供了break和continue来控制循环。一、顺序结构顺序结构就是程序从上到下一行行地执行，中间没有任何判断和跳转。二、if分支结构...
复制链接

扫一扫