使用Python3自带GUI、RSA、SQLite3做的密码管理软件 V3.0 证书加密解密密码

#_*_ coding:utf8 _*_

import os,time,random

## pycryptodome
from Crypto import Random
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5

## 数据库
import sqlite3


## 图形化模块
import re
from tkinter import *
from tkinter import filedialog  # 选择文件用
import tkinter.messagebox       # 弹出提示对话框
from tkinter import ttk         # 下拉菜单控件在ttk中


def 初始化配置文件(CONF_PATH):
    TEXT_CONF = ''
    D_CONF = {}
    if os.path.isfile(CONF_PATH):
        try:
            f = open(CONF_PATH, 'r', encoding='utf8')
            lines = f.readlines()
            f.close()
        except Exception as e:
            pass
        else:
            for line in lines:
                data = line.split('##')[0]
                try:
                    K,V = data.split('==')
                except Exception as e:
                    pass
                else:
                    D_CONF[K.strip()] = V.strip()
    
    if 'SV_数据库文件' in D_CONF:
        SV_数据库文件.set(D_CONF['SV_数据库文件'])
    else:
        SV_数据库文件.set('PWD.DB')  # 设置默认值
        TEXT_CONF += 'SV_数据库文件==PWD.DB ## 保存账号密码的数据库文件路径\n'
    
    if 'SV_选择公钥文件' in D_CONF:
        SV_选择公钥文件.set(D_CONF['SV_选择公钥文件'])
    else:
        SV_选择公钥文件.set('公钥.pem')
        TEXT_CONF += 'SV_选择公钥文件==公钥.pem ## 设置公钥默认存放位置为程序同目录下，方便使用\n'
    
    if 'SV_选择私钥文件' in D_CONF:
        SV_选择私钥文件.set(D_CONF['SV_选择私钥文件'])
    else:
        SV_选择私钥文件.set('私钥.pem')
        TEXT_CONF += 'SV_选择私钥文件==私钥.pem ## 设置私钥默认存放位置为程序同目录下，方便使用（不安全，私钥加密后可以提高安全性）\n'
    
    if 'IV_随机密码位数' in D_CONF and D_CONF['IV_随机密码位数'].isdigit():
        IV_随机密码位数.set(int(D_CONF['IV_随机密码位数']))
    else:
        IV_随机密码位数.set(20)
        TEXT_CONF += 'IV_随机密码位数==20 ## 随机生成的密码长度\n'
    
    if 'IV_账号加密保存_勾选框' in D_CONF and D_CONF['IV_账号加密保存_勾选框']=='1':
        IV_账号加密保存_勾选框.set(1)
    else:
        IV_账号加密保存_勾选框.set(0)
        TEXT_CONF += 'IV_账号加密保存_勾选框==0 ## 1：账号部分用私钥加密存储，其他值为否\n'
    
    if 'IV_密码加密保存_勾选框' in D_CONF and D_CONF['IV_密码加密保存_勾选框']=='1':
        IV_密码加密保存_勾选框.set(1)
    else:
        IV_密码加密保存_勾选框.set(0)
        TEXT_CONF += 'IV_密码加密保存_勾选框==1 ## 1：密码部分用私钥加密存储，其他值为否\n'
    
    if 'SV_私钥密码' in D_CONF:
        SV_私钥密码.set(D_CONF['SV_私钥密码'])  ## 私钥密码不推荐写配置文件，不安全
    else:
        TEXT_CONF += 'SV_私钥密码== ## 私钥密码不推荐写配置文件，不安全\n'
    
    if 'SV_随机密码数字字符集' in D_CONF:
        SV_随机密码数字字符集.set(D_CONF['SV_随机密码数字字符集'])
    else:
        SV_随机密码数字字符集.set('01234567890')
        TEXT_CONF += 'SV_随机密码数字字符集==01234567890 ## 随机密码数字组成部分\n'
    
    if 'SV_随机密码大写字母集' in D_CONF:
        SV_随机密码大写字母集.set(D_CONF['SV_随机密码大写字母集'])
    else:
        SV_随机密码大写字母集.set('ABCDEFGHJKMNPQRSTUVWXYZ')
        TEXT_CONF += 'SV_随机密码大写字母集==ABCDEFGHJKMNPQRSTUVWXYZ ## 随机密码大写字母组成部分\n'
    
    if 'SV_随机密码小写字母集' in D_CONF:
        SV_随机密码小写字母集.set(D_CONF['SV_随机密码小写字母集'])
    else:
        SV_随机密码小写字母集.set('abcdefghjkmnpqrstuvwxyz')
        TEXT_CONF += 'SV_随机密码小写字母集==abcdefghjkmnpqrstuvwxyz ## 随机密码小写字母组成部分\n'
    
    if 'SV_随机密码符号字符集' in D_CONF:
        SV_随机密码符号字符集.set(D_CONF['SV_随机密码符号字符集'])
    else:
        SV_随机密码符号字符集.set('`~!@#$%^&*()-_=+[{]}|;:<.>/?')
        TEXT_CONF += 'SV_随机密码符号字符集==`~!@#$%^&*()-_=+[{]}|;:<.>/? ## 随机密码符号组成部分\n'
    
    ## 配置文件不存在就生成一个模板文件
    if not os.path.exists(CONF_PATH):
        with open(CONF_PATH, 'w', encoding='utf-8') as f:
            f.write(TEXT_CONF)

####################
## TKinter 主窗口 ##
####################
top = Tk()  # 初始化Tk()
top.title('密码管理工具(Python3/tkinterGUI)')   # 设置标题
窗口宽 = 783
窗口高 = 483
# 获取屏幕尺寸以计算布局参数，使窗口居屏幕中央
屏幕宽 = top.winfo_screenwidth()
屏幕高 = top.winfo_screenheight()
主窗口显示位置 = '%dx%d+%d+%d' % (窗口宽, 窗口高, (屏幕宽-窗口宽)/2, (屏幕高-窗口高)/2)
top.geometry(主窗口显示位置)
top.resizable(width=True, height=True) # 设置窗口是否可变长、宽（True：可变，False：不可变）
top.grid_columnconfigure(0, weight=1)   # (第1列, 自适应窗口宽)
top.grid_rowconfigure(1, weight=1)      # (第2行, 自适应窗口高)


