python文件操作图形化——python实战项目：单词练习系统

python 文件操作与图形化编程

文件基本操作

D：\Python\example.txt

• 文件路径:D:\Python\
• 文件名:example
• 文件扩展名:.txt
  文件的组织形式和表达数据的方式更有效、更灵活。按编码方式一般分为两大类型：文本文件和二进制文件

Python对文件采用统一的操作步骤：打开—操作—关闭

1. open()

# 变量名=open(文件名,打开模式,文件编码)
f=open('example.txt','r',encoding='utf-8')

2. close()

f.close()

3. 文件读取
   当文件以文本文件方式打开时，读写按照字符串方式进行操作，并用当前计算机使用的编码或指定的编码。当文件以二进制文件方式打开时，读写按照字节流方式进行操作。

4. 文件写入
   file.seek(offset):改变当前文件操作指针的位置。offset：0表示文件开头，1当前位置，2文件结尾

图形化界面tkinter

tkinter是使用Python进行窗口视窗设计的模块。tkinter模块（＂Tk接口＂）是Python的标准Tk GUI工具包的接口。作为Python特定的GUI界面，它是一个图像的窗口，并且tkinter是Python自带的模块，可以编辑GUI界面，并且可以用GUI实现很多直观的功能，例如开发一个计算器或者开发一个有交互功能的小系统。
由于tkinter是Python内置的库，不用安装，所以只需在使用时导入tkinter模块：import tkinter，或者from tkinter import∗。
需要说明的是，虽然tkinter很好用，但是如果要开发一些大型的应用，tkinterᨀ供的功能还是太少了，需要使用wxPython、PyQt这些第三方库。

1. 主窗体创建运行

• 图形用户界面程序都需要一个根窗口，也叫主窗口，它就好像绘画时需要的画纸一样，tkinterᨀ供创建主窗口的构造函数Tk（）
• 窗口和组件都创建好后，需要运行，程序要不停地告诉窗口管理对象GM（Geometry Manager）有一个组件产生

# 创建
root = Tk()
# 运行
root.mainloop()

2. tkinter的组件
   canvas，Frame，Label…

3. 组件属性
   background,borderwidth，cursor…

单词练习系统

需求：设计单词练习系统，建立一个单词库，可以从单词库中随机抽取单词进行练习。练习方式有英译中、中译英、拼写填空，对于回答正确的问题会给出提示，并增加积分，错误的问题只有ᨀ示，不增加积分。练习完成后可以查看出错的单词，并对错误的单词进行次数统计。

1. 初始化设置
   创建系统类，在类中创建构造方法，设置各种初始化变量。
   （1）创建tkinter窗口对象，设置窗口属性。
   （2）设置窗口中需要使用的变量，如：当前积分、显示的随机单词，以及回答ᨀ示信息。
   （3）创建单选按钮组名。创建各类变量，相当于是全局变量。
   （1）创建单词列表变量。
   （2）创建错词列表变量。
   （3）创建显示单词变量。
   （4）创建拼写填空的变量。
   （5）创建随机数变量（用于从单词表中随机抽取单词）。
   （6）引用各种方法：如界面设置布局、窗体运行方法。
   初始化代码：

import tkinter
import tkinter.messagebox
import random


class Recite():

    def __init__(self):
        self.root = tkinter.Tk()
        self.root.geometry('450*500')
        self.root.title('xxr背单词')
        self.root['bg'] = 'yellow'
        self.word = tkinter.StringVar()
        self.score = tkinter.StringVar()
        self.fen = 0
        self.score.set(0)
        self.prompt = tkinter.StringVar()
        self.prompt.set('你最棒~')
        self.wrong = []
        self.dic = []
        self.word_list()
        # print(len(self.dic))
        self.radiolist = tkinter.IntVar()
        self.fill = ''
        self.space = ''
        self.r = random.randint(0, len(self.dic) - 1)
        self.word.set(self.dic[self.r][0])
        self.layout()
        self.root.mainloop()

2. 单词读取设计
   从单词库文件中将单词读取出来。可以用数据库，也可以使用文件，此处用的是文件。文件中的每一行由一个单词的中英文构成。
   打开文件读取数据，先对数据进行清洗，按换行符将它们分离成列表，一个单词为一个元素。再对列表进行遍历，对于遍历到的每一个元素即单词再次进行分离，即每个单词分成中文和英文两个元素，将分离得到的列表追加到初始化设置中创建的单词列表变量中。
   代码:

def word_list(self):
    f = open('words.txt', 'r', encoding='utf-8')
    t = f.read().split('\n')
    for d in t:
        self.dic.append(d.split())
        f.close()

主界面布局代码：

