本文共计12091个字，预计阅读时长48.4分钟。

AI写作助手使用文档

概述

AI写作助手是一个基于Python的桌面应用程序，旨在帮助用户快速生成特定风格和主题的文章。该程序提供了一个图形用户界面(GUI)，使得用户可以轻松输入关键词、设置生成数量、选择文章风格和保存目录，并启动文章生成过程。

系统要求

• Python环境
• requests库：用于发送网络请求
• ttkbootstrap库：用于创建GUI
• 网络连接：用于访问外部API

安装指南

1. 确保Python已安装在您的系统上。
2. 使用pip安装所需的库：
    

   pip install requests ttkbootstrap

3. 下载AI写作助手程序代码。

使用步骤

1. 运行程序：双击程序文件或在命令行中运行python <程序文件名>.py。
2. 输入关键词：在“关键词”输入框中输入文章的关键词，多个关键词请用逗号分隔。
3. 设置生成数量：在“生成数量”输入框中输入您希望生成的文章数量。
4. 设置建议字数：在“建议字数”输入框中输入您希望每篇文章的字数。
5. 选择文章风格：在“文章风格”输入框中输入您希望的文章风格。
6. 选择保存目录：点击“选择目录”按钮，选择文章保存的目录。
7. 导入关键词：如果已有关键词列表，点击“导入关键词”按钮导入。
8. 生成文章：点击“生成文章”按钮开始生成文章。
9. 导入发布脚本：如果需要自动发布文章，点击“导入发布脚本”按钮导入发布脚本。
10. 监控进度：程序会显示进度条和生成/失败的文章数量。

注意事项

• 确保您有一个有效的API Key，并替换代码中的api_key变量值。
• 确保网络连接正常，以便程序能够访问外部API。
• 如果遇到网络问题，检查API链接的合法性，并适当重试。

故障排除

• 如果API请求失败，请检查网络连接和API Key是否正确。
• 如果文章无法生成，请检查输入的关键词和设置是否正确。
• 如果发布脚本执行失败，请检查脚本是否正确导入和配置。

联系支持

如果在使用过程中遇到任何问题，请联系我们的技术支持团队。

import tkinter as tk
from tkinter import filedialog, messagebox
import ttkbootstrap as ttk
from ttkbootstrap.constants import *
import requests
import os
import threading
import re
import subprocess