## 全局变量 设置 显示
D_CACHE = {'右键菜单对应数据':'', 'LOG':''}
序号宽 = 5
备注宽 = 35
账号宽 = 25
密码宽 = 25
SV_数据库文件 = StringVar()
SV_数据库文件提示 = StringVar()
SV_数据库文件提示.set('Sqlite3')
IV_密钥长度 = IntVar()
SV_新私钥密码 = StringVar()
SV_选择公钥文件 = StringVar()       ## TK全局变量:可以实时更新显示
SV_公钥提示信息 = StringVar()       ## 显示公钥文件的情况
SV_选择私钥文件 = StringVar()
SV_私钥提示信息 = StringVar()
IV_随机密码位数 = IntVar()
SV_随机密码数字字符集 = StringVar()
SV_随机密码大写字母集 = StringVar()
SV_随机密码小写字母集 = StringVar()
SV_随机密码符号字符集 = StringVar()
IV_账号加密保存_勾选框 = IntVar()
IV_密码加密保存_勾选框 = IntVar()
SV_私钥密码 = StringVar()   # 解密用
SV_剪贴板提示信息 = StringVar()

初始化配置文件('PWD.conf')

def 生成新密钥对():
    时间 = time.strftime('%Y%m%d_%H%M%S')
    当前设置密钥长度 = IV_密钥长度.get()
    随机数生成器 = Random.new().read
    密钥对 = RSA.generate(当前设置密钥长度, 随机数生成器)
    
    ## 保存公钥
    if SV_选择公钥文件.get() != '':
        if os.path.exists(SV_选择公钥文件.get()):
            新公钥文件名 = f'公钥_{时间}.pem'
        else:
            新公钥文件名 = SV_选择公钥文件.get()
    else:
        if os.path.exists('公钥.pem'):
            新公钥文件名 = f'公钥_{时间}.pem'
        else:
            新公钥文件名 = '公钥.pem'
    公钥 = 密钥对.publickey().exportKey()                        # 导出公钥
    with open(新公钥文件名, 'wb') as f:
        f.write(公钥)
    LOGGING(f"新公钥文件名={新公钥文件名}", 'i')
    
    ## 保存私钥
    if SV_选择私钥文件.get() != '':
        if os.path.exists(SV_选择私钥文件.get()):
            新私钥文件名 = f'私钥_{时间}.pem'
        else:
            新私钥文件名 = SV_选择私钥文件.get()
    else:
        if os.path.exists('私钥.pem'):
            新私钥文件名 = f'私钥_{时间}.pem'
        else:
            新私钥文件名 = '私钥.pem'
    
    私钥密码 = SV_新私钥密码.get().strip()
    if 私钥密码 == '':
        私钥 = 密钥对.exportKey()                                    # 导出明文私钥
        with open(新私钥文件名, 'wb') as f:
            f.write(私钥)
        LOGGING(f"新私钥文件名（明文私钥）={新私钥文件名}", 'w')
    else:
        私钥 = 密钥对.exportKey(passphrase=私钥密码, pkcs=8, protection='scryptAndAES128-CBC')   # 导出密文私钥
        with open(新私钥文件名, 'wb') as f:
            f.write(私钥)
        LOGGING(f"新私钥文件名（密文私钥）={新私钥文件名}", 'i')
        
    INFO = '生成新密钥对完成，长度为：' + str(当前设置密钥长度)
    tkinter.messagebox.showinfo(title='INFO', message=INFO)
    ## 自动替换为新生成密钥对
    SV_选择公钥文件.set(新公钥文件名)
    SV_公钥提示信息.set('自动替换为新生成的公钥文件')
    SV_选择私钥文件.set(新私钥文件名)
    SV_私钥提示信息.set('自动替换为新生成的私钥文件')

## 显示日志
def LOGGING(TEXT, LEVEL):
    if D_CACHE['LOG'] != '' and D_CACHE['LOG'].winfo_exists()==1:
        D_CACHE['LOG'].insert(0.0, f"{time.strftime('%Y-%m-%d %H:%M:%S')} {TEXT}\n", LEVEL)

def DEF_按钮_选择数据库文件():
    数据库文件路径 = filedialog.askopenfilename()
    SV_数据库文件.set(数据库文件路径)       # 及时更新

def DEF_按钮_选择公钥文件():
    公钥文件路径 = filedialog.askopenfilename()
    SV_选择公钥文件.set(公钥文件路径)

def DEF_按钮_选择私钥文件():
    私钥文件路径 = filedialog.askopenfilename()
    SV_选择私钥文件.set(私钥文件路径)

