看到标题是不是有点惊讶，博主怎么走上了很刑的路线？看完此篇文章，教你自己做一个无限使用永久免费的文档拆分合并小工具

接下来的内容可能有点折腾，但也算是一劳永逸，不爱折腾的同学那你可能就是WPS会员的目标客户，还是老老实实交钱吧【狗头】

Python环境我就直接默认各位都有了，什么？没有？百度一个教程安装一下！

pip install -i https://mirrors.cloud.tencent.com/pypi/simple/ PyPDF2 pandas openpyxl python-docx

from PyPDF2 import PdfMerger


def merge_pdfs(pdf_list, output_pdf):
    merger = PdfMerger()
    for pdf in pdf_list:
        merger.append(pdf)
    merger.write(output_pdf)
    merger.close()
    print(f"合并后的PDF保存为 {output_pdf}")


# 示例用法
pdf_list = ['file1.pdf', 'file2.pdf']
merge_pdfs(pdf_list, 'merged.pdf')


import os

def merge_text_files(file_list, output_file):
    with open(output_file, 'w') as outfile:
        for file_name in file_list:
            with open(file_name, 'r') as infile:
                outfile.write(infile.read())
                outfile.write("\n")  # 可选：在文件之间添加换行符
    print(f"合并后的文件保存为 {output_file}")

# 示例用法
file_list = ['file1.txt', 'file2.txt', 'file3.txt']
merge_text_files(file_list, 'merged.txt')


from docx import Document

def merge_word_documents(doc_list, output_doc):
    merged_doc = Document()
    for doc in doc_list:
        sub_doc = Document(doc)
        for element in sub_doc.element.body:
            merged_doc.element.body.append(element)
    merged_doc.save(output_doc)
    print(f"合并后的Word文件保存为 {output_doc}")

# 示例用法
doc_list = ['file1.docx', 'file2.docx', 'file3.docx']
merge_word_documents(doc_list, 'merged.docx')


import pandas as pd

# 多个工作簿多个工作表合并为一个工作簿一个工作表
def merge_excel_files(file_list, output_file):
    combined_df = pd.DataFrame()
    for file_name in file_list:
        xl = pd.ExcelFile(file_name)
        for sheet_name in xl.sheet_names:
            df = xl.parse(sheet_name)  # 读取每个工作表的数据
            combined_df = pd.concat([combined_df, df], ignore_index=True)
    print(combined_df)
    
    combined_df.to_excel(output_file, index=False, na_rep="缺失数据")# na_rep 为缺失数据的填充，若不需要填充可去掉/为空
    print(f"合并后的Excel文件保存为 {output_file}")

# 多个工作簿多个工作表合并为一个工作簿多个工作表
def merge_excel_workbooks(file_list, output_file):
    # 创建一个空的Excel写入器
    with pd.ExcelWriter(output_file, engine='openpyxl') as writer:
        for file_name in file_list:
            # 读取每个工作簿的所有工作表
            xl = pd.ExcelFile(file_name)
            for sheet_name in xl.sheet_names:
                # 读取当前工作表
                df = xl.parse(sheet_name)
                # 将工作表写入新的工作簿
                df.to_excel(writer, sheet_name=f"{sheet_name}_{file_name}", index=False)
    print(f"合并后的工作簿保存为 {output_file}")


# 示例用法
file_list = ['test1.xlsx', 'test2.xlsx']
merge_excel_files(file_list, 'merged.xlsx')
merge_excel_workbooks(file_list, 'merged_workbook.xlsx')


import os
from PyPDF2 import PdfReader, PdfWriter


