Python itertools 进阶：高效生成包含额外数字的指定长度排列组合

from itertools import product, permutations
from typing import Iterable

def get_expanded_permutations(entry: str) -> Iterable[str]:
    """
    生成一个四位字符串与两位额外数字组合后的所有六位排列。

    Args:
        entry (str): 原始的四位数字字符串。

    Yields:
        str: 一个六位数字的排列字符串。
    """
    # 遍历所有两位额外数字的组合 (00, 01, ..., 99)
    for x, y in product(range(10), repeat=2):
        # 将原始四位字符串与两位额外数字拼接成一个六位字符串
        # 例如，如果 entry="1234", x=0, y=0，则 new_entry="123400"
        new_entry = f"{entry}{x}{y}"

        # 对这个六位字符串生成所有可能的排列
        for perm_tuple in permutations(new_entry):
            # 将排列元组转换为字符串并返回
            yield "".join(perm_tuple)

# 示例用法：
# 获取 "1234" 扩展后的前10个排列
# expanded_perms_sample = list(get_expanded_permutations("1234"))[:10]
# print(expanded_perms_sample)

# 获取 "1234" 扩展后的所有唯一排列
unique_expanded_perms = list(set(get_expanded_permutations("1234")))
# print(f"Unique permutations for '1234': {len(unique_expanded_perms)}")
# print(unique_expanded_perms[:10]) # 打印前10个唯一排列

import os
import datetime
from itertools import product, permutations
import tkinter as tk
from tkinter import filedialog, ttk, messagebox

# 定义核心逻辑函数
def get_expanded_permutations(entry: str) -> Iterable[str]:
    """
    生成一个四位字符串与两位额外数字组合后的所有六位排列。
    Args:
        entry (str): 原始的四位数字字符串。
    Yields:
        str: 一个六位数字的排列字符串。
    """
    for x, y in product(range(10), repeat=2):
        new_entry = f"{entry}{x}{y}"
        for perm_tuple in permutations(new_entry):
            yield "".join(perm_tuple)

class PermutationGenerator:
    def __init__(self, master):
        self.master = master
        self.master.title("Permutation Generator")
        self.input_file = ""
        self.output_file = ""
        self.create_widgets()

    def create_widgets(self):
        tk.Label(self.master, text="Input File:").grid(row=0, column=0, sticky="e")
        tk.Label(self.master, text="Output File:").grid(row=1, column=0, sticky="e")

        self.input_entry = tk.Entry(self.master, width=50, state="readonly")
        self.output_entry = tk.Entry(self.master, width=50, state="readonly")

        self.input_entry.grid(row=0, column=1, padx=5, pady=5)
        self.output_entry.grid(row=1, column=1, padx=5, pady=5)

        tk.Button(self.master, text="Browse", command=self.browse_input).grid(row=0, column=2, padx=5, pady=5)
        tk.Button(self.master, text="Browse", command=self.browse_output).grid(row=1, column=2, padx=5, pady=5)

        tk.Button(self.master, text="Generate Permutations", command=self.generate_permutations).grid(row=2, column=1, pady=10)

        self.progress_bar = ttk.Progressbar(self.master, orient="horizontal", length=300, mode="determinate")
        self.progress_bar.grid(row=3, column=1, pady=10)

    def browse_input(self):
        file_path = filedialog.askopenfilename(filetypes=[("Text files", "*.txt")])
        if file_path:
            self.input_entry.config(state="normal")
            self.input_entry.delete(0, tk.END)
            self.input_entry.insert(0, file_path)
            self.input_entry.config(state="readonly")
            self.input_file = file_path

    def browse_output(self):
        file_path = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files", "*.txt")])
        if file_path:
            self.output_entry.config(state="normal")
            self.output_entry.delete(0, tk.END)
            self.output_entry.insert(0, file_path)
            self.output_entry.config(state="readonly")
            self.output_file = file_path

    def generate_permutations(self):
        if not self.input_file or not self.output_file:
            messagebox.showwarning("Error", "Please select input and output files.")
            return

        try:
            with open(self.input_file, 'r') as infile:
                input_data = infile.read().splitlines()

            # 估算总进度条最大值：每个输入条目有 100 种扩展方式 (00-99)，每种扩展方式有 6! = 720 种排列
            # 假设我们只计算唯一的排列，那么实际数量会少于 100 * 720
            # 这里简化为每个输入条目对应一次进度条更新，或者更精确地估算所有唯一排列的总数
            # 由于去重操作，精确估算总数比较复杂，这里使用输入条目数作为基础进度
            self.progress_bar["maximum"] = len(input_data)
            self.progress_bar["value"] = 0 # 重置进度条

            log_filename = f"permutation_log_{datetime.datetime.now().strftime('%y%m%d%H%M')}.log"
            log_filepath = os.path.join(os.path.dirname(self.output_file), log_filename) # 将日志文件放在输出文件同目录

            # 确保输出文件是空的，避免追加旧数据
            with open(self.output_file, 'w') as outfile:
                outfile.write("")

            with open(log_filepath, 'w') as logfile:
                logfile.write(f"Permutation generation log - {datetime.datetime.now()}\n\n")

                for i, entry in enumerate(input_data):
                    if not entry.strip(): # 跳过空行
                        continue

                    # 为每个输入条目生成所有唯一的扩展排列
                    perms = set(get_expanded_permutations(entry))

                    # 批量写入当前输入条目的所有排列
                    with open(self.output_file, 'a') as outfile:
                        # 使用换行符连接所有排列，并一次性写入
                        outfile.write("\n".join(perms))
                        # 在每个批次后添加一个额外的换行，确保下一个批次从新行开始
                        outfile.write("\n") 

                    logfile.write(f"Generated {len(perms)} unique permutations for entry: '{entry}'\n")

                    self.progress_bar.step(1)
                    self.master.update_idletasks() # 更新 GUI

            messagebox.showinfo("Success", "Permutations generated successfully.")
            self.progress_bar["value"] = 0

        except Exception as e:
            messagebox.showerror("Error", f"An error occurred: {e}")
            self.progress_bar["value"] = 0

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