def DEF_显示设置小窗():
    新窗口 = Toplevel()
    新窗口.title('设置')
    显示坐标 = '+500+200'
    新窗口.geometry(显示坐标)
    新窗口.grid_columnconfigure(0, weight=1)   # (第0列, 自适应窗口宽)
    新窗口.grid_rowconfigure(0, weight=1)      # (第0列, 自适应窗口高)
    
    全局变量展示框 = LabelFrame(新窗口, text='设置 全局变量')   # , bg='#FFD700'
    全局变量展示框.grid(row=0,column=0,sticky='NSEW')
    全局变量展示框.grid_columnconfigure(1, weight=1)
    全局变量展示框.grid_rowconfigure(6, weight=1)
    
    全局变量显示宽 = 35
    
    Button(全局变量展示框, text='选择[数据文件]', command=DEF_按钮_选择数据库文件).grid(row=0,column=0,sticky='NSEW')
    Entry(全局变量展示框, textvariable=SV_数据库文件, width=全局变量显示宽       ).grid(row=0,column=1,sticky='NSEW')
    Label(全局变量展示框, textvariable=SV_数据库文件提示                         ).grid(row=0,column=2,sticky='NSEW')
    
    Label(全局变量展示框, text='设置[密钥长度]'                                  ).grid(row=1,column=0,sticky='NSEW')
    Label(全局变量展示框, textvariable=IV_密钥长度                               ).grid(row=1,column=2,sticky='NSEW')
    
    def 选择密钥长度后执行函数(event):
        设置新密钥长度 = Combobox_密钥长度.get()
        IV_密钥长度.set(设置新密钥长度)
        LOGGING(f"设置新密钥长度={设置新密钥长度}", 'd')
    
    Combobox_密钥长度 = ttk.Combobox(全局变量展示框, width=5)
    Combobox_密钥长度['value'] = (1024, 2048, 3072, 4096)
    Combobox_密钥长度.current(3)                            # 默认值中的内容为索引，从0开始
    IV_密钥长度.set(Combobox_密钥长度.get())
    Combobox_密钥长度.grid(row=1, column=1, sticky='NSEW')
    Combobox_密钥长度.bind('<<ComboboxSelected>>', 选择密钥长度后执行函数)
    
    Label(全局变量展示框, text='设置[私钥密码]'                                  ).grid(row=2,column=0,sticky='NSEW')
    Entry(全局变量展示框, textvariable=SV_新私钥密码, width=全局变量显示宽       ).grid(row=2,column=1,sticky='NSEW')
    Button(全局变量展示框, text='生成新密钥对', command=生成新密钥对             ).grid(row=2,column=2,sticky='NSEW')
    
    Button(全局变量展示框, text='选择[公钥文件]', command=DEF_按钮_选择公钥文件  ).grid(row=3,column=0,sticky='NSEW')
    Entry(全局变量展示框, textvariable=SV_选择公钥文件, width=全局变量显示宽     ).grid(row=3,column=1,sticky='NSEW')
    Label_公钥提示信息 = Label(全局变量展示框, textvariable=SV_公钥提示信息)
    Label_公钥提示信息.grid(                                                            row=3,column=2,sticky='W')
    if os.path.isfile(SV_选择公钥文件.get()):
        SV_公钥提示信息.set('公钥文件存在')
        Label_公钥提示信息['fg'] = 'green'
    else:
        SV_公钥提示信息.set('未找到')
        Label_公钥提示信息['fg'] = 'red'
    
    Button(全局变量展示框, text='选择[私钥文件]', command=DEF_按钮_选择私钥文件  ).grid(row=4,column=0,sticky='NSEW')
    Entry(全局变量展示框, textvariable=SV_选择私钥文件, width=全局变量显示宽     ).grid(row=4,column=1,sticky='NSEW')
    Label_私钥提示信息 = Label(全局变量展示框, textvariable=SV_私钥提示信息)
    Label_私钥提示信息.grid(                                                            row=4,column=2,sticky='W')
    if os.path.isfile(SV_选择私钥文件.get()):
        SV_私钥提示信息.set('私钥文件存在')
        Label_私钥提示信息['fg'] = 'green'
    else:
        SV_私钥提示信息.set('未找到')
        Label_私钥提示信息['fg'] = 'red'
    
    def DEF_按钮_修改私钥密码():
        tkinter.messagebox.showinfo(title='INFO', message='未实现')
        新窗口.attributes('-topmost', True)    ## 保持子窗口在主窗口前面
    
    Label(全局变量展示框,  text='解密[私钥密码]'                                  ).grid(row=5,column=0,sticky='NSEW')
    Entry(全局变量展示框, textvariable=SV_私钥密码, width=全局变量显示宽, show='*').grid(row=5,column=1,sticky='NSEW')
    Button(全局变量展示框, text='修改密码', command=DEF_按钮_修改私钥密码         ).grid(row=5,column=2,sticky='NSEW')
    
    Label(全局变量展示框, text='随机密码组成[数字字符]'                           ).grid(row=6,column=0,sticky='NSEW')
    Entry(全局变量展示框, textvariable=SV_随机密码数字字符集, width=全局变量显示宽).grid(row=6,column=1,sticky='NSEW')
    
    Label(全局变量展示框, text='随机密码组成[大写字母]'                           ).grid(row=7,column=0,sticky='NSEW')
    Entry(全局变量展示框, textvariable=SV_随机密码大写字母集, width=全局变量显示宽).grid(row=7,column=1,sticky='NSEW')
    
    Label(全局变量展示框, text='随机密码组成[小写字母]'                           ).grid(row=8,column=0,sticky='NSEW')
    Entry(全局变量展示框, textvariable=SV_随机密码小写字母集, width=全局变量显示宽).grid(row=8,column=1,sticky='NSEW')
    
    Label(全局变量展示框, text='随机密码组成[符号字符]'                           ).grid(row=9,column=0,sticky='NSEW')
    Entry(全局变量展示框, textvariable=SV_随机密码符号字符集, width=全局变量显示宽).grid(row=9,column=1,sticky='NSEW')
    
    ## 日志显示
    LF_日志框 = LabelFrame(全局变量展示框, text='日志（倒序）')
    LF_日志框.grid_columnconfigure(0, weight=1)
    LF_日志框.grid_rowconfigure(0, weight=1)      # (第0列, 自适应窗口高)
    TEXT_应用日志 = Text(LF_日志框, height=10, wrap='none')
    Scrollbar_日志框_竖 = Scrollbar(LF_日志框)
    Scrollbar_日志框_竖['command'] = TEXT_应用日志.yview
    Scrollbar_日志框_横 = Scrollbar(LF_日志框)
    Scrollbar_日志框_横['command'] = TEXT_应用日志.xview
    Scrollbar_日志框_横['orient'] = HORIZONTAL
    Scrollbar_日志框_竖.grid(row=0, column=1, sticky='NSEW')
    Scrollbar_日志框_横.grid(row=1, column=0, sticky='NSEW')
    TEXT_应用日志.config(xscrollcommand=Scrollbar_日志框_横.set, yscrollcommand=Scrollbar_日志框_竖.set)  # 自动设置滚动条滑动幅度
    TEXT_应用日志.grid(row=0, column=0, sticky='NSEW')
    TEXT_应用日志.tag_config('d', foreground='black')
    TEXT_应用日志.tag_config('i', foreground='green')  # 自定义文本格式 绿字
    TEXT_应用日志.tag_config('w', foreground='blue')   # 自定义文本格式 蓝字
    TEXT_应用日志.tag_config('e', backgroun='yellow', foreground='red')  # 自定义文本格式 黄底红字
    D_CACHE['LOG'] = TEXT_应用日志
    LF_日志框.grid(row=10, column=0, columnspan=3, sticky='NSEW')
    
    Label(全局变量展示框, text='[===END===]').grid(row=11, column=0, columnspan=3)

######## Sqlite3 SQL 语句函数
def DEF_SQLite3_返回_字段列表_数据列表(DB_PATH, SQL_CMD):
    数据库连接对象 = sqlite3.connect(DB_PATH)     # 尝试打开数据库文件
    try:
        游标对象 = 数据库连接对象.cursor()
    except Exception as e:
        ERROR = f'创建游标失败{e}'
        return(-1, ERROR)
    else:
        try:
            游标对象.execute(SQL_CMD)
        except Exception as e:
            ERROR = f'执行SQL语句 {SQL_CMD} 失败 {e}'
            游标对象.close()
            return(-1, ERROR)
        else:
            全部记录 = 游标对象.fetchall()                       # 获取全部查询数据记录
            游标对象_字段名列表 = 游标对象.description           # 获取查询结果的字段信息
            字段名列表 = [i[0] for i in 游标对象_字段名列表]     # 整理成字段名列表
            游标对象.close()
            return(0, (字段名列表, 全部记录))

