Great question! That page-by-page merge approach can get pretty sluggish, especially with larger PDFs. Let's break down how to speed up your current PyPDF2 workflow, plus a much more efficient alternative that avoids the merge step entirely.

First: Optimize Your PyPDF2 Code (Faster Merging) #

PyPDF2 doesn't have a "one-click" way to merge corresponding pages from two PDFs in a single operation—since we're overlaying content page-by-page, we still need to iterate through each pair. But we can make this way faster by using the latest PyPDF2 v2.x API (which has major performance improvements over the old PdfFileReader/PdfFileWriter classes) and optimizing IO handling.

Here's the revised, faster code:

from PyPDF2 import PdfReader, PdfWriter

def merge_pdf_pages_fast(first_pdf_fp, second_pdf_fp, target_fp):
    """
    Merges matching pages from two PDFs into one optimized output PDF.
    Args:
        first_pdf_fp: Path to your page number overlay PDF
        second_pdf_fp: Path to your content PDF (from ReportLab)
        target_fp: Path to save the final merged PDF
    """
    # Open both PDFs in binary read mode using context managers (cleaner, more efficient)
    with open(first_pdf_fp, "rb") as num_pdf, open(second_pdf_fp, "rb") as content_pdf:
        num_reader = PdfReader(num_pdf)
        content_reader = PdfReader(content_pdf)
        
        # Validate page count match
        assert len(num_reader.pages) == len(content_reader.pages), "PDFs must have identical page counts"
        
        writer = PdfWriter()
        
        # Iterate directly over page pairs with zip (avoids manual index lookup)
        for num_page, content_page in zip(num_reader.pages, content_reader.pages):
            # Merge the page number overlay onto the content page
            content_page.merge_page(num_page)
            writer.add_page(content_page)
        
        # Write the final PDF in one go
        with open(target_fp, "wb") as output:
            writer.write(output)

Why this is faster: #

• Uses PyPDF2's modern PdfReader/PdfWriter classes, which have optimized memory management and IO handling compared to the legacy PdfFile* classes.
• Uses zip() to iterate over page pairs directly, eliminating slow index-based page fetching (getPage(i)).
• Context managers (with statements) ensure files are opened/closed efficiently, reducing IO overhead.

Even Better: Skip the Merge Entirely #

The biggest speed win comes from not generating a separate page number PDF at all. You can add page numbers directly when creating your PDF with ReportLab, which cuts out the merge step entirely.

Here's a quick example of how to do this with ReportLab's SimpleDocTemplate and a custom footer function:

from reportlab.lib.pagesizes import letter
from reportlab.platypus import SimpleDocTemplate, Paragraph
from reportlab.lib.styles import getSampleStyleSheet

def generate_pdf_with_page_numbers(output_path, content_items):
    doc = SimpleDocTemplate(output_path, pagesize=letter)
    styles = getSampleStyleSheet()
    story = []
    
    # Add your actual content (replace with your ReportLab content generation)
    for item in content_items:
        story.append(Paragraph(item, styles["BodyText"]))
    
    # Define a footer function to draw page numbers
    def add_page_number(canvas, doc):
        canvas.saveState()
        # Draw centered page number at the bottom of the page
        page_text = f"Page {doc.page} of {doc.pages}"
        canvas.drawString(doc.pagesize[0]/2, 20, page_text)
        canvas.restoreState()
    
    # Build the PDF with the footer (applies to all pages)
    doc.build(story, onFirstPage=add_page_number, onLaterPages=add_page_number)

# Example usage
sample_content = [
    "This is the content for page 1.",
    "More content for page 2.",
    "Final content on page 3."
]
generate_pdf_with_page_numbers("content_with_pages.pdf", sample_content)

This approach is way faster because: #

• You're generating the PDF and adding pages numbers in a single pass, no extra files or merging required.
• No need to read/write two separate PDFs, which eliminates significant IO and memory overhead.
• You have full control over the page number styling (font, size, position) directly in your ReportLab code.

Final Takeaway #

If you absolutely need to merge two existing PDFs, use the optimized PyPDF2 v2.x code above. But for your use case (adding pages to a ReportLab-generated PDF), adding numbers directly during generation is the best, fastest solution.

内容的提问来源于stack exchange，提问作者SkyWalker