Python实现文字转语音(TTS)的3种方案对比

原创于 2025-10-25 10:49:42 发布 · 302 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#python #语音识别 #文字转语音 #TTS #pyttsx3 #gtts #eddge-tts

Python 专栏收录该内容

101 篇文章

订阅专栏

文章目录

Python实现文字转语音(TTS)的3种方案对比

Python实现文字转语音(TTS)的3种方案对比

Python提供了多种方式来实现文字转语音和文章朗读功能。以下是几种主流的方法：

一、主要实现方案

1. 使用 pyttsx3（离线方案）

import pyttsx3

# 初始化引擎
engine = pyttsx3.init()

# 设置属性
engine.setProperty('rate', 150)    # 语速
engine.setProperty('volume', 0.9)  # 音量 0.0-1.0

# 获取可用语音
voices = engine.getProperty('voices')
for voice in voices:
    print(f"Voice: {voice.name}, ID: {voice.id}")

# 设置语音（通常索引0是女声，1是男声）
if len(voices) > 1:
    engine.setProperty('voice', voices[1].id)

# 朗读文本
def text_to_speech(text):
    engine.say(text)
    engine.runAndWait()

# 使用示例
text_to_speech("你好，我是Python文字转语音程序")
text_to_speech("这是一段需要朗读的中文文本")

# 保存为音频文件
engine.save_to_file("这是要保存的文本内容", "output.wav")
engine.runAndWait()

2. 使用 gTTS（Google Text-to-Speech，在线方案）

from gtts import gTTS
import pygame
import io
import os

def google_tts(text, lang='zh-cn', slow=False):
    """
    使用Google TTS转换文本为语音
    """
    # 创建gTTS对象
    tts = gTTS(text=text, lang=lang, slow=slow)
    
    # 保存到内存或文件
    audio_buffer = io.BytesIO()
    tts.write_to_fp(audio_buffer)
    audio_buffer.seek(0)
    
    return audio_buffer

def play_audio(buffer):
    """
    播放音频缓冲区
    """
    pygame.mixer.init()
    pygame.mixer.music.load(buffer)
    pygame.mixer.music.play()
    
    while pygame.mixer.music.get_busy():
        pygame.time.Clock().tick(10)

# 使用示例
text = "这是一段使用Google文字转语音服务的中文文本"
audio_buffer = google_tts(text, lang='zh-cn')
play_audio(audio_buffer)

3. 使用 edge-tts（Microsoft Edge TTS，在线方案）

import asyncio
import edge_tts
import pygame

async def edge_text_to_speech(text, voice='zh-CN-XiaoxiaoNeural'):
    """
    使用Microsoft Edge TTS
    """
    communicate = edge_tts.Communicate(text, voice)
    
    # 保存到内存
    audio_buffer = io.BytesIO()
    async for chunk in communicate.stream():
        if chunk["type"] == "audio":
            audio_buffer.write(chunk["data"])
    
    audio_buffer.seek(0)
    return audio_buffer

# 包装为同步函数
def tts_sync(text, voice='zh-CN-XiaoxiaoNeural'):
    return asyncio.run(edge_text_to_speech(text, voice))

# 使用示例
text = "这是使用微软Edge文字转语音服务的中文文本"
audio_buffer = tts_sync(text)
play_audio(audio_buffer)

二、完整的文章朗读系统

import pyttsx3
import re
import time

class ArticleReader:
    def __init__(self):
        self.engine = pyttsx3.init()
        self.setup_engine()
        self.is_paused = False
        
    def setup_engine(self):
        """配置语音引擎"""
        self.engine.setProperty('rate', 160)
        self.engine.setProperty('volume', 0.8)
        
        # 尝试设置中文语音
        voices = self.engine.getProperty('voices')
        for voice in voices:
            if 'chinese' in voice.name.lower() or 'zh' in voice.id.lower():
                self.engine.setProperty('voice', voice.id)
                break
    
    def split_paragraphs(self, text):
        """分割文本为段落"""
        # 按段落分割
        paragraphs = re.split(r'\n\s*\n', text)
        result = []
        
        for para in paragraphs:
            para = para.strip()
            if para:
                # 如果段落太长，按句子分割
                if len(para) > 200:
                    sentences = re.split(r'[。！？!?]', para)
                    for sentence in sentences:
                        sentence = sentence.strip()
                        if sentence:
                            result.append(sentence)
                else:
                    result.append(para)
        
        return result
    
    def read_article(self, article_text):
        """朗读整篇文章"""
        paragraphs = self.split_paragraphs(article_text)
        
        print(f"开始朗读，共 {len(paragraphs)} 个段落")
        
        for i, paragraph in enumerate(paragraphs, 1):
            print(f"\n段落 {i}/{len(paragraphs)}: {paragraph[:50]}...")
            
            # 检查是否暂停
            while self.is_paused:
                time.sleep(0.1)
            
            self.engine.say(paragraph)
            self.engine.runAndWait()
            
            # 段落间暂停
            time.sleep(0.5)
    
    def pause(self):
        """暂停朗读"""
        self.is_paused = True
    
    def resume(self):
        """继续朗读"""
        self.is_paused = False
    
    def stop(self):
        """停止朗读"""
        self.engine.stop()