## 执行一条SQL语句
def DEF_SQL_执行(DB_PATH, SQL_CMD):
    数据库连接对象 = sqlite3.connect(DB_PATH)     # 尝试打开数据库文件
    try:
        游标对象 = 数据库连接对象.cursor()         # 创建一个游标
    except Exception as e:
        ERROR = '创建游标失败' + str(e)
        return(1, ERROR)
    else:
        try:
            游标对象.execute(SQL_CMD)
        except Exception as e:
            游标对象.close()
            ERROR = f"执行SQL语句出错: {e}"
            return(1, ERROR)
        else:
            数据库连接对象.commit()           # 提交更改
            游标对象.close()
            数据库连接对象.close()
            return(0, '操作成功')

## 初始化数据库：PWD表不存在则新建表
def 初始化数据库():
    DB_PATH = SV_数据库文件.get()
    ## 如果数据表 PWD 不存在则新建
    SQL_CMD = '''CREATE TABLE IF NOT EXISTS PWD(
    ID INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
    PS TEXT,
    USER TEXT,
    PASS TEXT,
    DATE timestamp not null default(datetime('now','localtime')));'''
    R = DEF_SQL_执行(DB_PATH, SQL_CMD)
    if R[0] == 0:
        INFO = "检查/初始化数据表 PWD 成功"
        LOGGING(INFO, 'i')
    else:
        ERROR = f'初始化数据表 PWD 失败:{R[1]}'
        LOGGING(ERROR, 'e')
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)

## 打开/刷新数据表
def 打开数据库():
    初始化数据库()
    ## 打开数据库，读取数据库密码表内容
    DB_PATH = SV_数据库文件.get()
    SQL_CMD = 'SELECT * FROM PWD'
    R = DEF_SQLite3_返回_字段列表_数据列表(DB_PATH, SQL_CMD)
    if R[0] == 0:
        INFO = "数据库表 PWD 读取成功"
        LOGGING(INFO, 'i')
        字段列表, 数据列表 = R[1]
        字段和数据的存储和展示(字段列表, 数据列表) ## 显示在界面
    else:
        ERROR = f'数据库表 PWD 读取失败:{R[1]}'
        LOGGING(ERROR, 'e')
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)


## 信息复制到剪贴板

def 解密密文(密文文本):
    ## 读取选中单元格字符串尝试还原字节类型
    try:
        还原字节码 = bytes.fromhex(密文文本)
    except Exception as E1:
        ERROR = f'还原字节码失败，格式有误(非16进制字符串形式:{E1}'
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)
    else:
        ## 尝试加载私钥
        私钥文件 = SV_选择私钥文件.get()
        if 私钥文件.rstrip() == '':
            ERROR = '没有选择私钥文件'
            LOGGING(ERROR, 'e')
            tkinter.messagebox.showerror(title='ERROR', message=ERROR)
        else:
            try:
                f = open(私钥文件,'r')
            except Exception as E2:
                ERROR = f'打开私钥文件失败:{E2}'
                LOGGING(ERROR, 'e')
                tkinter.messagebox.showerror(title='ERROR', message=ERROR)
            else:
                LOGGING("打开私钥文件成功", 'i')
                STR_私钥 = f.read()
                f.close()
                
                ## 根据私钥是否被加密分别处理
                私钥密码 = SV_私钥密码.get()
                if 私钥密码 != '':
                    LOGGING("检测到私钥密码，先解密私钥，再导入使用", 'd')
                    try:
                        OJB_私钥 = RSA.importKey(STR_私钥, passphrase=私钥密码)
                    except Exception as E3:
                        ERROR = f'导入私钥失败，私钥【密码错误】或【格式错误】:{E3}'
                        LOGGING(ERROR, 'e')
                        tkinter.messagebox.showerror(title='ERROR', message=ERROR)
                    else:
                        LOGGING("导入私钥成功", 'd')
                        私钥_PKCS115 = PKCS1_v1_5.new(OJB_私钥) 
                        
                        ## 私钥尝试解密
                        随机数生成器 = Random.new().read
                        try:
                            明文字节码 = 私钥_PKCS115.decrypt(还原字节码, 随机数生成器)
                        except Exception as E4:
                            ERROR = f'私钥解密失败:{E4}'
                            LOGGING(ERROR, 'e')
                            tkinter.messagebox.showerror(title='ERROR', message=ERROR)
                        else:
                            LOGGING("私钥解密成功", 'i')
                            明文字符串 = 明文字节码.decode('utf8')
                            return(明文字符串)
                else:
                    LOGGING("未检测到私钥密码，直接导入使用", 'd')
                    try:
                        OJB_私钥 = RSA.importKey(STR_私钥)
                    except Exception as E3:
                        ERROR = f'导入私钥失败，私钥【被加密】或【格式错误】:{E3}'
                        LOGGING(ERROR, 'e')
                        tkinter.messagebox.showerror(title='ERROR', message=ERROR)
                    else:
                        LOGGING("导入私钥成功", 'd')
                        私钥_PKCS115 = PKCS1_v1_5.new(OJB_私钥) 
                        
                        ## 私钥尝试解密
                        随机数生成器 = Random.new().read
                        try:
                            明文字节码 = 私钥_PKCS115.decrypt(还原字节码, 随机数生成器)
                        except Exception as E4:
                            ERROR = f'私钥解密失败:{E4}'
                            LOGGING(ERROR, 'e')
                            tkinter.messagebox.showerror(title='ERROR', message=ERROR)
                        else:
                            LOGGING("私钥解密成功", 'i')
                            明文字符串 = 明文字节码.decode('utf8')
                            return(明文字符串)

def 复制到剪贴板_原值(选中值):
    top.clipboard_clear()           # 清空剪贴板
    top.clipboard_append(选中值)    # 写入剪贴板
    LOGGING(f"已经复制到剪贴板(原值)={选中值}", 'i')
    SV_剪贴板提示信息.set('【数据原值】 已经复制到剪贴板')