def layout(self):
    lab1 = tkinter.Label(self.root,
                         text='xxr 背单词',
                         font=('宋体', 30),
                         bg='yellow')
    lab1.pack(pady=20)
    lab_score = tkinter.Label(self.root,
                              textvariable=self.score,
                              font=('宋体', 30),
                              fg='red',
                              bg='yellow')
    lab_score.pack()
    lab_2 = tkinter.Label(self.root, text='当前积分:', font=('宋体', 16), g='yellow')
    lab_2.place(x=40, y=100)
    lab_word = tkinter.Label(self.root,
                             textvariable=self.word,
                             font=('宋体', 20),
                             bg='white')
    lab_word.place(x=130, y=140)
    lab_prompt = tkinter.Label(self.root,
                               textvariable=self.prompt,
                               font=('宋体', 18),
                               fg='blue',
                               bg='yellow')
    lab_prompt.place(x=150, y=250)
    self.entry = tkinter.Entry(self.root, width=15, font=('宋体', 20))
    self.entry.place(x=120, y=200)
    r1 = tkinter.Radiobutton(self.root,
                             textvariable=self.radiolist,
                             value=0,
                             text='英译中',
                             command=self.select1,
                             bg='yellow')
    r2 = tkinter.Radiobutton(self.root,
                             textvariable=self.radiolist,
                             value=1,
                             text='中译英',
                             command=self.select2,
                             bg='yellow')
    r3 = tkinter.Radiobutton(self.root,
                             textvariable=self.radiolist,
                             value=2,
                             text='拼写填空',
                             command=self.select3,
                             bg='yellow')
    self.radiolist.set(0)
    r1.place(x=40, y=130)
    r2.place(x=40, y=150)
    r3.place(x=40, y=170)
    but1 = tkinter.Button(self.root,
                          text='确定',
                          width=5,
                          font=('宋体', 15),
                          command=self.judge)
    but1.place(x=130, y=300)
    but2 = tkinter.Button(self.root,
                          text='退出',
                          width=5,
                          font=('宋体', 15),
                          command=self.exit)
    but2.place(x=230, y=300)
    but3 = tkinter.Button(self.root,
                          text='查看错词表',
                          width=10,
                          font=('宋体', 15),
                          command=self.wrong_word)
    but3.place(x=130, y=400)

3. 单词练习方式模块设计
   （1）根据练习的单选按钮，标签显示不同的内容。在文本输入框中输入相应的内容，单击“确定”按钮进行判断。
   （2）由单选按钮的command事件链接到相应的方法中

def select1(self):
    self.r = random.randint(0,len(self.dic)-1)
    self.word.set(self.dic[self.r][0])
def select2(self):
    self.r = random.randint(0,len(self.dic)-1)
    self.word.set(self.dic[self.r][1])
def select3(self):
    self.r = random.randint(0,len(self.dic)-1)
    word= self.dic[self.r][0]
    k = random.randint(0,len(word)-1)
    self.space = ''
    for i in range(len(word)):
        if i!=k:
            self.space += word[i]
        else:
            self.space += '_'
            self.fill = word[i]
    self.space = self.space + '' + self.dic[self.r][1]
    self.word.set(self.space)

4. 正误判断设计
   先判断练习方式是哪一种，再获取文本框输入的内容，将获取的内容与对应的单词表内容进行比对，如果相同，则增加积分，给出赞扬；如果不同，则给出鼓励，并将对应单词加到错词表。

def judge(self):
    if self.radiolist.get() == 2:
        s = self.entry.get().lower()
        if s == self.fill:
            self.prompt.set('太棒了')
            self.fen += 1
            self.score.set(self.fen)
        else:
            self.prompt.set('很遗憾,继续加油~')
            self.wrong.append(self.dic[self.r])
        self.r = random.randint(0, len(self.dic) - 1)
        self.select3()
        self.entry.delete(0, 'end')
    else:
        if self.radiolist.get() == 0:
            e = 0
            c = 1
        elif self.radiolist.get() == 1:
            e = 1
            c = 0
        word = self.dic[self.r][c]

        s = self.entry.get()
        if word == s:
            self.prompt.set('太棒了')
            self.fen += 1
            self.score.set(self.fen)
        else:
            self.prompt.set('很遗憾,继续加油~')
            self.wrong.append(self.dic[self.r])
        self.r = random.randint(0, len(self.dic) - 1)
        self.word.set(self.dic[self.r][e])
        self.entry.delete(0, 'end')

5. 退出设计

def exit(self):
    self.root.destroy()

6. 错词表设计
   单击“查看错词表”按钮调用错词方法，打开新的窗口，原窗口隐藏。在新窗口将错词表中的内容以表格的形式列出来，并显示错误次数。
   代码

def wrong_word(self):
    self.root.withdraw()
    self.wt = tkinter.Tk()
    self.wt.title('错词表')
    self.wt.geometry('450*500')
    self.wt['bg'] = 'yellow'
    lab_wr = tkinter.Label(self.wt,
                           text='本次练习错题表',
                           font=('宋体', 20),
                           bg='yellow')
    lab_wr.place(x=100, y=10)
    tree = ttk.Treeview(self.wt, show='headings', height=15)
    tree.place(x=30, y=50)
    tree['columns'] = ('1', '2', '3')
    tree.column('1', width=110)
    tree.column('2', width=110)
    tree.column('3', width=110)
    tree.heading('1', text='英文', anchor='center')
    tree.heading('2', text='中文', anchor='center')
    tree.heading('3', text='错误次数', anchor='center')

    but_re = tkinter.Button(self.wt,
                            text='返回',
                            font=('宋体', 15),
                            command=self.back)
    but_re.place(x=150, y=400)
    self.wrong.sort(key=lambda x: x[0])
    self.wrong.append(['', ''])
    p = self.wrong[0][0]
    c = 1
    for w in range(1, len(self.wrong)):
        if self.wrong[w][0] == p:
            c += 1
        else:
            tree.insert("",
                        'end',
                        values=(self.wrong[w - 1][0], self.wrong[w - 1][1], c))
            c = 1
            p = self.wrong[w][0]
    self.wt.protocol('WM_DELETE_WINDOM', self.back)

7. 返回设计

def back(self):
    self.wt.destroy()
    self.root.update()
    self.root.deiconify()