class AIWriterApp:
    def __init__(self, root):
        self.root = root
        self.root.title("AI写作助手")
        self.root.geometry("600x500")
        self.root.configure(bg="#f0f0f0")

        # 初始化计数器
        self.generated_count = 0
        self.failed_count = 0

        # 初始化发布脚本路径
        self.publish_script_path = None

        # 初始化文章保存目录
        self.save_directory = None

        # 创建界面元素
        self.create_widgets()

    def create_widgets(self):
        # 标题
        title_label = ttk.Label(self.root, text="AI写作助手", font=("Helvetica", 24, "bold"), bootstyle="inverse-primary")
        title_label.pack(pady=(20, 10))

        # 关键词输入框
        keyword_frame = ttk.Frame(self.root, bootstyle="light")
        keyword_frame.pack(pady=5, fill=X, padx=20)
        ttk.Label(keyword_frame, text="关键词:", font=("Helvetica", 12), bootstyle="inverse-light").pack(side=LEFT, padx=(0, 10))
        self.keyword_entry = ttk.Entry(keyword_frame, width=50, font=("Helvetica", 12))
        self.keyword_entry.pack(side=LEFT, fill=X, expand=True)

        # 生成数量输入框
        count_frame = ttk.Frame(self.root, bootstyle="light")
        count_frame.pack(pady=5, fill=X, padx=20)
        ttk.Label(count_frame, text="生成数量:", font=("Helvetica", 12), bootstyle="inverse-light").pack(side=LEFT, padx=(0, 10))
        self.count_entry = ttk.Entry(count_frame, width=10, font=("Helvetica", 12))
        self.count_entry.pack(side=LEFT)

        # 文章字数输入框
        word_count_frame = ttk.Frame(self.root, bootstyle="light")
        word_count_frame.pack(pady=5, fill=X, padx=20)
        ttk.Label(word_count_frame, text="建议字数:", font=("Helvetica", 12), bootstyle="inverse-light").pack(side=LEFT, padx=(0, 10))
        self.word_count_entry = ttk.Entry(word_count_frame, width=10, font=("Helvetica", 12))
        self.word_count_entry.pack(side=LEFT)

        # 文章风格输入框
        style_frame = ttk.Frame(self.root, bootstyle="light")
        style_frame.pack(pady=5, fill=X, padx=20)
        ttk.Label(style_frame, text="文章风格:", font=("Helvetica", 12), bootstyle="inverse-light").pack(side=LEFT, padx=(0, 10))
        self.style_entry = ttk.Entry(style_frame, width=50, font=("Helvetica", 12))
        self.style_entry.pack(side=LEFT, fill=X, expand=True)

        # 文章保存目录输入框
        save_dir_frame = ttk.Frame(self.root, bootstyle="light")
        save_dir_frame.pack(pady=5, fill=X, padx=20)
        ttk.Label(save_dir_frame, text="保存目录:", font=("Helvetica", 12), bootstyle="inverse-light").pack(side=LEFT, padx=(0, 10))
        self.save_dir_entry = ttk.Entry(save_dir_frame, width=50, font=("Helvetica", 12))
        self.save_dir_entry.pack(side=LEFT, fill=X, expand=True)
        self.select_dir_button = ttk.Button(save_dir_frame, text="选择目录", bootstyle="outline-primary", command=self.select_save_directory)
        self.select_dir_button.pack(side=LEFT, padx=(10, 0))

        # 导入关键词按钮
        self.import_button = ttk.Button(self.root, text="导入关键词", bootstyle="outline-primary", command=self.import_keywords)
        self.import_button.pack(pady=10, padx=20, side=LEFT, fill=X, expand=True)

        # 生成文章按钮
        self.generate_button = ttk.Button(self.root, text="生成文章", bootstyle="outline-primary", command=self.start_generate_articles)
        self.generate_button.pack(pady=10, padx=20, side=LEFT, fill=X, expand=True)

        # 导入发布脚本按钮
        self.import_publish_script_button = ttk.Button(self.root, text="导入发布脚本", bootstyle="outline-primary", command=self.import_publish_script)
        self.import_publish_script_button.pack(pady=10, padx=20, side=LEFT, fill=X, expand=True)

        # 进度条
        self.progress = ttk.Progressbar(self.root, bootstyle="success", length=400, mode="determinate")
        self.progress.pack(pady=10, padx=20, fill=X)

        # 生成和失败计数器
        counter_frame = ttk.Frame(self.root, bootstyle="light")
        counter_frame.pack(pady=5, fill=X, padx=20)
        self.generated_label = ttk.Label(counter_frame, text="生成文章数量: 0", font=("Helvetica", 12), bootstyle="inverse-light")
        self.generated_label.pack(side=LEFT, padx=(0, 10))
        self.failed_label = ttk.Label(counter_frame, text="失败数量: 0", font=("Helvetica", 12), bootstyle="inverse-light")
        self.failed_label.pack(side=RIGHT)

        # 状态标签
        self.status_label = ttk.Label(self.root, text="", font=("Helvetica", 12), bootstyle="inverse-light")
        self.status_label.pack(pady=10, padx=20, fill=X)

    def import_keywords(self):
        file_path = filedialog.askopenfilename(filetypes=[("Text files", "*.txt")])
        if file_path:
            with open(file_path, 'r', encoding='utf-8') as file:
                keywords = file.read().splitlines()
            self.keyword_entry.delete(0, tk.END)
            self.keyword_entry.insert(0, ', '.join(keywords))

    def import_publish_script(self):
        script_path = filedialog.askopenfilename(filetypes=[("Python files", "*.py")])
        if script_path:
            self.publish_script_path = script_path
            messagebox.showinfo("成功", f"发布脚本已导入: {script_path}")

    def select_save_directory(self):
        directory = filedialog.askdirectory()
        if directory:
            self.save_directory = directory
            self.save_dir_entry.delete(0, tk.END)
            self.save_dir_entry.insert(0, directory)

    def start_generate_articles(self):
        # 显示正在生成中的状态
        self.status_label.config(text="正在生成中，请稍等...")
        self.root.update_idletasks()

        # 启动生成文章的线程
        threading.Thread(target=self.generate_articles).start()

    def generate_articles(self):
        keywords = self.keyword_entry.get().split(',')
        count = int(self.count_entry.get())
        word_count = int(self.word_count_entry.get())
        style = self.style_entry.get()
        save_directory = self.save_directory

        if not save_directory:
            messagebox.showerror("错误", "请选择保存目录")
            return

        if not os.path.exists(save_directory):
            os.makedirs(save_directory)

        total_articles = len(keywords) * count
        self.progress["maximum"] = total_articles
        self.progress["value"] = 0
        self.generated_count = 0
        self.failed_count = 0

        # 使用线程池来生成文章
        threads = []
        for keyword in keywords:
            for _ in range(count):
                thread = threading.Thread(target=self.generate_and_save_article, args=(keyword.strip(), word_count, style, save_directory))
                threads.append(thread)
                thread.start()

        # 等待所有线程完成
        for thread in threads:
            thread.join()

        # 显示生成完成的状态
        self.status_label.config(text="已完成，请查收")

        # 自动执行发布脚本
        if self.publish_script_path:
            self.execute_publish_script()

    def generate_and_save_article(self, keyword, word_count, style, save_directory):
        article = self.generate_article(keyword, word_count, style)
        if article:
            self.save_article(article, save_directory)
            self.generated_count += 1
        else:
            self.failed_count += 1
        self.progress["value"] += 1
        self.update_counters()
        self.root.update_idletasks()

    def generate_article(self, keyword, word_count, style):
        api_key = "此处替换为你的deepSeek API Key"  # 替换为你的deepSeek API Key
        base_url = "https://api.deepseek.com"

        headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

        data = {
            "model": "deepseek-chat",
            "messages": [
                {"role": "system", "content": "你是文章创作大师，你擅长创作任何已知风格的文章，并且根据用户的要求，你会尝试不同风格，创作出有吸引力的文章。注意,正文第一行必须是标题，标题需要符合文章主题，标题下是正文。"},
                {"role": "user", "content": f"请根据关键词'{keyword}'生成一篇{word_count}字左右的{style}风格的文章，关键词可根据你自己的理解扩充，文章的标题需要保持创新性，不要重复使用相同标题。"}
            ],
            "temperature": 0.3
        }

        response = requests.post(f"{base_url}/chat/completions", headers=headers, json=data)
        if response.status_code == 200:
            return response.json()["choices"][0]["message"]["content"]
        else:
            messagebox.showerror("错误", f"API请求失败: {response.status_code}")
            return None

    def save_article(self, article, save_directory):
        # 过滤黑名单词汇
        filtered_article = self.filter_blacklisted_words(article)

        # 将文本转换为HTML格式
        html_content = self.convert_to_html(filtered_article)

        # 提取标题并去除“标题：”字样
        title = article.split('\n')[0].strip()
        if title.startswith("标题："):
            title = title[4:].strip()

        # 去除标题中的非法字符
        title = self.clean_filename(title)

        # 保存为HTML文件
        with open(os.path.join(save_directory, f"{title}.html"), 'w', encoding='utf-8') as file:
            file.write(html_content)

    def convert_to_html(self, text):
        # 将加粗、换行和分段格式转换为HTML
        html_content = text.replace('**', '<strong>').replace('**', '</strong>')
        html_content = html_content.replace('\n', '<br>')
        html_content = html_content.replace('\n\n', '</p><p>')

        # 去除内容中的 # 以及类似符号
        html_content = re.sub(r'[#*]', '', html_content)

        return f"<p>{html_content}</p>"

    def filter_blacklisted_words(self, text):
        # 黑名单词汇列表
        blacklist = ["标题：", "敏感词2", "敏感词3"]  # 请替换为实际的黑名单词汇

        # 过滤黑名单词汇
        for word in blacklist:
            text = text.replace(word, "")

        # 去除内容中的 # 以及类似符号
        text = re.sub(r'[#*]', '', text)

        return text

    def clean_filename(self, filename):
        # 去除文件名中的非法字符
        illegal_chars = r'[<>:"/\\|?*#]'
        cleaned_filename = re.sub(illegal_chars, '', filename)
        return cleaned_filename

    def update_counters(self):
        self.generated_label.config(text=f"生成文章数量: {self.generated_count}")
        self.failed_label.config(text=f"失败数量: {self.failed_count}")

    def execute_publish_script(self):
        try:
            # 在 Windows 系统中，使用 subprocess.CREATE_NO_WINDOW 避免弹出命令行窗口
            if os.name == 'nt':  # 'nt' 是 Windows 的标识符
                subprocess.run(["python", self.publish_script_path], creationflags=subprocess.CREATE_NO_WINDOW, check=True)
            else:
                subprocess.run(["python", self.publish_script_path], check=True)
            messagebox.showinfo("成功", "发布脚本已成功执行")
        except subprocess.CalledProcessError as e:
            messagebox.showerror("错误", f"发布脚本执行失败: {e}")

if __name__ == "__main__":
    root = ttk.Window(themename="cosmo")
    app = AIWriterApp(root)
    root.mainloop()