def 复制到剪贴板_解密(选中值):
    top.clipboard_clear()           # 清空剪贴板
    #top.clipboard_append(选中值)    # 写入剪贴板
    LOGGING(f"开始复制到剪贴板(解密)={选中值}", 'd')
    明文字符串 = 解密密文(选中值)
    if 明文字符串:
        top.clipboard_append(明文字符串)
        INFO = '【解密后内容】 已经复制到剪贴板'
        SV_剪贴板提示信息.set(INFO)

def 删除数据行(ID):
    LOGGING(f"DELETE ID {ID}", 'd')
    
    用户选择结果 = tkinter.messagebox.askquestion(title='删除确认', message=f'确定要删除{ID}?')
    LOGGING(f"用户选择结果={用户选择结果}", 'd')
    if 用户选择结果 == 'yes':
        DB_PATH = SV_数据库文件.get()
        SQL_CMD = f'DELETE FROM PWD WHERE ID = "{ID}"'
        LOGGING(f"SQL_CMD={SQL_CMD}", 'd')
        ## 删除记录
        R = DEF_SQL_执行(DB_PATH, SQL_CMD)
        if R[0] == 0:
            打开数据库()
            tkinter.messagebox.showinfo(title='INFO', message='删除成功')
        else:
            ERROR = f'删除记录失败:{R[1]}'
            tkinter.messagebox.showerror(title='ERROR', message=ERROR)

def 提示操作():
    tkinter.messagebox.showinfo(title='INFO', message='请使用鼠标左键操作')

def 根据编号删除整行():
    选中值 = D_CACHE['右键菜单对应数据'][0]
    删除数据行(选中值)

def 备注原值复制到剪贴板():
    选中值 = D_CACHE['右键菜单对应数据'][1]
    复制到剪贴板_原值(选中值)

def 账号原值复制到剪贴板():
    选中值 = D_CACHE['右键菜单对应数据'][2]
    复制到剪贴板_原值(选中值)

def 账号解密到剪贴板():
    选中值 = D_CACHE['右键菜单对应数据'][2]
    复制到剪贴板_解密(选中值)

def 密码原值复制到剪贴板():
    选中值 = D_CACHE['右键菜单对应数据'][3]
    复制到剪贴板_原值(选中值)

def 密码解密复制到剪贴板():
    选中值 = D_CACHE['右键菜单对应数据'][3]
    复制到剪贴板_解密(选中值)