def split_pdf(input_pdf, method='fixed', pages_per_file=5, page_ranges=None, output_folder='output', recursive=False):
    """
    批量拆分PDF文件，支持递归遍历文件夹中的PDF
    :param input_pdf: 输入的PDF文件路径或文件夹路径
    :param method: 拆分方法 ('fixed' 为每x页拆分，'ranges' 为指定页面范围拆分)
    :param pages_per_file: 每个拆分文件包含的页数（仅在 method='fixed' 时使用）
    :param page_ranges: 页面范围的列表，例如 [(1, 10), (11, 25)]（仅在 method='ranges' 时使用）若end为None，则拆分到最后一页
    :param output_folder: 输出文件夹，拆分后的PDF文件将保存在此文件夹中
    :param recursive: 是否递归遍历子文件夹中的PDF文件
    """
    # 确保输出文件夹存在
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)

    # 如果输入的是文件夹路径，则获取其中的所有PDF文件
    if os.path.isdir(input_pdf):
        # 获取目录中的所有PDF文件
        pdf_files = [os.path.join(input_pdf, f) for f in os.listdir(input_pdf) if f.endswith('.pdf')]
        if recursive:
            # 如果递归选项开启，则遍历子文件夹
            for root, _, files in os.walk(input_pdf):
                pdf_files.extend([os.path.join(root, f) for f in files if f.endswith('.pdf')])
        # 对每个PDF文件进行拆分
        for pdf_file in pdf_files:
            split_pdf(pdf_file, method, pages_per_file, page_ranges, output_folder, recursive)
    else:
        # 单个PDF文件拆分
        reader = PdfReader(input_pdf)
        total_pages = len(reader.pages)

        # 获取原文件名（不带路径和扩展名）
        base_filename = os.path.splitext(os.path.basename(input_pdf))[0]

        # 按固定页数拆分
        if method == 'fixed':
            for i in range(0, total_pages, pages_per_file):
                writer = PdfWriter()
                for j in range(i, min(i + pages_per_file, total_pages)):
                    writer.add_page(reader.pages[j])
                output_pdf = os.path.join(output_folder, f"{base_filename}_{i // pages_per_file + 1}.pdf")
                with open(output_pdf, 'wb') as out_file:
                    writer.write(out_file)
                print(f"已拆分：{output_pdf}")

        # 按指定页面范围拆分
        elif method == 'ranges':
            if not page_ranges:
                raise ValueError("请提供有效的页面范围列表，例如 [(1, 10), (11, 25)]")
            for index, (start, end) in enumerate(page_ranges):
                writer = PdfWriter()
                # 如果没有提供结束页，表示拆分到最后一页
                if end is None:
                    end = total_pages
                for i in range(start - 1, end):
                    writer.add_page(reader.pages[i])
                output_pdf = os.path.join(output_folder, f"{base_filename}_{index + 1}.pdf")
                with open(output_pdf, 'wb') as out_file:
                    writer.write(out_file)
                print(f"已拆分：{output_pdf}")
        else:
            raise ValueError("拆分方法不正确。请选择 'fixed' 或 'ranges'.")


# 示例用法：
input_pdf = r'input.pdf'  # 或者文件夹路径
output_folder = 'output'
# 按固定页数拆分，每25页拆分一次
split_pdf(input_pdf, method='fixed', pages_per_file=25, output_folder=output_folder, recursive=False)

# 按指定页面范围拆分，例如 [(1, 10), (11, 25), (26, 40)]
page_ranges = [(1, 10), (11, 25), (26, 40), (41, None)]
split_pdf(input_pdf, method='ranges', page_ranges=page_ranges, output_folder=output_folder, recursive=False)


import os
import re


