[已解决]pyttsx3 不能停止的问题

newbison

大家好，我写了一个给小朋友听写的小App。
目前存在一个问题，就是我暂停点了Close之后，就容易卡死。
应该是pyttsx3的engine还在运行，无法直接停掉。请问大家有办法吗？

1. import tkinter as tk
   
2. from tkinter import ttk
   
3. import json
   
4. import random
   
5. import pyttsx3  
   
6. import time
   
7. import threading
   
8. import os
   
9. 
   
10. current_dir = os.path.join(os.path.abspath(__file__))
    
11. parent_dir = os.path.dirname(current_dir)
    
12. 
    
13. # Initialize TTS engine
    
14. engine = pyttsx3.init()
    
15. engine.setProperty("rate", 100)
    
16. engine.setProperty("volume", 1)
    
17. 
    
18. voices = engine.getProperty("voices")
    
19. 
    
20. class LanguageLearningApp:
    
21.     def __init__(self, master):
    
22.         self.master = master
    
23.         self.master.title("Language Learning App")
    
24.         self.master.geometry("400x300")
    
25. 
    
26.         self.language_var = tk.StringVar(value="english")
    
27.         self.word_count_var = tk.IntVar(value=10)
    
28.         self.sleep_time_var = tk.DoubleVar(value=1.0)
    
29.         self.order_var = tk.StringVar(value="random")
    
30.         self.file_var = tk.StringVar(value="primary")
    
31.         self.grade_var = tk.StringVar()
    
32. 
    
33. 
    
34.         self.is_paused = False
    
35.         self.is_running = False
    
36.         self.stop_thread = False  # Flag to stop the thread
    
37. 
    
38.         self.create_widgets()
    
39. 
    
40.     def create_widgets(self):
    
41.         # Language selection
    
42.         language_frame = tk.Frame(self.master)
    
43.         language_frame.pack(pady=5)
    
44.         tk.Label(language_frame, text="Select Language:").pack(side=tk.LEFT)
    
45.         tk.Radiobutton(language_frame, text="English", variable=self.language_var, value="english").pack(side=tk.LEFT)
    
46.         tk.Radiobutton(language_frame, text="Chinese", variable=self.language_var, value="chinese").pack(side=tk.LEFT)
    
47. 
    
48.         # Word count selection
    
49.         tk.Label(self.master, text="Number of Words:").pack(pady=5)
    
50.         word_counts = [5, 10, 20, 50, 75, 100]
    
51.         ttk.Combobox(self.master, textvariable=self.word_count_var, values=word_counts).pack()
    
52. 
    
53.         # Sleep time selection
    
54.         tk.Label(self.master, text="Sleep Time (seconds):").pack(pady=5)
    
55.         sleep_times = [i/10 for i in range(6, 16, 1)]
    
56.         ttk.Combobox(self.master, textvariable=self.sleep_time_var, values=sleep_times).pack()
    
57. 
    
58.         # Order selection
    
59.         order_frame = tk.Frame(self.master)
    
60.         order_frame.pack(pady=5)
    
61.         tk.Label(order_frame, text="Order:").pack(side=tk.LEFT)
    
62.         tk.Radiobutton(order_frame, text="Sequential", variable=self.order_var, value="sequential").pack(side=tk.LEFT)
    
63.         tk.Radiobutton(order_frame, text="Random", variable=self.order_var, value="random").pack(side=tk.LEFT)
    
64. 
    
65.         # File selection
    
66.         file_frame = tk.Frame(self.master)
    
67.         file_frame.pack(pady=5)
    
68.         tk.Label(file_frame, text="Select File:").pack(side=tk.LEFT)
    
69.         tk.Radiobutton(file_frame, text="Primary", variable=self.file_var, value="primary").pack(side=tk.LEFT)
    
70.         tk.Radiobutton(file_frame, text="High School", variable=self.file_var, value="high_school").pack(side=tk.LEFT)
    
71.         tk.Radiobutton(file_frame, text="College", variable=self.file_var, value="college").pack(side=tk.LEFT)
    
72. 
    
73.         # Start, Pause, and Close buttons
    
74.         button_frame = tk.Frame(self.master)
    
75.         button_frame.pack(pady=20)
    
76.         tk.Button(button_frame, text="Start", command=self.start_learning).pack(side=tk.LEFT, padx=5)
    
77.         self.pause_button = tk.Button(button_frame, text="Pause", command=self.toggle_pause)
    
78.         self.pause_button.pack(side=tk.LEFT, padx=5)
    
79.         tk.Button(button_frame, text="Close", command=self.close_app).pack(side=tk.LEFT, padx=5)
    
80. 
    
81.     def toggle_pause(self):
    
82.         self.is_paused = not self.is_paused
    
83.         if self.is_paused:
    
84.             self.pause_button.config(text="Resume")
    
85.         else:
    