def DEF_显示修改小窗():
    新窗口 = Toplevel()
    新窗口.title('修改')
    显示坐标 = '+500+200'
    新窗口.geometry(显示坐标)
    新窗口.grid_columnconfigure(2, weight=1)   # (第0列, 自适应窗口宽)
    新窗口.grid_columnconfigure(3, weight=1)
    新窗口.grid_columnconfigure(4, weight=1)
    新窗口.grid_rowconfigure(2, weight=1)      # (第0列, 自适应窗口高)
    
    标题框 = Frame(新窗口, bg='#FFD700')
    原值框 = Frame(新窗口, bg='#FFD700')
    新值框 = Frame(新窗口, bg='#FFD700')
    标题框.grid(row=0,column=0,sticky='W')
    原值框.grid(row=1,column=0,sticky='W')
    新值框.grid(row=2,column=0,sticky='W')
    
    if len(D_CACHE['右键菜单对应数据']) == 4:
        ID,PS,USER,PASS = D_CACHE['右键菜单对应数据']   # 兼容旧版本
    else:
        ID,PS,USER,PASS,DATE = D_CACHE['右键菜单对应数据']
    
    def 弹出右键菜单(event):
        选中控件 = event.widget
        LOGGING(f"弹出右键菜单={选中控件.grid_info()}", 'd')
        列 = 选中控件.grid_info()['column']
        if 列 == 3:      # 账号
            D_CACHE['右键菜单对应数据'] = ['','',USER_新值.get(1.0, END).rstrip('\n'),'']
        elif 列 == 4:    # 密码
            D_CACHE['右键菜单对应数据'] = ['','','',PASS_新值.get(1.0, END).rstrip('\n')]
        右键菜单_新窗口.post(event.x_root, event.y_root)   # 光标位置显示菜单
    def 转成明文():
        if D_CACHE['右键菜单对应数据'][2] != '':
            R = 解密密文(D_CACHE['右键菜单对应数据'][2])
            if R:
                USER_新值.delete(0.0, END)
                USER_新值.insert(0.0, R)
        elif D_CACHE['右键菜单对应数据'][3] != '':
            R = 解密密文(D_CACHE['右键菜单对应数据'][3])
            if R:
                PASS_新值.delete(0.0, END)
                PASS_新值.insert(0.0, R)
    def 转成密文():
        if D_CACHE['右键菜单对应数据'][2] != '':
            R = 加密明文(D_CACHE['右键菜单对应数据'][2])
            if R:
                USER_新值.delete(0.0, END)
                USER_新值.insert(0.0, R)
        elif D_CACHE['右键菜单对应数据'][3] != '':
            R = 加密明文(D_CACHE['右键菜单对应数据'][3])
            if R:
                PASS_新值.delete(0.0, END)
                PASS_新值.insert(0.0, R)
    右键菜单_新窗口 = Menu(tearoff=False)
    右键菜单_新窗口.add_command(label='转成明文', command=转成明文)
    右键菜单_新窗口.add_command(label='转成密文', command=转成密文)

    ID_标题   = Entry(新窗口, width=序号宽)
    PS_标题   = Entry(新窗口, width=备注宽)
    USER_标题 = Entry(新窗口, width=账号宽)
    PASS_标题 = Entry(新窗口, width=密码宽)
    ID_标题.insert(0, 'ID')
    PS_标题.insert(0, 'PS')
    USER_标题.insert(0, 'USER   右键菜单(明/密)转换')
    PASS_标题.insert(0, 'PASS   右键菜单(明/密)转换')
    ID_标题['stat']='readonly'
    PS_标题['stat']='readonly'
    USER_标题['stat']='readonly'
    PASS_标题['stat']='readonly'
    
    Label(标题框, text='标题').grid(row=0,column=0,sticky='W')
    ID_标题.grid(row=0,column=1,sticky='W')
    PS_标题.grid(row=0,column=2,sticky='WSNE')
    USER_标题.grid(row=0,column=3,sticky='WSNE')
    PASS_标题.grid(row=0,column=4,sticky='WSNE')
    
    ID_原值   = Entry(新窗口, width=序号宽)
    PS_原值   = Entry(新窗口, width=备注宽)
    USER_原值 = Entry(新窗口, width=账号宽)
    PASS_原值 = Entry(新窗口, width=密码宽)
    ID_原值.insert(0, ID)
    PS_原值.insert(0, PS)
    USER_原值.insert(0, USER)
    PASS_原值.insert(0, PASS)
    ID_原值['stat']='readonly'
    PS_原值['stat']='readonly'
    USER_原值['stat']='readonly'
    PASS_原值['stat']='readonly'
    Label(原值框, text='原值').grid(row=1,column=0,sticky='W')
    ID_原值.grid(row=1,column=1,sticky='W')
    PS_原值.grid(row=1,column=2,sticky='WSNE')
    USER_原值.grid(row=1,column=3,sticky='WSNE')
    PASS_原值.grid(row=1,column=4,sticky='WSNE')
    
    ID_新值   = Text(新窗口, width=序号宽, height=3)
    PS_新值   = Text(新窗口, width=备注宽, height=3)
    USER_新值 = Text(新窗口, width=账号宽, height=3)
    PASS_新值 = Text(新窗口, width=密码宽, height=3)
    USER_新值.bind("<Button-3>", 弹出右键菜单)
    PASS_新值.bind("<Button-3>", 弹出右键菜单)
    ID_新值.insert(0.0, ID)
    ID_新值.configure(state='disabled')   # 设置为不可编辑
    PS_新值.insert(0.0, PS)
    USER_新值.insert(0.0, USER)
    PASS_新值.insert(0.0, PASS)
    Label(新值框, text='新值').grid(row=2,column=0,sticky='W')
    ID_新值.grid(row=2,column=1,sticky='WSNE')
    PS_新值.grid(row=2,column=2,sticky='WSNE')
    USER_新值.grid(row=2,column=3,sticky='WSNE')
    PASS_新值.grid(row=2,column=4,sticky='WSNE')
    
    def DELETE():
        ID = ID_原值.get()
        删除数据行(ID)
        新窗口.destroy()   ## 关闭子窗口
    
    def UPDATE():
        对比结果 = ''
        L_更新内容 = []
        if PS_新值.get(1.0, END).rstrip('\n') != PS_原值.get():
            对比结果 += '备注(改)'
            VALUE = PS_新值.get(1.0, END).rstrip('\n')
            L_更新内容.append(f"PS='{VALUE}'")
        else:
            对比结果 += '备注()'
        
        if USER_新值.get(1.0, END).rstrip('\n') != USER_原值.get():
            对比结果 += '账号(改)'
            VALUE = USER_新值.get(1.0, END).rstrip('\n')
            L_更新内容.append(f"USER='{VALUE}'")
        else:
            对比结果 += '账号()'
        
        if PASS_新值.get(1.0, END).rstrip('\n') != PASS_原值.get():
            对比结果 += '密码(改)'
            VALUE = PASS_新值.get(1.0, END).rstrip('\n')
            L_更新内容.append(f"PASS='{VALUE}'")
        else:
            对比结果 += '密码()'
        
        LOGGING(对比结果, 'd')
        
        if L_更新内容 != []:
            DB_PATH = SV_数据库文件.get()
            SQL_CMD = f"UPDATE PWD SET {', '.join(L_更新内容)} WHERE ID={ID_原值.get()}"
            LOGGING(SQL_CMD, 'd')
            R = DEF_SQL_执行(DB_PATH, SQL_CMD)
            if R[0] == 0:
                LOGGING(R[1], 'i')
                新窗口.destroy()                   ## 关闭子窗口
                打开数据库() # 刷新一下
                tkinter.messagebox.showinfo(title='INFO', message=R[1])
            else:
                打开数据库() # 刷新一下
                LOGGING(R[1], 'e')
                tkinter.messagebox.showerror(title='ERROR', message=R[1])
        else:
            新窗口.attributes('-topmost', True)    ## 保持子窗口在主窗口前面
            tkinter.messagebox.showwarning(title='WARNING', message="未检测到更改")
    
    Button(新窗口, text='删除', fg='red',   command=DELETE).grid(row=3, column=0, columnspan=2,sticky='WSNE')
    Button(新窗口, text='更新', bg='#FFA500', command=UPDATE).grid(row=3, column=2, columnspan=3,sticky='WSNE')


## 创建数据框右键菜单(编号)
数据框_右键菜单_编号 = Menu(tearoff=False)
数据框_右键菜单_编号.add_command(label='修改此行(鼠标左键双击)', command=DEF_显示修改小窗)
数据框_右键菜单_编号.add_command(label='删除此行', command=根据编号删除整行)

## 创建数据框右键菜单(备注)
数据框_右键菜单_备注 = Menu(tearoff=False)
数据框_右键菜单_备注.add_command(label='原值 到 剪贴板(鼠标左键双击)', command=备注原值复制到剪贴板)

## 创建数据框右键菜单(账号)
数据框_右键菜单_账号 = Menu(tearoff=False)
数据框_右键菜单_账号.add_command(label='原值 到 剪贴板(鼠标左键双击)', command=账号原值复制到剪贴板)
数据框_右键菜单_账号.add_command(label='解密 到 剪贴板', command=账号解密到剪贴板)

## 创建数据框右键菜单(密码)
数据框_右键菜单_密码 = Menu(tearoff=False)
数据框_右键菜单_密码.add_command(label='解密 到 剪贴板(鼠标左键双击)', command=密码解密复制到剪贴板)
数据框_右键菜单_密码.add_command(label='原值 复制到 剪贴板', command=密码原值复制到剪贴板)