def split_text(input_file, method='fixed', pattern=None, lines_per_file=100, line_ranges=None, output_folder='output', recursive=False):
    """
    批量拆分文本文件，支持递归遍历文件夹中的文本文件
    :param input_file: 输入的文本文件路径或文件夹路径
    :param method: 拆分方法 ('fixed' 为每x行拆分，'ranges' 为指定行范围拆分, 'regex' 为正则表达式拆分)
    :param lines_per_file: 每个拆分文件包含的行数（仅在 method='fixed' 时使用）
    :param line_ranges: 行范围的列表，例如 [(1, 100), (101, 200)]（仅在 method='ranges' 时使用）若end为None，则拆分到最后一行
    :param output_folder: 输出文件夹，拆分后的文本文件将保存在此文件夹中
    :param recursive: 是否递归遍历子文件夹中的文本文件
    """
    # 确保输出文件夹存在
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)

    # 如果输入的是文件夹路径，则获取其中的所有文本文件
    if os.path.isdir(input_file):
        # 获取目录中的所有文本文件
        text_files = [os.path.join(input_file, f) for f in os.listdir(input_file) if f.endswith('.txt')]
        if recursive:
            # 如果递归选项开启，则遍历子文件夹
            for root, _, files in os.walk(input_file):
                text_files.extend([os.path.join(root, f) for f in files if f.endswith('.txt')])
        # 对每个文本文件进行拆分
        for text_file in text_files:
            split_text(text_file, method, pattern, lines_per_file, line_ranges, output_folder, recursive)
    else:
        # 单个文本文件拆分
        with open(input_file, 'r', encoding='utf-8') as file:

            lines = file.readlines()
            file.seek(0)  # 将文件指针移到文件开头
            content = file.read()  # 读取整个文件内容
        total_lines = len(lines)

        # 获取原文件名（不带路径和扩展名）
        base_filename = os.path.splitext(os.path.basename(input_file))[0]

        # 按固定行数拆分
        if method == 'fixed':
            for i in range(0, total_lines, lines_per_file):
                output_file = os.path.join(output_folder, f"{base_filename}_{i // lines_per_file + 1}.txt")
                with open(output_file, 'w', encoding='utf-8') as out_file:
                    out_file.writelines(lines[i:i + lines_per_file])
                print(f"已拆分：{output_file}")

        # 按指定行范围拆分
        elif method == 'ranges':
            if not line_ranges:
                raise ValueError("请提供有效的行范围列表，例如 [(1, 100), (101, 200)]")
            for index, (start, end) in enumerate(line_ranges):
                output_file = os.path.join(output_folder, f"{base_filename}_{index + 1}.txt")
                with open(output_file, 'w', encoding='utf-8') as out_file:
                    # 如果没有提供结束行，表示拆分到最后一行
                    if end is None:
                        end = total_lines
                    out_file.writelines(lines[start - 1:end])
                print(f"已拆分：{output_file}")
        elif method == 'regex':
            if not pattern:
                raise ValueError("请提供有效的正则表达式")
            matches = re.split(pattern, content)  # 根据正则匹配拆分内容

            for idx, match in enumerate(matches):
                if match.strip():
                    print(f'保存到: {os.path.join(output_folder, f"{base_filename}part_{idx + 1}.txt")}')
                    with open(os.path.join(output_folder, f'{base_filename}_part_{idx + 1}.txt'), 'w', encoding='utf-8') as f:
                        f.write(match)

        else:
            raise ValueError("拆分方法不正确。请选择 'fixed'、'ranges'或 'regex'.")


# 示例用法：
input_file = r'path/to/file.txt'  # 或者文件夹路径
output_folder = 'output'

# 按固定行数拆分，每500行拆分一次
split_text(input_file, method='fixed', lines_per_file=500, output_folder=output_folder, recursive=False)

# 按指定行范围拆分，例如 [(1, 50), (51, 100), (101, 150)]
line_ranges = [(1, 50), (51, 100), (101, 150)]
split_text(input_file, method='ranges', line_ranges=line_ranges, output_folder=output_folder, recursive=False)
# 根据正则表达式拆分
pattern = r'第\d+章 [^\n]+'  # 匹配"第 xxx 章 - xxxxx"的标题结构
split_text(input_file, method='regex', pattern=pattern, output_folder=output_folder, recursive=False)


import os
from docx import Document


def split_word_by_title(input_docx, title_level=1, output_folder='output', recursive=False, separate_subfolder=False):
    """
    按标题拆分Word文档，支持按标题级别拆分并选择是否按原文件名创建子文件夹
    :param input_docx: 输入的Word文件路径或文件夹路径
    :param title_level: 拆分时按标题的级别（只拆分到此级别的标题）
    :param output_folder: 输出文件夹，拆分后的文件将保存在此文件夹中
    :param recursive: 是否递归遍历子文件夹中的Word文件
    :param separate_subfolder: 是否为每个文件创建一个子文件夹来存放拆分后的文件
    """
    # 确保输出文件夹存在
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)

    # 如果输入的是文件夹路径，则获取其中的所有Word文件
    if os.path.isdir(input_docx):
        # 获取目录中的所有Word文件
        word_files = [os.path.join(input_docx, f) for f in os.listdir(input_docx) if f.endswith('.docx')]
        if recursive:
            # 如果递归选项开启，则遍历子文件夹
            for root, _, files in os.walk(input_docx):
                word_files.extend([os.path.join(root, f) for f in files if f.endswith('.docx')])
        # 对每个Word文件进行拆分
        for word_file in word_files:
            try:
                split_word_by_title(word_file, title_level, output_folder, recursive, separate_subfolder)
            except Exception as e:
                print(f"处理文件 {word_file} 时出错: {e}")
    else:
        # 单个Word文件拆分
        doc = Document(input_docx)
        base_filename = os.path.splitext(os.path.basename(input_docx))[0]
        output_dir = os.path.join(output_folder, base_filename) if separate_subfolder else output_folder

        # 如果选择了为每个文件创建子文件夹
        if separate_subfolder and not os.path.exists(output_dir):
            os.makedirs(output_dir)

        # 按标题拆分
        current_doc = None
        for p in doc.paragraphs:
            try:
                heading_level = int(p.style.name.split(' ')[-1])  # 获取标题级别
                if p.style.name.startswith('Heading') and heading_level <= title_level:
                    # 保存当前文档
                    if current_doc:
                        output_docx = os.path.join(output_dir, f"{base_filename}_title_split_{p.text}.docx")
                        current_doc.save(output_docx)
                        print(f"已拆分：{output_docx}")
                    # 新建文档并添加标题
                    current_doc = Document()
                    current_doc.add_paragraph(p.text)
                elif current_doc:
                    current_doc.add_paragraph(p.text)
            except ValueError:
                # 不是标题，直接添加到当前文档
                if current_doc:
                    current_doc.add_paragraph(p.text)

        # 保存最后一个文档
        if current_doc:
            output_docx = os.path.join(output_dir, f"{base_filename}_title_split_end.docx")
            current_doc.save(output_docx)
            print(f"已拆分：{output_docx}")


