利用 Python itertools 库高效生成带填充位的字符串排列组合

from itertools import permutations

four_digit_code = "1234"

# 尝试从4位字符串生成6位排列，结果将是空的
six_digit_perms = list(permutations(four_digit_code, 6))
print(f"从 '{four_digit_code}' 生成的6位排列 (错误示例): {six_digit_perms}")
# 输出: 从 '1234' 生成的6位排列 (错误示例): []

# 从4位字符串生成4位排列，这是正确的用法
four_digit_perms = list(permutations(four_digit_code, 4))
print(f"从 '{four_digit_code}' 生成的4位排列 (正确示例): {four_digit_perms[:5]}...")
# 输出: 从 '1234' 生成的4位排列 (正确示例): [('1', '2', '3', '4'), ('1', '2', '4', '3'), ('1', '3', '2', '4'), ('1', '3', '4', '2'), ('1', '4', '2', '3')]...

from itertools import product

# 生成所有两位数字组合
two_digit_fillers = list(product(range(10), repeat=2))
print(f"前10组两位填充数字: {two_digit_fillers[:10]}")
# 输出: 前10组两位填充数字: [(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9)]

from itertools import product, permutations
from typing import Iterable, Set

def get_expanded_permutations(entry: str) -> Set[str]:
    """
    为给定的4位字符串生成所有包含两位0-9填充位的6位排列组合。

    Args:
        entry: 原始的4位数字字符串。

    Returns:
        一个包含所有唯一6位排列字符串的集合。
    """
    all_permutations = set()
    for x, y in product(range(10), repeat=2):
        # 将填充数字转换为字符串并与原始entry组合
        new_entry_str = f"{entry}{x}{y}"

        # 对新的6位字符串进行全长排列
        for perm_tuple in permutations(new_entry_str):
            all_permutations.add("".join(perm_tuple))

    return all_permutations

# 示例使用
input_code = "1234"
results = get_expanded_permutations(input_code)
print(f"为 '{input_code}' 生成的前10个唯一6位排列组合: {list(results)[:10]}")
print(f"总共生成了 {len(results)} 个唯一排列组合。")
# 示例输出 (顺序可能不同):
# 为 '1234' 生成的前10个唯一6位排列组合: ['001234', '001243', '001324', '001342', '001423', '001432', '002134', '002143', '002314', '002341']
# 总共生成了 72000 个唯一排列组合。

import os
import datetime

# 假设 input_data 是从输入文件读取的4位码列表
# input_data = ["1234", "5678", ...] 
# output_file_path = "output.txt"
# log_file_path = "log.txt"

def process_and_write_permutations(input_data: list, output_file_path: str, log_file_path: str):
    """
    处理输入数据，生成排列组合并写入输出文件，同时记录日志。
    """
    with open(output_file_path, 'w') as outfile: # 使用 'w' 模式清空文件或创建新文件
        outfile.write("") # 确保文件是空的，或者在每次运行时都从头开始

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

        for entry in input_data:
            perms = get_expanded_permutations(entry) # 获取当前entry的所有唯一排列

            # 将所有排列一次性写入输出文件
            with open(output_file_path, 'a') as outfile:
                outfile.write("\n".join(perms))
                outfile.write("\n") # 在每个entry的排列结束后添加一个换行，确保下一个entry的排列从新行开始

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

# 模拟输入数据
sample_input_data = ["1234", "5678"] 
output_path = "output_permutations.txt"
log_path = "generation_log.txt"

# 运行处理函数
process_and_write_permutations(sample_input_data, output_path, log_path)
print(f"所有排列已写入到 '{output_path}'。")
print(f"日志已写入到 '{log_path}'。")

import os
import datetime
from itertools import product, permutations
from typing import Set

def get_expanded_permutations(entry: str) -> Set[str]:
    """
    为给定的4位字符串生成所有包含两位0-9填充位的6位排列组合。
    """
    all_permutations = set()
    for x, y in product(range(10), repeat=2):
        new_entry_str = f"{entry}{x}{y}"
        for perm_tuple in permutations(new_entry_str):
            all_permutations.add("".join(perm_tuple))
    return all_permutations

def generate_and_save_permutations(input_file_path: str, output_file_path: str, log_file_path: str):
    """
    从输入文件读取4位码，生成其所有6位排列组合，并写入输出文件。
    同时记录处理过程到日志文件。
    """
    if not os.path.exists(input_file_path):
        print(f"错误: 输入文件 '{input_file_path}' 不存在。")
        return

    input_data = []
    with open(input_file_path, 'r') as infile:
        input_data = [line.strip() for line in infile if line.strip()]

    if not input_data:
        print("警告: 输入文件中没有有效数据。")
        return

    # 确保输出文件是空的，或者在每次运行时都从头开始
    with open(output_file_path, 'w') as outfile:
        outfile.write("")

    # 初始化日志文件
    with open(log_file_path, 'w') as logfile:
        logfile.write(f"Permutation generation log - {datetime.datetime.now()}\n\n")

        total_entries = len(input_data)
        processed_count = 0
        print(f"开始处理 {total_entries} 个输入码...")

        for entry in input_data:
            if len(entry) != 4 or not entry.isdigit():
                print(f"跳过无效输入码: '{entry}' (非4位数字)。")
                logfile.write(f"Skipped invalid entry: '{entry}' (not 4 digits or not numeric)\n")
                continue

            perms = get_expanded_permutations(entry)

            # 将当前entry的所有排列一次性写入输出文件
            with open(output_file_path, 'a') as outfile:
                outfile.write("\n".join(perms))
                outfile.write("\n") # 确保下一个entry的排列从新行开始

            processed_count += 1
            logfile.write(f"Generated {len(perms)} unique permutations for entry: '{entry}'.\n")
            print(f"已处理 {processed_count}/{total_entries} 个，为 '{entry}' 生成了 {len(perms)} 个唯一排列。")

        logfile.write(f"\nPermutation generation completed at {datetime.datetime.now()}\n")
        print("所有排列生成完毕。")

if __name__ == "__main__":
    # 创建一个示例输入文件
    with open("input.txt", "w") as f:
        f.write("1234\n")
        f.write("5678\n")
        f.write("9012\n")
        f.write("invalid\n") # 包含一个无效行

    input_file = "input.txt"
    output_file = "output_permutations.txt"
    log_file = "generation_log.txt"

    generate_and_save_permutations(input_file, output_file, log_file)
    print(f"结果已保存到 '{output_file}'。")
    print(f"日志已保存到 '{log_file}'。")