## 在显编框展示结果，保存结果到全局变量
def 字段和数据的存储和展示(L_字段名, LL_数据值):
    列数 = len(L_字段名)
    行数 = len(LL_数据值)
    LOGGING(f"显示字段名={L_字段名}", 'd')
    xscroll = Scrollbar(top, orient=HORIZONTAL)
    yscroll = Scrollbar(top, orient=VERTICAL)
    
    TV_数据表格 = ttk.Treeview(
        master=top,                 # 父容器
        columns=L_字段名,           # 显示的列
        show='headings',            # 隐藏首列
        xscrollcommand=xscroll.set, # x轴滚动条
        yscrollcommand=yscroll.set, # y轴滚动条
    )
    
    for 列名 in L_字段名:
        TV_数据表格.heading(column=列名, text=列名, anchor=W)   # 定义表头
        if 列名 == 'ID':
            TV_数据表格.column(column=列名, anchor=W, width=39, minwidth=39, stretch=False)  # 定义列
        elif 列名 == 'DATE':
            TV_数据表格.column(column=列名, anchor=W, width=127, minwidth=127, stretch=False)
        elif 列名 == 'PS':
            TV_数据表格.column(column=列名, anchor=W, width=290, minwidth=290)
        else:
            TV_数据表格.column(column=列名, anchor=W, width=150, minwidth=150)
    
    LL_数据值.reverse()    # 倒序显示
    for DATA in LL_数据值:
        TV_数据表格.insert('', END, values=DATA)  # 添加数据到末尾
    
    ## 嵌套函数
    def DEF_嵌套_鼠标左键双击(event):
        选中IID = TV_数据表格.identify_row(event.y)
        选中列 = TV_数据表格.identify_column(event.x)
        列号_PY_INDEX = int(选中列[1:])-1
        DEBUG = f"鼠标左键双击 选中IID={选中IID} 选中列={选中列} 列号_PY_INDEX={列号_PY_INDEX}"
        LOGGING(DEBUG, 'd')
        if 选中IID:
            L_VALUES = TV_数据表格.item(选中IID)['values']
            选中值 = L_VALUES[列号_PY_INDEX]
            if 列号_PY_INDEX == 0:    # ID列，修改用
                D_CACHE['右键菜单对应数据'] = L_VALUES
                DEF_显示修改小窗()
            elif 列号_PY_INDEX == 3:    # 密码数据
                复制到剪贴板_解密(选中值)
            else:
                复制到剪贴板_原值(选中值)
            
        else:
            LOGGING("【点出界外】应该的点在表头行了", 'w')
    
    def DEF_嵌套_鼠标右键(event):
        选中IID = TV_数据表格.identify_row(event.y)
        选中列 = TV_数据表格.identify_column(event.x)
        列号_PY_INDEX = int(选中列[1:])-1
        
        DEBUG = f"鼠标右键 选中IID={选中IID} 选中列={选中列} 列号_PY_INDEX={列号_PY_INDEX}"
        LOGGING(DEBUG, 'd')
        if 选中IID:
            TV_数据表格.selection_set(选中IID)
            L_VALUES = TV_数据表格.item(选中IID)['values']
            点击格内容 = L_VALUES[列号_PY_INDEX]
            DEBUG = f"L_VALUES={L_VALUES} 点击格内容={点击格内容}"
            LOGGING(DEBUG, 'd')
            D_CACHE['右键菜单对应数据'] = L_VALUES
            
            ## 弹出菜单
            光标X轴 = event.x_root
            光标Y轴 = event.y_root
            if 列号_PY_INDEX == 0:    # ID列，删除用
                数据框_右键菜单_编号.post(光标X轴, 光标Y轴)
            elif 列号_PY_INDEX == 2:
                数据框_右键菜单_账号.post(光标X轴, 光标Y轴)
            elif 列号_PY_INDEX == 3:    # 密码数据
                数据框_右键菜单_密码.post(光标X轴, 光标Y轴)    # 光标位置显示菜单
            else:
                数据框_右键菜单_备注.post(光标X轴, 光标Y轴)
            
        else:
            INFO = "【点出界外】应该的点在表头行了"
            LOGGING(INFO, 'i')
            D_CACHE['右键菜单对应数据'] = ''
    
    TV_数据表格.bind('<Double-Button-1>', DEF_嵌套_鼠标左键双击)   # 绑定左键双击事件
    TV_数据表格.bind('<Button-3>', DEF_嵌套_鼠标右键)              # 打开菜单

    xscroll.config(command=TV_数据表格.xview)
    xscroll.grid(row=2,column=0,sticky='NSEW')
    yscroll.config(command=TV_数据表格.yview)
    yscroll.grid(row=1,column=1,sticky='NSEW')
    TV_数据表格.grid(row=1,column=0,sticky='NSEW')  # 显示填满空间


##
def 加密明文(明文文本):
    ERROR = ''
    公钥文件 = SV_选择公钥文件.get()
    if 公钥文件.rstrip() == '':
        ERROR = '没有选择公钥文件'
    else:
        try:
            f = open(公钥文件,'r')
        except Exception as E1:
            ERROR = f'打开公钥文件失败:{E1}'
            LOGGING(ERROR, 'e')
        else:
            LOGGING("打开公钥文件成功", 'd')
            STR_公钥 = f.read()
            f.close()
            try:
                OJB_公钥 = RSA.importKey(STR_公钥)
            except Exception as E2:
                ERROR = f'导入公钥失败:{E2}'
                LOGGING(ERROR, 'e')
            else:
                公钥_PKCS115 = PKCS1_v1_5.new(OJB_公钥)
                明文字节码 = 明文文本.encode('utf8')
                try:
                    密文字节码 = 公钥_PKCS115.encrypt(明文字节码)   # 公钥加密
                except Exception as E3:
                    ERROR = f'公钥加密失败:{E3}'
                    LOGGING(ERROR, 'e')
                else:
                    LOGGING("公钥加密成功", 'i')
                    STR_HEX = Bytes2HEX_STR(密文字节码)  ## 字节类型转成16进制字符串存储到数据库
                    return(STR_HEX)
    if ERROR != '':
        ERROR += '\n请打开 "设置" 按钮处理'
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)

def 存入数据库():
    备注 = Entry_备注.get().strip()
    帐号 = Entry_帐号.get().strip()
    密码 = Entry_密码.get().strip()
    if 帐号 == '' or 密码 == '':
        ERROR = '帐号/密码 中有空内容'
        LOGGING(ERROR, 'e')
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)
    else:
        if IV_账号加密保存_勾选框.get() == 1:
            帐号_STR_HEX = 加密明文(帐号)
            if 帐号_STR_HEX:
                帐号 = 帐号_STR_HEX
            else:
                帐号 = ''
            
        if IV_密码加密保存_勾选框.get() == 1:
            密码_STR_HEX = 加密明文(密码)
            if 密码_STR_HEX:
                密码 = 密码_STR_HEX
            else:
                密码 = ''
        
        if 帐号 != '' and 密码 != '':
            DB_PATH = SV_数据库文件.get()
            SQL_插入数据 = f'INSERT INTO PWD (PS, USER, PASS) VALUES ("{备注}", "{帐号}", "{密码}");'
            R_INSERT = DEF_SQL_执行(DB_PATH, SQL_插入数据)
            if R_INSERT[0] == 0:
                LOGGING("保存成功", 'i')
                Entry_备注.delete(0, END)         # 界面：清空输入框
                Entry_帐号.delete(0, END)         # 界面：清空输入框
                Entry_密码.delete(0, END)         # 界面：清空输入框
                打开数据库()                      # 更新数据库显示框
            else:
                ERROR = f'插入数据失败:{R_INSERT[1]}'
                LOGGING(ERROR, 'e')
                tkinter.messagebox.showerror(title='ERROR', message=ERROR)
        else:
            ERROR = '帐号或密码加密失败'
            LOGGING(ERROR, 'e')