# 示例用法：
input_docx = r'input.docx'  # 或者是单个Word文件路径
output_folder = r'output'

# 按标题拆分，按h1级标题拆分
split_word_by_title(input_docx, title_level=1, output_folder=output_folder, separate_subfolder=True)


import os
import pandas as pd

# 用于将多个工作簿中的多个工作表拆分为单个工作表并保存为单独的文件
def split_excel(input_path, output_folder, recursive=False):
    # 判断输入是文件还是文件夹
    if os.path.isfile(input_path):
        # 处理单个文件
        process_excel_file(input_path, output_folder)
    elif os.path.isdir(input_path):
        # 处理文件夹，递归或不递归
        for root, dirs, files in os.walk(input_path):
            for filename in files:
                if filename.endswith('.xlsx') or filename.endswith('.xls'):
                    file_path = os.path.join(root, filename)
                    process_excel_file(file_path, output_folder)
            # 如果不需要递归，结束遍历
            if not recursive:
                break


def process_excel_file(file_path, output_folder):
    # 读取 Excel 文件中的所有工作表
    xls = pd.ExcelFile(file_path)
    for sheet_name in xls.sheet_names:
        # 读取工作表数据
        df = pd.read_excel(xls, sheet_name=sheet_name)
        # 创建输出文件夹路径
        output_file_path = os.path.join(output_folder, f"{os.path.splitext(os.path.basename(file_path))[0]}_{sheet_name}.xlsx")
        # 保存每个工作表为单独的 Excel 文件
        df.to_excel(output_file_path, index=False)
        print(f"Saved: {output_file_path}")


# 输入路径，可以是单个文件或文件夹
input_path = 'merged_workbook.xlsx'  # 输入路径（单个文件或文件夹）
output_folder = 'output'  # 输出文件夹路径
recursive = True  # 是否递归处理子文件夹中的文件

# 调用函数进行拆分
split_excel(input_path, output_folder, recursive)


Python办公自动化："破解WPS会员"之文档拆分合并

Python 是一种高效且易于学习的编程语言，广泛应用于办公自动化中。利用 Python，用户可以通过编写脚本和程序自动化处理各种办公任务，节省时间，提高工作效率。

腾云先锋（TDP）成员

编程语言

Python

4位行业大咖将分享DeepSeek × 技术创作者：10倍速构建专业影响力讲座，助你抢占AI红利窗口！点击报名到场/直播预约：<a href="https://cloud.tencent.com/developer/salon/salon-2328" target="_blank">https://cloud.tencent.com/developer/salon/salon-2328</a><br/> 
 <img src="https://qcloudimg.tencent-cloud.cn/raw/3b8f3fb01c22a358ef9f87c7ffbddb3b.jpg"/>

腾讯技术创作特训营

文章

问答

视频

学习中心

腾讯云实验室

Python办公自动化："破解WPS会员"之文档拆分合并

Python办公自动化："破解WPS会员"之文档拆分合并

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