• Python 自定义模块和包设计英语生词本（文件版）

    上一篇：Python 自定义包和模块随机生成6位验证码（详解版）-CSDN博客

    紧接上一篇博文，当我们熟练掌握如何自定义模块和包后，就要开始着手运用模块和包设计自己的小程序。这里我以“英语生词本”为例，来看我如何一步一步实现功能。

    一、简述如何自定义模块和包

    ①Python的包是模块的集合，一个包可以放很多自定义模块，与模块一样用import...或from...import...导入使用。

    ②模块不是一个简单的.py文件，如要实现被导入调用模块，一开始就要有对模块进行全局规划的意识，把一些单一重复的普通函数、类、全局变量整合到一起。

    二、小程序“英语生词本”设计

    1、根据小程序“英语生词本”功能规划代码框架，代码如下：

    1. input_info = '请输入菜单序号:'
    2.  
    3. # 功能实现  ************************************************************************
    4. while True:
    5.  
    6.     # 菜单选择
    7.     choice = input(input_info)
    8.     input_info = '请输入菜单序号:'
    9.  
    10.     # 1.查看单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    11.     if choice == '1':
    12.        pass
    13.  
    14.     # 2.背默单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    15.     elif choice == '2':
    16.        pass
    17.  
    18.     # 3.新增单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    19.     elif choice == '3':
    20.         pass
    21.  
    22.     # 4.删除单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    23.     elif choice == '4':
    24.         pass
    25.  
    26.     # 5.修改单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    27.     elif choice == '5':
    28.         pass
    29.  
    30.     # 0.退出  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    31.     elif choice == '0':
    32.         break
    33.  
    34.     # 其他
    35.     else:
    36.         input_info = '请重新输入菜单序号:'
    37.

    2、根据相应的功能逐个实现，代码如下：

    1. # 功能实现  ************************************************************************
    2. while True:
    3.     init_menu()         # 打印初始化菜单
    4.     make_file()         # 新建文件
    5.     read_file_data()    # 读取目标文件数据
    6.  
    7.     # 菜单选择
    8.     choice = input(input_info)
    9.     input_info = '请输入菜单序号:'
    10.  
    11.     # 1.查看单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    12.     if choice == '1':
    13.         input_title('查看单词')     # 打印标题
    14.  
    15.         # 判断是否为空文件
    16.         if english_dict == dict():
    17.             print('哦豁！您还没新增单词呢！')
    18.             continue
    19.  
    20.         # 打印单词
    21.         count = 0   # 计数
    22.         for i, j in english_dict.items():
    23.             count += 1
    24.             print(f'{count}. {i}\t\t\t{j}')
    25.  
    26.     # 2.背默单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    27.     elif choice == '2':
    28.         input_title('背默单词')     # 打印标题
    29.  
    30.         # 判断是否为空文件
    31.         if english_dict == dict() or english_dict == '文件不存在':
    32.             print('哦豁！您还没新增单词呢！')
    33.             continue
    34.  
    35.         # 选择背默模式    -----------------------------------------------------------
    36.         while True:
    37.             choice_mode = input(f'1.单词背默\t2.中文背默\t0.退出\n'
    38.                                 f'{"-"*32}\n请选择模式序号输入:')
    39.  
    40.             # 1.单词背默模式  -------------------------------------------------------
    41.             if choice_mode == '1':
    42.                 input_title('单词背默')     # 打印标题
    43.  
    44.                 # 开始背默
    45.                 break_flag = 0      # 旗帜
    46.                 for i, j in english_dict.items():
    47.                     while True:
    48.                         english = input(f'请输入{j}的\n英文翻译(退出:q 下一个:n):')
    49.  
    50.                         # 回答正确
    51.                         if english.strip(' ') == i:
    52.                             print('回答正确,再接再厉')
    53.                             break
    54.  
    55.                         # 退出
    56.                         elif english.strip(' ') == 'q' or english.strip(' ') == 'Q':
    57.                             break_flag = 1
    58.                             break
    59.  
    60.                         # 下一个
    61.                         elif english.strip(' ') == 'n' or english.strip(' ') == 'N':
    62.                             break
    63.  
    64.                         # 错误
    65.                         elif english.strip(' ') != '':
    66.                             print(f'回答错误: {english}')
    67.                             print(f'正确答案: {i}')
    68.  
    69.                         print('-' * 32)       # 打印分割线
    70.  
    71.                     # 退出两层循环
    72.                     if break_flag:
    73.                         break_flag = 0
    74.                         break
    75.  
    76.                     print('-' * 32)         # 打印分割线
    77.  
    78.             # 2.翻译背默模式  -------------------------------------------------------
    79.             elif choice_mode == '2':
    80.                 input_title('中文背默')        # 打印标题
    81.  
    82.                 # 开始背默
    83.                 break_flag = 0      # 旗帜
    84.                 error_flag = 0      # 旗帜
    85.                 for i, j in english_dict.items():
    86.                     while True:
    87.                         chinese_list = []       # 输入内容容器
    88.                         chinese = input(f'请输入 {i} 的\n中文翻译(退出:q 下一个:n):')
    89.  
    90.                         # 获取输入内容
    91.                         for k in chinese.split(' '):
    92.                             if k:
    93.                                 chinese_list.append(k)
    94.  
    95.                         # 判断输入内容是否为空
    96.                         if not chinese_list:
    97.                             print("-" * 32)  # 打印分割线
    98.                             continue
    99.  
    100.                         # 下一个
    101.                         elif chinese_list[0] in list('nN'):
    102.                             break
    103.  
    104.                         # 退出
    105.                         elif chinese_list[0] in list('qQ'):
    106.                             break_flag = 1
    107.                             break
    108.  
    109.                         # 全部正确
    110.                         elif chinese_list == j:
    111.                             print('全部回答正确')
    112.                             break
    113.  
    114.                         # 部分正确
    115.                         for t in chinese_list:
    116.                             if t in j and t == chinese_list[-1]:
    117.                                 print('回答正确一部分')
    118.                                 print(f'完整答案: {j}')
    119.                                 break_flag = 1
    120.                                 break
    121.  
    122.                             # 错误
    123.                             elif t not in j:
    124.                                 if not error_flag:
    125.                                     print('错误内容: ', end='')
    126.                                     error_flag = 1
    127.                                 print(f'{t}', end='  ')
    128.  
    129.                         # 退出两层循环
    130.                         if break_flag:
    131.                             break_flag = 0
    132.                             break
    133.  
    134.                         # 打印内容补全
    135.                         elif error_flag:
    136.                             error_flag = 0
    137.                             print(f'\n完整答案: {j}')
    138.  
    139.                         print("-" * 32)     # 打印分割线
    140.  
    141.                     # 退出两层循环
    142.                     if break_flag:
    143.                         break_flag = 0
    144.                         break
    145.  
    146.                     print("-" * 32)         # 打印分割线
    147.  
    148.             # 0.退出  -------------------------------------------------------------
    149.             elif choice_mode == '0':
    150.                 break
    151.  
    152.             input_title('背默单词')     # 打印标题
    153.  
    154.     # 3.新增单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    155.     elif choice == '3':
    156.         input_title('新增单词')     # 打印标题
    157.  
    158.         # 键盘输入单词和翻译
    159.         while True:
    160.             print('标准格式: instance  例子  实例')
    161.             data = input('请输入单词及中文翻译(退出:q):')
    162.  
    163.             # 获取输入内容
    164.             data_list = []  # 输入内容容器
    165.             for i in data.split(' '):
    166.                 if i:
    167.                     data_list.append(i)
    168.  
    169.             # 判断输入内容格式是否正确
    170.             if len(data_list) == 0 or (len(data_list) == 1 and data_list[0] not in tuple('qQ')):
    171.                 print('-' * 32)
    172.                 continue
    173.  
    174.             # 退出
    175.             elif data_list[0] in tuple('qQ'):
    176.                 break
    177.  
    178.             # 判断输入单词是否不在字典里
    179.             elif data_list[0] not in english_dict.keys():
    180.                 english_dict[data_list[0]] = data_list[1::]     # 保存到字典
    181.                 print(f'已新增成功: {data_list[0]} {english_dict[data_list[0]]}')
    182.  
    183.             # 判断输入单词是否在字典里
    184.             elif data_list[0] in english_dict.keys():
    185.                 print(f'该单词: {data_list[0]}  {english_dict[data_list[0]]}\n'
    186.                       f'已存在,无法新增: {data_list[0]}  {data_list[1::]}')
    187.  
    188.             print('-'*32)       # 打印分隔线
    189.  
    190.             # 保存到文件里
    191.             from 小功能包.词典文件 import dict_file
    192.             dict_file.file_write(english_dict, file_path, split)
    193.  
    194.     # 4.删除单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    195.     elif choice == '4':
    196.         input_title('删除单词')  # 打印标题
    197.  
    198.         # 判断是否为空文件
    199.         if english_dict == dict():
    200.             print('哦豁！您还没新增单词呢！')
    201.             continue
    202.  
    203.         # 删除单词
    204.         while True:
    205.             data = input('请输入要删除的[单词/中文](退出:q):')
    206.  
    207.             # 退出
    208.             if data.strip(' ') == 'q' or data.strip(' ') == 'Q':
    209.                 break
    210.  
    211.             # 在字典查找与输入内容相关单词
    212.             dict_keys = dict_find(data)
    213.  
    214.             # 判断是否找到数据
    215.             if len(dict_keys) == 0:
    216.                 print(f'很遗憾,未找到与" {data} "相关内容')
    217.  
    218.             # 单个单词直接删除
    219.             elif len(dict_keys) == 1:
    220.                 print(f'原单词: {dict_keys[0]}  {english_dict[dict_keys[0]]}')
    221.                 remove = input('请确认是否删除(y/n):')
    222.  
    223.                 # 判断输入是否为空
    224.                 if not remove.strip(' '):
    225.                     print('已放弃本次删除操作')
    226.  
    227.                 # 确定删除
    228.                 elif remove.strip(' ') == 'y' or remove.strip(' ') == 'Y':
    229.                     print('已成功删除单词')
    230.                     english_dict.pop(dict_keys[0])  # 删除
    231.  
    232.                 # 其他
    233.                 else:
    234.                     print('已放弃本次删除操作')
    235.  
    236.             # 多个单词选择删除
    237.             elif len(dict_keys) > 1:
    238.                 while True:
    239.  
    240.                     # 打印查找到的数据
    241.                     count = 0       # 计数
    242.                     print(f'已为您找到以下单词:')
    243.                     for i in dict_keys:
    244.                         count += 1
    245.                         print(f'{count}. {i}  {english_dict[i]}')
    246.  
    247.                     choice_change = input('请输入要删除的单词序号(退出:q):')
    248.  
    249.                     # 把序号转化为字符串存入列表
    250.                     num_list = []
    251.                     for i in range(1, len(dict_keys)+1):
    252.                         num_list.append(str(i))
    253.  
    254.                     # 退出
    255.                     if choice_change.strip(' ') in list('qQ'):
    256.                         break
    257.  
    258.                     # 当输入正确序号时
    259.                     elif choice_change.strip(' ') in num_list:
    260.                         print(f'原单词: {dict_keys[int(choice_change)-1]}  '
    261.                               f'{english_dict[dict_keys[int(choice_change)-1]]}')
    262.                         remove = input(f'请确认是否要删除(y/n):')
    263.  
    264.                         # 确定删除
    265.                         if remove.strip(' ') == 'y' or remove.strip(' ') == 'Y':
    266.                             print('已成功删除单词')
    267.                             english_dict.pop(dict_keys[int(choice_change)-1])  # 删除
    268.  
    269.                         # 其他
    270.                         else:
    271.                             print('已放弃本次删除操作')
    272.  
    273.                         print('-' * 32)     # 打印分割线
    274.  
    275.                         break               # 跳出本次循环
    276.  
    277.             input_title('删除单词')        # 打印标题
    278.  
    279.             # 更新文件数据
    280.             from 小功能包.词典文件 import dict_file
    281.             dict_file.file_write(english_dict, file_path, split)
    282.  
    283.     # 5.修改单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    284.     elif choice == '5':
    285.         input_title('修改单词')     # 打印标题
    286.  
    287.         # 判断是否为空文件
    288.         if english_dict == dict():
    289.             print('哦豁！您还没新增单词呢！')
    290.             continue
    291.  
    292.         # 修改单词
    293.         while True:
    294.             data = input('请输入要修改的[单词/中文](退出:q):')
    295.  
    296.             # 退出
    297.             if data.strip(' ') == 'q' or data.strip(' ') == 'Q':
    298.                 break
    299.  
    300.             # 在字典查找与输入内容相关单词
    301.             dict_keys = dict_find(data)
    302.  
    303.             # 未找到数据
    304.             if len(dict_keys) == 0:
    305.                 print(f'很遗憾,未找到与" {data} "相关内容')
    306.  
    307.             # 单个单词直接修改
    308.             elif len(dict_keys) == 1:
    309.                 print(f'原单词: {dict_keys[0]}  {english_dict[dict_keys[0]]}')
    310.  
    311.                 # 输入新单词
    312.                 data_list = new_data_input(dict_keys)
    313.  
    314.                 # 返回
    315.                 if not data_list:
    316.                     input_title('修改单词')  # 打印标题
    317.                     continue
    318.  
    319.                 print(f'{dict_keys[0]} {english_dict[dict_keys[0]]} '
    320.                       f'修改为 {data_list[0]} {data_list[1::]}')
    321.                 remove = input('请确认是否修改(y/n):')
    322.  
    323.                 # 输入空字符
    324.                 if not remove.strip(' '):
    325.                     print('已放弃本次修改操作')
    326.  
    327.                 # 确定修改
    328.                 elif remove.strip(' ') == 'y' or remove.strip(' ') == 'Y':
    329.                     print('已成功修改单词')
    330.                     english_dict.pop(dict_keys[0])                  # 删除
    331.                     english_dict[data_list[0]] = data_list[1::]     # 添加
    332.  
    333.                 # 其他
    334.                 else:
    335.                     print('已放弃本次修改操作')
    336.  
    337.             # 多个单词选择修改
    338.             elif len(dict_keys) > 1:
    339.                 while True:
    340.  
    341.                     # 打印查找到的数据
    342.                     count = 0   # 计数
    343.                     print(f'已为您找到以下单词:')
    344.                     for i in dict_keys:
    345.                         count += 1
    346.                         print(f'{count}. {i}  {english_dict[i]}')
    347.  
    348.                     choice_change = input('请输入要修改的单词序号(退出:q):')
    349.  
    350.                     # 把序号转化为字符串存入列表
    351.                     num_list = []
    352.                     for i in range(1, len(dict_keys)+1):
    353.                         num_list.append(str(i))
    354.  
    355.                     # 退出
    356.                     if choice_change.strip(' ') in list('qQ'):
    357.                         break
    358.  
    359.                     # 当输入正确序号时
    360.                     elif choice_change.strip(' ') in num_list:
    361.                         print(f'原单词: {dict_keys[int(choice_change)-1]}  '
    362.                               f'{english_dict[dict_keys[int(choice_change)-1]]}')
    363.  
    364.                         # 输入新单词
    365.                         data_list = new_data_input(dict_keys, dict_keys[int(choice_change)-1])
    366.  
    367.                         # 返回
    368.                         if not data_list:
    369.                             break
    370.  
    371.                         remove = input(f'{dict_keys[int(choice_change) - 1]} '
    372.                                        f'{english_dict[dict_keys[int(choice_change)-1]]} '
    373.                                        f'修改为 {data_list[0]} {data_list[1::]}'
    374.                                        f'\n请确认是否要修改(y/n):')
    375.  
    376.                         # 确定修改
    377.                         if remove.strip(' ') == 'y' or remove.strip(' ') == 'Y':
    378.                             print('已成功修改单词')
    379.                             english_dict.pop(dict_keys[int(choice_change)-1])   # 删除
    380.                             english_dict[data_list[0]] = data_list[1::]         # 添加
    381.  
    382.                         # 其他
    383.                         else:
    384.                             print('已放弃本次修改操作')
    385.  
    386.                         print('-' * 32)     # 打印分割线
    387.                         break               # 跳出本次循环
    388.  
    389.             input_title('修改单词')       # 打印标题
    390.  
    391.             # 更新文件数据
    392.             from 小功能包.词典文件 import dict_file
    393.             dict_file.file_write(english_dict, file_path, split)
    394.  
    395.     # 0.退出  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    396.     elif choice == '0':
    397.         input_title('退出生词本', 11)        # 打印标题
    398.         break
    399.  
    400.     # 其他
    401.     else:
    402.         input_info = '请重新输入菜单序号:'
    403.

    3、自定义模块和包导入，实现代码交互，代码如下：

    1. """
    2.     字典文件模块
    3. """
    4.  
    5.  
    6. # 用于模块导入使用通配符'*'
    7. __all__ = ['make_dir', 'make_file', 'dict_file']
    8.  
    9.  
    10. """****************************** 普通函数 ******************************"""
    11. # 新建目录  ----------------------------------------------------------------
    12. def make_dir(path):
    13.     # 路径分割
    14.     path_list = ''
    15.     for i in path.split('\\')[:-1:]:
    16.         path_list += i + '\\'
    17.  
    18.     # 新建目录
    19.     import os
    20.     if not os.path.exists(path_list):
    21.         os.mkdir(path_list)
    22.  
    23.  
    24. # 新建文件  ---------------------------------------------------------------
    25. def make_file(path):
    26.     # 判断文件是否存在
    27.     import os
    28.     if not os.path.exists(path):
    29.         file = open(file=path, mode='w')
    30.         file.close()
    31.  
    32. """****************************** 功能类 ******************************"""
    33. # 字典文件类 ==============================================================
    34. class dict_file:
    35.  
    36.     def __init__(self):
    37.         pass
    38.  
    39.     # 读取文件数据    ----------------------------------------------------
    40.     @classmethod
    41.     def file_read(cls, dict, path, split):
    42.         # 判断文件是否存在
    43.         import os
    44.         if not os.path.exists(path):
    45.             return '文件不存在'
    46.  
    47.         # 读取文件数据
    48.         file = open(file=path, mode='r', encoding='utf-8')
    49.         data_list = file.readlines()
    50.         file.close()
    51.         # 判断文件是否为空
    52.         if data_list == dict:
    53.             return dict
    54.         # 分割获取需要的数据
    55.         for i in data_list:
    56.             split_list = i.strip('\n').split(split)
    57.             dict[split_list[0]] = split_list[1::]
    58.         return dict
    59.  
    60.     # 写入文件数据    ---------------------------------------------------
    61.     @classmethod
    62.     def file_write(cls, dict, path, split):
    63.         make_dir(path)      # 创建目录
    64.         # make_file(path)     # 创建文件
    65.  
    66.         # 数据写入文件
    67.         file = open(file=path, mode='w', encoding='utf-8')
    68.         for i, j in dict.items():
    69.             file.write(f'{i}')
    70.             for k in j:
    71.                 file.write(f'{split}{k}')
    72.             file.write('\n')
    73.         file.close()
    74.  
    75.  
    76. """****************************** 代码测试 ******************************"""
    77. # 代码测试  ****************************************************************
    78. if __name__ == '__main__':
    79.     print(dict_file.file_read(dict(), '.\\..\\123\\456.txt', '(*)'))
    80.     dict_file.file_write({'present': ['现在', '礼物']}, '.\\..\\111\\222.txt', '(*)')
    81. else:
    82.     pass
    83.

    4、所有功能整合完成，代码如下：

    1. """
    2.     英语生词本(文件版)
    4. """
    5.  
    6.  
    7. # 打印初始化菜单   ===================================================================
    8. def init_menu():
    9.     print(f'{"="*12}英语生词本{"="*12}\n'
    10.           f'1.查看单词\t2.背默单词\t'
    11.           f'3.新增单词\n4.删除单词\t'
    12.           f'5.修改单词\t0.退出\n{"-"*32}')
    13.  
    14.  
    15. # 打印标题  =========================================================================
    16. def input_title(str, fill=12):
    17.     print(f'{"*"*fill} {str} {"*"*fill}')
    18.  
    19.  
    20. # 创建文件  ========================================================================
    21. def make_file():
    22.     from 小功能包 import 词典文件
    23.     词典文件.make_dir(file_path)       # 创建目录
    24.     词典文件.make_file(file_path)      # 创建文件
    25.  
    26.  
    27. # 读取目标文件数据  ==================================================================
    28. def read_file_data():
    29.     from 小功能包.词典文件 import dict_file
    30.     global english_dict
    31.     english_dict = dict_file.file_read(dict=dict(), path=file_path, split=split)
    32.  
    33.  
    34. # 数据查找  ========================================================================
    35. def dict_find(find_str):
    36.     # 查找与输入内容相关单词
    37.     dict_keys = []  # 字典键容器
    38.     keyword = []    # 关键字
    39.     # 分离查找关键字
    40.     for i in find_str.strip(' ').split(' '):
    41.         if i:
    42.             keyword.append(i)
    43.     # 查找关键字
    44.     for i, j in english_dict.items():
    45.         only_flag = 1               # 只执行一次
    46.         for k in keyword:
    47.             if i == k or k in j:
    48.                 if only_flag:       # 只执行一次
    49.                     only_flag = 0
    50.                     dict_keys.append(i)
    51.  
    52.     print('-' * 32)  # 打印分割线
    53.     return dict_keys
    54.  
    55.  
    56. # 新单词输入 ========================================================================
    57. def new_data_input(dict_keys, str=None):
    58.     # 剔除单词
    59.     new_keys = []
    60.     if str:
    61.         new_keys.extend(dict_keys)
    62.         new_keys.remove(str)
    63.     # 新单词输入
    64.     if dict_keys:
    65.         while True:
    66.             data_list = []      # 输入内容容器
    67.             new_data = input('请输入新单词及中文翻译(退出:q):')
    68.             # 获取输入内容
    69.             for i in new_data.split(' '):
    70.                 if i:
    71.                     data_list.append(i)
    72.             # 判断输入内容格式是否正确
    73.             if len(data_list) == 0 or (len(data_list) == 1 and data_list[0] not in tuple('qQ')):
    74.                 print('标准格式: instance  例子  实例')
    75.             # 退出
    76.             elif data_list[0] in tuple('qQ'):
    77.                 return []
    78.             # 判断单词是否存在
    79.             elif data_list[0] in english_dict.keys() and data_list[0] not in dict_keys:
    80.                 print(f'该单词: {data_list[0]}  {english_dict[data_list[0]]}\n'
    81.                       f'已存在,无法命名为: {data_list[0]}')
    82.             elif data_list[0] in new_keys and str:
    83.                 print(f'该单词: {data_list[0]}  {english_dict[data_list[0]]}\n'
    84.                       f'已存在,无法命名为: {data_list[0]}')
    85.             else:
    86.                 break
    87.             print('-' * 32)     # 打印分割线
    88.         return data_list
    89.  
    90.  
    91. # 全局变量  ========================================================================
    92. english_dict = dict()                       # 用于暂存英语生词字典
    93. file_path = '.\\..\\English\\data.txt'      # 文件保存路径
    94. split = '(*)'                               # 数据分割符号
    95. input_info = '请输入菜单序号:'
    96.  
    97.  
    98. # 功能实现  ************************************************************************
    99. while True:
    100.     init_menu()         # 打印初始化菜单
    101.     make_file()         # 新建文件
    102.     read_file_data()    # 读取目标文件数据
    103.  
    104.     # 菜单选择
    105.     choice = input(input_info)
    106.     input_info = '请输入菜单序号:'
    107.  
    108.     # 1.查看单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    109.     if choice == '1':
    110.         input_title('查看单词')     # 打印标题
    111.  
    112.         # 判断是否为空文件
    113.         if english_dict == dict():
    114.             print('哦豁！您还没新增单词呢！')
    115.             continue
    116.  
    117.         # 打印单词
    118.         count = 0   # 计数
    119.         for i, j in english_dict.items():
    120.             count += 1
    121.             print(f'{count}. {i}\t\t\t{j}')
    122.  
    123.     # 2.背默单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    124.     elif choice == '2':
    125.         input_title('背默单词')     # 打印标题
    126.  
    127.         # 判断是否为空文件
    128.         if english_dict == dict() or english_dict == '文件不存在':
    129.             print('哦豁！您还没新增单词呢！')
    130.             continue
    131.  
    132.         # 选择背默模式    -----------------------------------------------------------
    133.         while True:
    134.             choice_mode = input(f'1.单词背默\t2.中文背默\t0.退出\n'
    135.                                 f'{"-"*32}\n请选择模式序号输入:')
    136.  
    137.             # 1.单词背默模式  -------------------------------------------------------
    138.             if choice_mode == '1':
    139.                 input_title('单词背默')     # 打印标题
    140.  
    141.                 # 开始背默
    142.                 break_flag = 0      # 旗帜
    143.                 for i, j in english_dict.items():
    144.                     while True:
    145.                         english = input(f'请输入{j}的\n英文翻译(退出:q 下一个:n):')
    146.  
    147.                         # 回答正确
    148.                         if english.strip(' ') == i:
    149.                             print('回答正确,再接再厉')
    150.                             break
    151.  
    152.                         # 退出
    153.                         elif english.strip(' ') == 'q' or english.strip(' ') == 'Q':
    154.                             break_flag = 1
    155.                             break
    156.  
    157.                         # 下一个
    158.                         elif english.strip(' ') == 'n' or english.strip(' ') == 'N':
    159.                             break
    160.  
    161.                         # 错误
    162.                         elif english.strip(' ') != '':
    163.                             print(f'回答错误: {english}')
    164.                             print(f'正确答案: {i}')
    165.  
    166.                         print('-' * 32)       # 打印分割线
    167.  
    168.                     # 退出两层循环
    169.                     if break_flag:
    170.                         break_flag = 0
    171.                         break
    172.  
    173.                     print('-' * 32)         # 打印分割线
    174.  
    175.             # 2.翻译背默模式  -------------------------------------------------------
    176.             elif choice_mode == '2':
    177.                 input_title('中文背默')        # 打印标题
    178.  
    179.                 # 开始背默
    180.                 break_flag = 0      # 旗帜
    181.                 error_flag = 0      # 旗帜
    182.                 for i, j in english_dict.items():
    183.                     while True:
    184.                         chinese_list = []       # 输入内容容器
    185.                         chinese = input(f'请输入 {i} 的\n中文翻译(退出:q 下一个:n):')
    186.  
    187.                         # 获取输入内容
    188.                         for k in chinese.split(' '):
    189.                             if k:
    190.                                 chinese_list.append(k)
    191.  
    192.                         # 判断输入内容是否为空
    193.                         if not chinese_list:
    194.                             print("-" * 32)  # 打印分割线
    195.                             continue
    196.  
    197.                         # 下一个
    198.                         elif chinese_list[0] in list('nN'):
    199.                             break
    200.  
    201.                         # 退出
    202.                         elif chinese_list[0] in list('qQ'):
    203.                             break_flag = 1
    204.                             break
    205.  
    206.                         # 全部正确
    207.                         elif chinese_list == j:
    208.                             print('全部回答正确')
    209.                             break
    210.  
    211.                         # 部分正确
    212.                         for t in chinese_list:
    213.                             if t in j and t == chinese_list[-1]:
    214.                                 print('回答正确一部分')
    215.                                 print(f'完整答案: {j}')
    216.                                 break_flag = 1
    217.                                 break
    218.  
    219.                             # 错误
    220.                             elif t not in j:
    221.                                 if not error_flag:
    222.                                     print('错误内容: ', end='')
    223.                                     error_flag = 1
    224.                                 print(f'{t}', end='  ')
    225.  
    226.                         # 退出两层循环
    227.                         if break_flag:
    228.                             break_flag = 0
    229.                             break
    230.  
    231.                         # 打印内容补全
    232.                         elif error_flag:
    233.                             error_flag = 0
    234.                             print(f'\n完整答案: {j}')
    235.  
    236.                         print("-" * 32)     # 打印分割线
    237.  
    238.                     # 退出两层循环
    239.                     if break_flag:
    240.                         break_flag = 0
    241.                         break
    242.  
    243.                     print("-" * 32)         # 打印分割线
    244.  
    245.             # 0.退出  -------------------------------------------------------------
    246.             elif choice_mode == '0':
    247.                 break
    248.  
    249.             input_title('背默单词')     # 打印标题
    250.  
    251.     # 3.新增单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    252.     elif choice == '3':
    253.         input_title('新增单词')     # 打印标题
    254.  
    255.         # 键盘输入单词和翻译
    256.         while True:
    257.             print('标准格式: instance  例子  实例')
    258.             data = input('请输入单词及中文翻译(退出:q):')
    259.  
    260.             # 获取输入内容
    261.             data_list = []  # 输入内容容器
    262.             for i in data.split(' '):
    263.                 if i:
    264.                     data_list.append(i)
    265.  
    266.             # 判断输入内容格式是否正确
    267.             if len(data_list) == 0 or (len(data_list) == 1 and data_list[0] not in tuple('qQ')):
    268.                 print('-' * 32)
    269.                 continue
    270.  
    271.             # 退出
    272.             elif data_list[0] in tuple('qQ'):
    273.                 break
    274.  
    275.             # 判断输入单词是否不在字典里
    276.             elif data_list[0] not in english_dict.keys():
    277.                 english_dict[data_list[0]] = data_list[1::]     # 保存到字典
    278.                 print(f'已新增成功: {data_list[0]} {english_dict[data_list[0]]}')
    279.  
    280.             # 判断输入单词是否在字典里
    281.             elif data_list[0] in english_dict.keys():
    282.                 print(f'该单词: {data_list[0]}  {english_dict[data_list[0]]}\n'
    283.                       f'已存在,无法新增: {data_list[0]}  {data_list[1::]}')
    284.  
    285.             print('-'*32)       # 打印分隔线
    286.  
    287.             # 保存到文件里
    288.             from 小功能包.词典文件 import dict_file
    289.             dict_file.file_write(english_dict, file_path, split)
    290.  
    291.     # 4.删除单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    292.     elif choice == '4':
    293.         input_title('删除单词')  # 打印标题
    294.  
    295.         # 判断是否为空文件
    296.         if english_dict == dict():
    297.             print('哦豁！您还没新增单词呢！')
    298.             continue
    299.  
    300.         # 删除单词
    301.         while True:
    302.             data = input('请输入要删除的[单词/中文](退出:q):')
    303.  
    304.             # 退出
    305.             if data.strip(' ') == 'q' or data.strip(' ') == 'Q':
    306.                 break
    307.  
    308.             # 在字典查找与输入内容相关单词
    309.             dict_keys = dict_find(data)
    310.  
    311.             # 判断是否找到数据
    312.             if len(dict_keys) == 0:
    313.                 print(f'很遗憾,未找到与" {data} "相关内容')
    314.  
    315.             # 单个单词直接删除
    316.             elif len(dict_keys) == 1:
    317.                 print(f'原单词: {dict_keys[0]}  {english_dict[dict_keys[0]]}')
    318.                 remove = input('请确认是否删除(y/n):')
    319.  
    320.                 # 判断输入是否为空
    321.                 if not remove.strip(' '):
    322.                     print('已放弃本次删除操作')
    323.  
    324.                 # 确定删除
    325.                 elif remove.strip(' ') == 'y' or remove.strip(' ') == 'Y':
    326.                     print('已成功删除单词')
    327.                     english_dict.pop(dict_keys[0])  # 删除
    328.  
    329.                 # 其他
    330.                 else:
    331.                     print('已放弃本次删除操作')
    332.  
    333.             # 多个单词选择删除
    334.             elif len(dict_keys) > 1:
    335.                 while True:
    336.  
    337.                     # 打印查找到的数据
    338.                     count = 0       # 计数
    339.                     print(f'已为您找到以下单词:')
    340.                     for i in dict_keys:
    341.                         count += 1
    342.                         print(f'{count}. {i}  {english_dict[i]}')
    343.  
    344.                     choice_change = input('请输入要删除的单词序号(退出:q):')
    345.  
    346.                     # 把序号转化为字符串存入列表
    347.                     num_list = []
    348.                     for i in range(1, len(dict_keys)+1):
    349.                         num_list.append(str(i))
    350.  
    351.                     # 退出
    352.                     if choice_change.strip(' ') in list('qQ'):
    353.                         break
    354.  
    355.                     # 当输入正确序号时
    356.                     elif choice_change.strip(' ') in num_list:
    357.                         print(f'原单词: {dict_keys[int(choice_change)-1]}  '
    358.                               f'{english_dict[dict_keys[int(choice_change)-1]]}')
    359.                         remove = input(f'请确认是否要删除(y/n):')
    360.  
    361.                         # 确定删除
    362.                         if remove.strip(' ') == 'y' or remove.strip(' ') == 'Y':
    363.                             print('已成功删除单词')
    364.                             english_dict.pop(dict_keys[int(choice_change)-1])  # 删除
    365.  
    366.                         # 其他
    367.                         else:
    368.                             print('已放弃本次删除操作')
    369.  
    370.                         print('-' * 32)     # 打印分割线
    371.  
    372.                         break               # 跳出本次循环
    373.  
    374.             input_title('删除单词')        # 打印标题
    375.  
    376.             # 更新文件数据
    377.             from 小功能包.词典文件 import dict_file
    378.             dict_file.file_write(english_dict, file_path, split)
    379.  
    380.     # 5.修改单词    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    381.     elif choice == '5':
    382.         input_title('修改单词')     # 打印标题
    383.  
    384.         # 判断是否为空文件
    385.         if english_dict == dict():
    386.             print('哦豁！您还没新增单词呢！')
    387.             continue
    388.  
    389.         # 修改单词
    390.         while True:
    391.             data = input('请输入要修改的[单词/中文](退出:q):')
    392.  
    393.             # 退出
    394.             if data.strip(' ') == 'q' or data.strip(' ') == 'Q':
    395.                 break
    396.  
    397.             # 在字典查找与输入内容相关单词
    398.             dict_keys = dict_find(data)
    399.  
    400.             # 未找到数据
    401.             if len(dict_keys) == 0:
    402.                 print(f'很遗憾,未找到与" {data} "相关内容')
    403.  
    404.             # 单个单词直接修改
    405.             elif len(dict_keys) == 1:
    406.                 print(f'原单词: {dict_keys[0]}  {english_dict[dict_keys[0]]}')
    407.  
    408.                 # 输入新单词
    409.                 data_list = new_data_input(dict_keys)
    410.  
    411.                 # 返回
    412.                 if not data_list:
    413.                     input_title('修改单词')  # 打印标题
    414.                     continue
    415.  
    416.                 print(f'{dict_keys[0]} {english_dict[dict_keys[0]]} '
    417.                       f'修改为 {data_list[0]} {data_list[1::]}')
    418.                 remove = input('请确认是否修改(y/n):')
    419.  
    420.                 # 输入空字符
    421.                 if not remove.strip(' '):
    422.                     print('已放弃本次修改操作')
    423.  
    424.                 # 确定修改
    425.                 elif remove.strip(' ') == 'y' or remove.strip(' ') == 'Y':
    426.                     print('已成功修改单词')
    427.                     english_dict.pop(dict_keys[0])                  # 删除
    428.                     english_dict[data_list[0]] = data_list[1::]     # 添加
    429.  
    430.                 # 其他
    431.                 else:
    432.                     print('已放弃本次修改操作')
    433.  
    434.             # 多个单词选择修改
    435.             elif len(dict_keys) > 1:
    436.                 while True:
    437.  
    438.                     # 打印查找到的数据
    439.                     count = 0   # 计数
    440.                     print(f'已为您找到以下单词:')
    441.                     for i in dict_keys:
    442.                         count += 1
    443.                         print(f'{count}. {i}  {english_dict[i]}')
    444.  
    445.                     choice_change = input('请输入要修改的单词序号(退出:q):')
    446.  
    447.                     # 把序号转化为字符串存入列表
    448.                     num_list = []
    449.                     for i in range(1, len(dict_keys)+1):
    450.                         num_list.append(str(i))
    451.  
    452.                     # 退出
    453.                     if choice_change.strip(' ') in list('qQ'):
    454.                         break
    455.  
    456.                     # 当输入正确序号时
    457.                     elif choice_change.strip(' ') in num_list:
    458.                         print(f'原单词: {dict_keys[int(choice_change)-1]}  '
    459.                               f'{english_dict[dict_keys[int(choice_change)-1]]}')
    460.  
    461.                         # 输入新单词
    462.                         data_list = new_data_input(dict_keys, dict_keys[int(choice_change)-1])
    463.  
    464.                         # 返回
    465.                         if not data_list:
    466.                             break
    467.  
    468.                         remove = input(f'{dict_keys[int(choice_change) - 1]} '
    469.                                        f'{english_dict[dict_keys[int(choice_change)-1]]} '
    470.                                        f'修改为 {data_list[0]} {data_list[1::]}'
    471.                                        f'\n请确认是否要修改(y/n):')
    472.  
    473.                         # 确定修改
    474.                         if remove.strip(' ') == 'y' or remove.strip(' ') == 'Y':
    475.                             print('已成功修改单词')
    476.                             english_dict.pop(dict_keys[int(choice_change)-1])   # 删除
    477.                             english_dict[data_list[0]] = data_list[1::]         # 添加
    478.  
    479.                         # 其他
    480.                         else:
    481.                             print('已放弃本次修改操作')
    482.  
    483.                         print('-' * 32)     # 打印分割线
    484.                         break               # 跳出本次循环
    485.  
    486.             input_title('修改单词')       # 打印标题
    487.  
    488.             # 更新文件数据
    489.             from 小功能包.词典文件 import dict_file
    490.             dict_file.file_write(english_dict, file_path, split)
    491.  
    492.     # 0.退出  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    493.     elif choice == '0':
    494.         input_title('退出生词本', 11)        # 打印标题
    495.         break
    496.  
    497.     # 其他
    498.     else:
    499.         input_info = '请重新输入菜单序号:'
    500.

    运行结果：

    1. ============英语生词本============
    2. 1.查看单词	2.背默单词	3.新增单词
    3. 4.删除单词	5.修改单词	0.退出
    4. --------------------------------
    5. 请输入菜单序号:1
    6. ************ 查看单词 ************
    7. 哦豁！您还没新增单词呢！
    8. ============英语生词本============
    9. 1.查看单词	2.背默单词	3.新增单词
    10. 4.删除单词	5.修改单词	0.退出
    11. --------------------------------
    12. 请输入菜单序号:3
    13. ************ 新增单词 ************
    14. 标准格式: instance  例子  实例
    15. 请输入单词及中文翻译(退出:q):title 题目 标题
    16. 已新增成功: title ['题目', '标题']
    17. --------------------------------
    18. 标准格式: instance  例子  实例
    19. 请输入单词及中文翻译(退出:q):turtle  海龟
    20. 已新增成功: turtle ['海龟']
    21. --------------------------------
    22. 标准格式: instance  例子  实例
    23. 请输入单词及中文翻译(退出:q):q
    24. ============英语生词本============
    25. 1.查看单词	2.背默单词	3.新增单词
    26. 4.删除单词	5.修改单词	0.退出
    27. --------------------------------
    28. 请输入菜单序号:1
    29. ************ 查看单词 ************
    30. 1. title			['题目', '标题']
    31. 2. turtle			['海龟']

    作者：周华

    创作日期：2023/10/14

  • 相关阅读:
    代码随想录——接雨水（双指针&动态规划&单调栈）
    linux搭建git服务器，windows客户端配置git
    mysql MVC jsp实现表分页
    【Linux】[gdb]Linux环境下如何调试代码
    SAP PI/PO 视频，自己录制
    Apache Hudi vs Delta Lake：透明TPC-DS Lakehouse性能基准
    基于ArcGIS进行空间方向性研究
    如何实现图片懒加载，原生 + React 实现方式
    Java编写简易rabbitmq生产者与消费者
    linux网络编程之TCP协议编程
  • 原文地址：https://blog.csdn.net/zhouhua2022/article/details/133827244