def 搜索备注信息():
    备注 = Entry_备注.get().strip()
    if 备注 == '':
        ERROR = '备注空内容'
        LOGGING(ERROR, 'e')
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)
    else:
        DB_PATH = SV_数据库文件.get()
        SQL_CMD = f'SELECT * FROM PWD WHERE PS LIKE "%{备注}%"'
        LOGGING(f"搜索备注内容={备注} SQL_CMD={SQL_CMD}", 'd')
        R = DEF_SQLite3_返回_字段列表_数据列表(DB_PATH, SQL_CMD)
        if R[0] == 0:
            LOGGING("执行搜索语句成功", 'i')
            字段列表, 数据列表 = R[1]
            字段和数据的存储和展示(字段列表, 数据列表)
        else:
            ERROR = f'执行搜索语句失败:{R[1]}'
            LOGGING(ERROR, 'e')
            tkinter.messagebox.showerror(title='ERROR', message=ERROR)

def 生成随机密码():
    密码长度 = IV_随机密码位数.get()
    数字字符列表 = [i for i in SV_随机密码数字字符集.get()]
    大写字母列表 = [i for i in SV_随机密码大写字母集.get()]
    小写字母列表 = [i for i in SV_随机密码小写字母集.get()]
    符号字符列表 = [i for i in SV_随机密码符号字符集.get()]
    
    组合列表 = 数字字符列表 + 大写字母列表 + 小写字母列表 + 符号字符列表
    if 密码长度 > 84:
        ERROR = '过长，请设置长度 <= 84'
        tkinter.messagebox.showerror(title='ERROR', message=ERROR)
    else:
        random.shuffle(组合列表)
        随机密码 = ''
        for i in range(0, 密码长度):
            随机密码 += 组合列表[i]
        Entry_密码.delete(0, END)         # 界面：清空输入框
        Entry_密码.insert(END, 随机密码)

## 字节码转16进制格式的字符串
def Bytes2HEX_STR(Bytes):
    STR_HEX = ''
    for i in Bytes:
        STR_HEX += hex(i)[2:].zfill(2)      ## '0x50' 取 '50' 部分，如果不足2个字符，填充0
    return(STR_HEX)


操作框 = Frame(top)   #LabelFrame(top, text='操作框')

序号框 = Frame(操作框)
Label(序号框, text='序号').grid(row=0, column=0)
Entry_序号 = Entry(序号框, width=序号宽)
Entry_序号.grid(row=1, column=0, sticky='ESWN')

备注框 = Frame(操作框)
Label(备注框, text='备注').grid(row=0, column=0)
Entry_备注 = Entry(备注框, width=备注宽)
Entry_备注.grid(row=1, column=0, sticky='ESWN')
Button(备注框, text='  搜索  ', command=搜索备注信息).grid(row=2, column=0)
备注框.grid_columnconfigure(0, weight=1)

帐号框 = Frame(操作框)
Label(帐号框, text='帐号').grid(row=0, column=0)
Entry_帐号 = Entry(帐号框, width=账号宽)
Entry_帐号.grid(row=1, column=0, sticky='ESWN')
Checkbutton(帐号框, text='加密保存', variable=IV_账号加密保存_勾选框).grid(row=2,column=0)
帐号框.grid_columnconfigure(0, weight=1)

密码框 = Frame(操作框)
Label(密码框, text='密码').grid(row=0, column=0)
Entry_密码 = Entry(密码框, width=密码宽)
Entry_密码.grid(row=1, column=0, sticky='ESWN')
Checkbutton(密码框, text='加密保存', variable=IV_密码加密保存_勾选框).grid(row=2,column=0)
密码框.grid_columnconfigure(0, weight=1)

数据库操作框 = Frame(操作框) #LabelFrame(操作框, text='数据库操作框')
Button(数据库操作框, text='  设置  ', fg='red', command=DEF_显示设置小窗).grid(row=0,column=0,sticky='ESWN')
Button(数据库操作框, text='  刷新数据库  ', fg='#FFA500', command=打开数据库).grid(row=0, column=1, sticky='ESWN')
Label_剪贴板提示信息 = Label(数据库操作框, textvariable=SV_剪贴板提示信息, width=50)
Label_剪贴板提示信息['fg'] = '#FF6600'
Label_剪贴板提示信息.grid(row=0, column=2, sticky='ESWN')

保存框 = Frame(数据库操作框)
Label(保存框, text='长度'                                   ).grid(row=0, column=1, sticky='ESWN')
Entry(保存框, textvariable=IV_随机密码位数, width=4             ).grid(row=0, column=2, sticky='ESWN')
Button(保存框, text='  生成随机密码  ', command=生成随机密码).grid(row=0, column=3, sticky='ESWN')
Button(保存框, text='  保存  ', command=存入数据库, fg='red').grid(row=0, column=4, sticky='ESWN')

保存框.grid(row=0, column=3, sticky='ESWN')
数据库操作框.grid_columnconfigure(2, weight=1)

序号框.grid(row=0, column=0, sticky='NW')
备注框.grid(row=0, column=1, sticky='WSNE')
帐号框.grid(row=0, column=2, sticky='WSNE')
密码框.grid(row=0, column=3, sticky='WSNE')
数据库操作框.grid(row=1, column=0, columnspan=4, sticky='ESWN')

操作框.grid_columnconfigure(1, weight=1)   # (第2列, 自适应窗口宽)
操作框.grid_columnconfigure(2, weight=1)   # (第3列, 自适应窗口宽)
操作框.grid_columnconfigure(3, weight=1)   # (第4列, 自适应窗口宽)
操作框.grid(row=0, column=0, sticky='WSNE')

## 开软件后先执行数据库的初始化和打开
打开数据库()

# 进入消息循环
top.mainloop()