1、词频统计

统计文本文件中每个单词出现的频率。

实现

import tkinter as tk
from tkinter import filedialog, messagebox
from collections import Counter
import re

class WordFrequencyCounter:
    def __init__(self, master):
        self.master = master
        self.master.title("词频统计")
        
        self.label = tk.Label(master, text="选择一个文本文件进行词频统计")
        self.label.pack(pady=10)

        self.select_button = tk.Button(master, text="选择文件", command=self.select_file)
        self.select_button.pack(pady=5)

        self.result_text = tk.Text(master, width=50, height=20)
        self.result_text.pack(pady=10)

    def select_file(self):
        """选择文件并统计单词频率"""
        file_path = filedialog.askopenfilename(filetypes=[("Text files", "*.txt")])
        if file_path:
            try:
                self.count_words(file_path)
            except Exception as e:
                messagebox.showerror("错误", f"读取文件时出错: {e}")

    def count_words(self, file_path):
        """统计单词频率并显示结果"""
        with open(file_path, 'r', encoding='utf-8') as file:
            text = file.read()
        
        # 统计单词频率
        words = re.findall(r'\b\w+\b', text.lower())  # 使用正则表达式提取单词并转换为小写
        word_count = Counter(words)  # 统计单词频率
        self.display_results(word_count)
        return word_count #为了UT 写了return

    def display_results(self, word_count):
        """显示单词频率结果"""
        self.result_text.delete(1.0, tk.END)  # 清空文本框
        for word, count in word_count.items():
            self.result_text.insert(tk.END, f"{word}: {count}\n")  # 打印每个单词及其频率

if __name__ == "__main__":
    root = tk.Tk()
    app = WordFrequencyCounter(root)
    root.mainloop()

测试

unittest

import unittest
from collections import Counter
from word_frequency_counter import WordFrequencyCounter  # 假设你的类在这个文件中
import tkinter as tk

class TestWordFrequencyCounter(unittest.TestCase):
    
    def setUp(self):
        """创建一个 Tkinter 窗口以便测试"""
        self.root = tk.Tk()
        self.app = WordFrequencyCounter(self.root)
        self.test_file_path = 'test_sample.txt'
        with open(self.test_file_path, 'w', encoding='utf-8') as f:
            f.write("Hello world! Hello Python. Hello, hello world.")

    def tearDown(self):
        """销毁 Tkinter 窗口"""
        self.root.destroy()

    def test_count_words(self):
        """测试单词计数功能"""
        expected_count = Counter({'hello': 4, 'world': 2, 'python': 1})

        # 使用私有方法进行测试
        word_count = self.app.count_words(self.test_file_path)
        self.assertEqual(word_count, expected_count)

    def test_display_results(self):
        """测试结果显示功能"""
        test_count = Counter({'hello': 4, 'world': 1})
        self.app.display_results(test_count)

        # 检查文本框内容
        expected_output = "hello: 4\nworld: 1\n"
        self.assertEqual(self.app.result_text.get(1.0, tk.END).strip(), expected_output.strip())

if __name__ == "__main__":
    unittest.main()

pytest

import pytest
from collections import Counter
from word_frequency_counter import WordFrequencyCounter  # 假设你的类在这个文件中
import tkinter as tk

@pytest.fixture
def app():
    """创建一个 Tkinter 窗口以便测试"""
    root = tk.Tk()
    app = WordFrequencyCounter(root)
    app.test_file_path = 'test_sample.txt'
    with open(app.test_file_path, 'w', encoding='utf-8') as f:
        f.write("Hello world! Hello Python. Hello, hello world.")
    yield app
    
    root.destroy()

def test_count_words(app):
    """测试单词计数功能"""
    expected_count = Counter({'hello': 4, 'world': 2, 'python': 1})

    # 使用私有方法进行测试
    word_count = app.count_words(app.test_file_path)
    assert word_count == expected_count

def test_display_results(app):
    """测试结果显示功能"""
    test_count = Counter({'hello': 4, 'world': 1})
    app.display_results(test_count)

    # 检查文本框内容
    expected_output = "hello: 4\nworld: 1\n"
    assert app.result_text.get(1.0, tk.END).strip() == expected_output.strip()

2、简单的闹钟

设置一个简单的闹钟，指定时间后播放提示音。

实现

import tkinter as tk
from tkinter import messagebox
from datetime import datetime
import winsound  # Windows平台播放声音
import threading
import time