86.             self.pause_button.config(text="Pause")
    
87. 
    
88.     def start_learning(self):
    
89.         file_map = {
    
90.             "primary": "words.json",
    
91.             "high_school": "high_school_words.json",
    
92.             "college": "college_words.json"
    
93.         }
    
94. 
    
95.         selected_file = file_map[self.file_var.get()]
    
96.         filepath = os.path.join(parent_dir, selected_file)
    
97.         with open(filepath, "r", encoding="utf-8") as file:
    
98.             word_dict = json.load(file)
    
99. 
    
100.         language = self.language_var.get()
     
101.         word_count = self.word_count_var.get()
     
102.         sleep_time = self.sleep_time_var.get()
     
103.         order = self.order_var.get()
     
104. 
     
105.         if language == "english":
     
106.             words = list(word_dict.keys())
     
107.             engine.setProperty("voice", voices[1].id)  # English voice
     
108.         else:
     
109.             words = list(word_dict.values())
     
110.             engine.setProperty("voice", voices[0].id)  # Chinese voice
     
111. 
     
112.         if order == "random":
     
113.             words = random.sample(words, word_count)
     
114.         else:
     
115.             words = words[:word_count]
     
116. 
     
117.         self.stop_thread = False  # Reset the stop flag
     
118.         self.is_running = True
     
119.         threading.Thread(target=self.display_and_pronounce, args=(words, sleep_time)).start()
     
120. 
     
121.     def display_and_pronounce(self, words, sleep_time):
     
122.         for word in words:
     
123.             if self.stop_thread:  # Check if the thread needs to be stopped
     
124.                 break
     
125.             while self.is_paused:
     
126.                 time.sleep(0.1)
     
127.             length = len(word.split(" "))
     
128.             if length == 1:
     
129.                 gap = 2 * sleep_time
     
130.             elif length == 2:
     
131.                 gap = 3 * sleep_time
     
132.             elif length == 3:
     
133.                 gap = 5 * sleep_time
     
134.             else:
     
135.                 gap = 9 * sleep_time
     
136.             
     
137.             engine.say(word)
     
138.             engine.runAndWait()
     
139.             time.sleep(gap)
     
140.             engine.say(word)
     
141.             engine.runAndWait()
     
142.             time.sleep(gap)
     
143. 
     
144.         self.show_words_popup(words)
     
145. 
     
146.     def show_words_popup(self, words):
     
147.         popup = tk.Toplevel(self.master)
     
148.         popup.title("Selected Words")
     
149.         popup.geometry("400x300")
     
150. 
     
151.         formatted_words = "\n".join(["\t".join(words[i:i+5]) for i in range(0, len(words), 5)])
     
152.         tk.Label(popup, text=formatted_words, font=("Arial", 14), justify=tk.LEFT, wraplength=350).pack(pady=20)
     
153.         tk.Button(popup, text="Close", command=popup.destroy).pack(pady=5)
     
154. 
     
155.     def close_app(self):
     
156.         self.stop_thread = True  # Set the flag to stop the thread
     
157.         self.is_running = False
     
158.         engine.stop()          # stop the TTS engine
     
159.         self.master.destroy()  # Close the main window
     
160. 
     
161. if __name__ == "__main__":
     
162.     root = tk.Tk()
     
163.     app = LanguageLearningApp(root)
     
164.     root.mainloop()
     

复制代码

最佳答案

月排行榜 / 总排行榜

FishC

2024-8-2 10:14:14

哈哈，看来你的应用在关闭的时候像个不愿意离开的客人一样，依然赖在那儿继续说话！别担心，我来帮你找到解决方案。

问题的核心在于 `pyttsx3` 的 `engine.runAndWait()` 在调用时会阻塞线程，也就是说一旦你开始播放一个单词，它需要等到声音播完才能继续执行后面的代码。为了优雅地处理这个问题，我们可以在关闭应用时确保 TTS 引擎能够顺利停止。

### 解决方案

1. **使用 `engine.stop()`**: 在 `close_app` 方法中确保调用 `engine.stop()` ，这样它就会立即停止当前正在播放的音频。
   
2. **在 `display_and_pronounce` 方法中处理 `stop_thread` 标志**: 使用 `stop_thread` 标志来检查是否应当停止播放。

3. **简化 TTS 播放逻辑**: 如果 TTS 引擎在某些情况下仍然没有反应，可以考虑在语音播放的地方使用 `threading.Event()` 来实现更好的线程控制。

下面是更新后的 `LanguageLearningApp` 类的一部分，展示了如何修改 `close_app` 和相关逻辑：

1. def display_and_pronounce(self, words, sleep_time):
   
2.     for word in words:
   
3.         if self.stop_thread:  # Check if the thread needs to be stopped
   
4.             break
   
5.         while self.is_paused:
   
6.             time.sleep(0.1)
   
7. 
   