# 使用示例
def main():
    reader = ArticleReader()
    
    # 示例文章
    article = """
    人工智能是计算机科学的一个分支，它企图了解智能的实质，
    并生产出一种新的能以人类智能相似的方式做出反应的智能机器。
    
    该领域的研究包括机器人、语言识别、图像识别、自然语言处理和专家系统等。
    人工智能从诞生以来，理论和技术日益成熟，应用领域也不断扩大。
    
    可以设想，未来人工智能带来的科技产品，将会是人类智慧的“容器”。
    人工智能可以对人的意识、思维的信息过程进行模拟。
    """
    
    try:
        reader.read_article(article)
    except KeyboardInterrupt:
        print("\n朗读被用户中断")
    finally:
        reader.stop()

if __name__ == "__main__":
    main()

三、高级功能扩展

1. 带GUI的朗读程序

import tkinter as tk
from tkinter import ttk, scrolledtext
import threading
import pyttsx3

class TTSGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("文字转语音朗读器")
        self.root.geometry("600x400")
        
        self.engine = pyttsx3.init()
        self.setup_gui()
    
    def setup_gui(self):
        # 文本输入区域
        tk.Label(self.root, text="输入要朗读的文本:").pack(pady=5)
        self.text_area = scrolledtext.ScrolledText(self.root, height=15, width=70)
        self.text_area.pack(pady=5)
        
        # 控制按钮
        button_frame = tk.Frame(self.root)
        button_frame.pack(pady=10)
        
        self.read_btn = tk.Button(button_frame, text="开始朗读", command=self.start_reading)
        self.read_btn.pack(side=tk.LEFT, padx=5)
        
        self.stop_btn = tk.Button(button_frame, text="停止", command=self.stop_reading)
        self.stop_btn.pack(side=tk.LEFT, padx=5)
        
        # 设置框架
        settings_frame = tk.LabelFrame(self.root, text="语音设置")
        settings_frame.pack(pady=10, fill=tk.X, padx=20)
        
        # 语速设置
        tk.Label(settings_frame, text="语速:").grid(row=0, column=0, padx=5)
        self.rate_var = tk.IntVar(value=150)
        tk.Scale(settings_frame, from_=50, to=300, variable=self.rate_var, 
                orient=tk.HORIZONTAL).grid(row=0, column=1, padx=5)
        
        # 音量设置
        tk.Label(settings_frame, text="音量:").grid(row=0, column=2, padx=5)
        self.volume_var = tk.DoubleVar(value=0.8)
        tk.Scale(settings_frame, from_=0.0, to=1.0, resolution=0.1,
                variable=self.volume_var, orient=tk.HORIZONTAL).grid(row=0, column=3, padx=5)
    
    def start_reading(self):
        text = self.text_area.get(1.0, tk.END).strip()
        if text:
            # 在新线程中运行朗读，避免GUI冻结
            thread = threading.Thread(target=self.read_text, args=(text,))
            thread.daemon = True
            thread.start()
    
    def read_text(self, text):
        self.engine.setProperty('rate', self.rate_var.get())
        self.engine.setProperty('volume', self.volume_var.get())
        self.engine.say(text)
        self.engine.runAndWait()
    
    def stop_reading(self):
        self.engine.stop()

# 运行GUI
if __name__ == "__main__":
    root = tk.Tk()
    app = TTSGUI(root)
    root.mainloop()

2. 文件朗读功能

import pyttsx3
import os

class FileReader:
    def __init__(self):
        self.engine = pyttsx3.init()
    
    def read_text_file(self, file_path):
        """朗读文本文件"""
        if not os.path.exists(file_path):
            print(f"文件不存在: {file_path}")
            return
        
        with open(file_path, 'r', encoding='utf-8') as file:
            content = file.read()
        
        print(f"开始朗读文件: {file_path}")
        self.engine.say(content)
        self.engine.runAndWait()
    
    def save_audio_file(self, text, output_path):
        """将文本保存为音频文件"""
        self.engine.save_to_file(text, output_path)
        self.engine.runAndWait()
        print(f"音频文件已保存: {output_path}")

# 使用示例
reader = FileReader()
reader.read_text_file("article.txt")  # 朗读文本文件
reader.save_audio_file("这是要保存的内容", "output.mp3")  # 保存为音频

四、各方案对比

方案	优点	缺点	适用场景
pyttsx3	离线使用、免费、支持多平台	语音质量一般、中文支持有限	本地应用、基础朗读
gTTS	语音质量好、支持多语言	需要联网、有使用限制	在线应用、需要高质量语音
edge-tts	语音质量优秀、免费	需要联网、依赖异步	高质量朗读、Web应用