class AlarmClock:
    def __init__(self, root):
        self.root = root
        self.root.title("闹铃")
        self.alarms = []

        # GUI Components
        self.label = tk.Label(root, text="设置时间 (HH:MM):")
        self.label.pack(pady=10)

        self.entry = tk.Entry(root)
        self.entry.pack(pady=10)

        self.event_label = tk.Label(root, text="事件描述:")
        self.event_label.pack(pady=10)

        self.event_entry = tk.Entry(root)
        self.event_entry.pack(pady=10)

        self.add_button = tk.Button(root, text="添加闹铃", command=self.add_alarm)
        self.add_button.pack(pady=10)

        self.alarm_listbox = tk.Listbox(root)
        self.alarm_listbox.pack(pady=10)

        self.remove_button = tk.Button(root, text="删除闹铃", command=self.remove_alarm)
        self.remove_button.pack(pady=10)

        # Start alarm checking in a separate thread
        self.check_alarms_thread = threading.Thread(target=self.check_alarms, daemon=True)
        self.check_alarms_thread.start()

    def add_alarm(self):
        time_str = self.entry.get()
        event = self.event_entry.get()

        try:
            # Validate time format
            datetime.strptime(time_str, "%H:%M")
            self.alarms.append((time_str, event))
            self.alarm_listbox.insert(tk.END, f"{time_str} - {event}")
            self.entry.delete(0, tk.END)
            self.event_entry.delete(0, tk.END)
        except ValueError:
            messagebox.showerror("无效得时间", "Please enter time in HH:MM format.")

    def remove_alarm(self):
        selected = self.alarm_listbox.curselection()
        if selected:
            self.alarm_listbox.delete(selected)
            self.alarms.pop(selected[0])

    def check_alarms(self):
        while True:
            current_time = datetime.now().strftime("%H:%M")
            for alarm in self.alarms:
                if alarm[0] == current_time:
                    winsound.Beep(1000, 2000)  # 1000Hz, 1秒
                    messagebox.showinfo("Alarm", f"Time for: {alarm[1]}")
                    self.alarms.remove(alarm)
                    self.alarm_listbox.delete(0)
            time.sleep(30)  # Check every 30 seconds

if __name__ == "__main__":
    root = tk.Tk()
    app = AlarmClock(root)
    root.mainloop()

测试：

unittest

import unittest
from datetime import datetime
from unittest.mock import patch
from AlarmClock import AlarmClock
import tkinter as tk

class TestAlarmClock(unittest.TestCase):
    def setUp(self):
        self.root = tk.Tk()
        self.app = AlarmClock(self.root)

    def test_add_alarm_valid(self):
        self.app.entry.insert(0, "12:30")
        self.app.event_entry.insert(0, "Meeting")
        self.app.add_alarm()
        self.assertEqual(len(self.app.alarms), 1)
        self.assertEqual(self.app.alarms[0], ("12:30", "Meeting"))

    def test_add_alarm_invalid(self):
        self.app.entry.insert(0, "25:00")
        self.app.event_entry.insert(0, "Invalid Time")
        self.app.add_alarm()
        self.assertEqual(len(self.app.alarms), 0)

    def test_remove_alarm(self):
        self.app.entry.insert(0, "12:30")
        self.app.event_entry.insert(0, "Meeting")
        self.app.add_alarm()
        self.app.alarm_listbox.select_set(0)
        self.app.remove_alarm()
        self.assertEqual(len(self.app.alarms), 0)

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

if __name__ == "__main__":
    unittest.main()

pytest

import pytest
from datetime import datetime
from unittest.mock import patch
from AlarmClock import AlarmClock
import tkinter as tk

@pytest.fixture
def app():
    root = tk.Tk()
    app = AlarmClock(root)
    yield app
    root.destroy()

def test_add_alarm_valid(app):
    app.entry.insert(0, "12:30")
    app.event_entry.insert(0, "Meeting")
    app.add_alarm()
    assert len(app.alarms) == 1
    assert app.alarms[0] == ("12:30", "Meeting")

def test_add_alarm_invalid(app):
    app.entry.insert(0, "25:00")
    app.event_entry.insert(0, "Invalid Time")
    app.add_alarm()
    assert len(app.alarms) == 0

def test_remove_alarm(app):
    app.entry.insert(0, "12:30")
    app.event_entry.insert(0, "Meeting")
    app.add_alarm()
    app.alarm_listbox.select_set(0)
    app.remove_alarm()
    assert len(app.alarms) == 0