8.         gap = self.calculate_gap(word, sleep_time)
   
9.         
   
10.         engine.say(word)      
    
11.         engine.runAndWait()   
    
12.         
    
13.         if self.stop_thread:
    
14.             break  # Stop if the thread needs to end
    
15. 
    
16.         time.sleep(gap)      
    
17.         engine.say(word)      
    
18.         engine.runAndWait()   
    
19. 
    
20.         if self.stop_thread:
    
21.             break  # Stop if the thread needs to end
    
22.             
    
23.         time.sleep(gap)
    
24. 
    
25. def calculate_gap(self, word, sleep_time):
    
26.     length = len(word.split(" "))
    
27.     if length == 1:
    
28.         return 2 * sleep_time
    
29.     elif length == 2:
    
30.         return 3 * sleep_time
    
31.     elif length == 3:
    
32.         return 5 * sleep_time
    
33.     else:
    
34.         return 9 * sleep_time
    
35. 
    
36. def close_app(self):
    
37.     self.stop_thread = True  # Set the flag to stop the thread
    
38.     if self.is_running:      # Only stop if it's running
    
39.         engine.stop()       # Stop the TTS engine
    
40.     self.master.destroy()    # Close the main window

复制代码

### 总结

- 确保在关闭应用时正确设置停止标志并停止 TTS 引擎。
- 确保每次调用 `engine.runAndWait()` 后检查是否需要提前退出。
- 用计算间隔的函数来简化你的代码，使逻辑更加清晰。

试试这个改动，看看你的应用是否能在关闭时变得乖巧一些！如果依然有问题，别犹豫，来找我寻求帮助哦！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

跳转到最佳答案楼层

FishC

哈哈，看来你的应用在关闭的时候像个不愿意离开的客人一样，依然赖在那儿继续说话！别担心，我来帮你找到解决方案。

问题的核心在于 `pyttsx3` 的 `engine.runAndWait()` 在调用时会阻塞线程，也就是说一旦你开始播放一个单词，它需要等到声音播完才能继续执行后面的代码。为了优雅地处理这个问题，我们可以在关闭应用时确保 TTS 引擎能够顺利停止。

### 解决方案

1. **使用 `engine.stop()`**: 在 `close_app` 方法中确保调用 `engine.stop()` ，这样它就会立即停止当前正在播放的音频。
   
2. **在 `display_and_pronounce` 方法中处理 `stop_thread` 标志**: 使用 `stop_thread` 标志来检查是否应当停止播放。

3. **简化 TTS 播放逻辑**: 如果 TTS 引擎在某些情况下仍然没有反应，可以考虑在语音播放的地方使用 `threading.Event()` 来实现更好的线程控制。

下面是更新后的 `LanguageLearningApp` 类的一部分，展示了如何修改 `close_app` 和相关逻辑：

1. def display_and_pronounce(self, words, sleep_time):
   
2.     for word in words:
   
3.         if self.stop_thread:  # Check if the thread needs to be stopped
   
4.             break
   
5.         while self.is_paused:
   
6.             time.sleep(0.1)
   
7. 
   
8.         gap = self.calculate_gap(word, sleep_time)
   
9.         
   
10.         engine.say(word)      
    
11.         engine.runAndWait()   
    
12.         
    
13.         if self.stop_thread:
    
14.             break  # Stop if the thread needs to end
    
15. 
    
16.         time.sleep(gap)      
    
17.         engine.say(word)      
    
18.         engine.runAndWait()   
    
19. 
    
20.         if self.stop_thread:
    
21.             break  # Stop if the thread needs to end
    
22.             
    
23.         time.sleep(gap)
    
24. 
    
25. def calculate_gap(self, word, sleep_time):
    
26.     length = len(word.split(" "))
    
27.     if length == 1:
    
28.         return 2 * sleep_time
    
29.     elif length == 2:
    
30.         return 3 * sleep_time
    
31.     elif length == 3:
    
32.         return 5 * sleep_time
    
33.     else:
    
34.         return 9 * sleep_time
    
35. 
    
36. def close_app(self):
    
37.     self.stop_thread = True  # Set the flag to stop the thread
    
38.     if self.is_running:      # Only stop if it's running
    
39.         engine.stop()       # Stop the TTS engine
    
40.     self.master.destroy()    # Close the main window

复制代码

### 总结

- 确保在关闭应用时正确设置停止标志并停止 TTS 引擎。
- 确保每次调用 `engine.runAndWait()` 后检查是否需要提前退出。
- 用计算间隔的函数来简化你的代码，使逻辑更加清晰。

试试这个改动，看看你的应用是否能在关闭时变得乖巧一些！如果依然有问题，别犹豫，来找我寻求帮助哦！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

newbison

完美解决，非常感谢鱼C。
下一步我就需要找到小学、初中、高中的英语词汇表，以后就可以用电脑给小孩听写单词了~~