Batch Generate docx Files in Python

Automating document creation saves time and reduces errors. Python-docx makes batch processing simple. You can generate hundreds of documents from templates.

This guide covers everything from basic setup to advanced techniques. You will learn to create professional documents efficiently.

Setting Up Python-docx

First, install the python-docx library. Use pip for installation. It works with Python 3.6 and above.

pip install python-docx

Verify the installation by importing it. This confirms everything is working correctly. You are now ready to start coding.

import docx
print("python-docx installed successfully")

python-docx installed successfully

Basic Document Creation

Start with a simple document. The Document() function creates a new file. Add paragraphs using add_paragraph().

from docx import Document

# Create a new document
doc = Document()
doc.add_paragraph('Hello, this is my first automated document!')
doc.save('simple_document.docx')

This creates a basic Word file. The content appears in the document body. You can open it in Microsoft Word.

Batch Processing Fundamentals

Batch generation uses loops with data sources. Common sources include CSV files, databases, or lists. Each iteration creates a new document.

# Sample data for batch processing
employees = [
    {'name': 'John Doe', 'position': 'Developer'},
    {'name': 'Jane Smith', 'position': 'Designer'},
    {'name': 'Bob Johnson', 'position': 'Manager'}
]

for emp in employees:
    doc = Document()
    doc.add_paragraph(f"Employee: {emp['name']}")
    doc.add_paragraph(f"Position: {emp['position']}")
    doc.save(f"employee_{emp['name'].replace(' ', '_')}.docx")

This creates three separate documents. Each file contains employee-specific information. The filenames include the employee names.

Using Templates for Consistency

Templates ensure consistent formatting across documents. Create a master document with placeholders. Replace them with actual data during generation.

def create_from_template(template_path, output_path, data):
    doc = Document(template_path)
    
    for paragraph in doc.paragraphs:
        for key, value in data.items():
            if f'{{{key}}}' in paragraph.text:
                paragraph.text = paragraph.text.replace(f'{{{key}}}', value)
    
    doc.save(output_path)

# Usage example
template_data = {
    'company_name': 'Tech Solutions Inc',
    'employee_name': 'Sarah Wilson',
    'start_date': '2024-01-15'
}

create_from_template('template.docx', 'offer_letter.docx', template_data)

This approach maintains corporate branding. All documents follow the same structure. Only the dynamic content changes.

Advanced Formatting Techniques

Professional documents need proper formatting. Python-docx offers extensive styling options. You can control fonts, colors, and alignment.

For detailed text styling, see our Python-docx Text Styling Guide. It covers font properties comprehensively.

from docx.shared import Inches, Pt
from docx.enum.text import WD_ALIGN_PARAGRAPH

doc = Document()
title = doc.add_paragraph()
title.alignment = WD_ALIGN_PARAGRAPH.CENTER

title_run = title.add_run('COMPANY REPORT')
title_run.bold = True
title_run.font.size = Pt(16)

# Add regular content
content = doc.add_paragraph('This is the report body content.')
doc.save('formatted_report.docx')

This creates a professionally formatted document. The title is centered and bold. The font size is larger for emphasis.

Working with Tables

Tables organize data effectively. Python-docx provides robust table creation features. You can add and format tables programmatically.

Learn advanced table techniques in our Python-docx Table Formatting Complete Guide.

# Create a table with sample data
doc = Document()
table = doc.add_table(rows=4, cols=3)
table.style = 'Light Grid Accent 1'

# Header row
header_cells = table.rows[0].cells
header_cells[0].text = 'Product'
header_cells[1].text = 'Quantity'
header_cells[2].text = 'Price'

# Data rows
data = [
    ('Laptop', '15', '$1200'),
    ('Mouse', '45', '$25'),
    ('Keyboard', '30', '$75')
]

for i, (product, qty, price) in enumerate(data, 1):
    row_cells = table.rows[i].cells
    row_cells[0].text = product
    row_cells[1].text = qty
    row_cells[2].text = price

doc.save('product_catalog.docx')

The table presents data clearly. The style makes it visually appealing. Readers can quickly scan the information.

Adding Headers and Footers

Headers and footers provide document context. They typically contain page numbers, dates, or company information. Python-docx handles them efficiently.

Our Python-docx Headers Footers Guide covers this topic in depth.

doc = Document()
section = doc.sections[0]
header = section.header
footer = section.footer

# Add header content
header_para = header.paragraphs[0]
header_para.text = "Confidential Company Document"

# Add footer content
footer_para = footer.paragraphs[0]
footer_para.text = "Page 1"

doc.add_paragraph("Main document content goes here.")
doc.save('document_with_header_footer.docx')

Headers and footers appear on every page. They maintain professional standards. Important information stays visible.

Error Handling and Validation

Batch processing requires robust error handling. Files might be missing or data corrupted. Proper validation prevents complete failures.

import os
from docx import Document

def safe_document_creation(output_path, content):
    try:
        doc = Document()
        doc.add_paragraph(content)
        
        # Ensure output directory exists
        os.makedirs(os.path.dirname(output_path), exist_ok=True)
        
        doc.save(output_path)
        return True
    except Exception as e:
        print(f"Error creating {output_path}: {str(e)}")
        return False

# Batch processing with error handling
documents_to_create = [
    ('reports/q1_report.docx', 'Q1 Financial Report'),
    ('reports/q2_report.docx', 'Q2 Financial Report'),
    ('reports/q3_report.docx', 'Q3 Financial Report')
]

for path, content in documents_to_create:
    success = safe_document_creation(path, content)
    if success:
        print(f"Created: {path}")
    else:
        print(f"Failed: {path}")

This approach continues processing even if errors occur. Each document creation is independent. Failed creations don't stop the entire batch.

Performance Optimization

Large batches need optimization. Memory management becomes crucial. Several techniques improve performance significantly.

import gc

def optimized_batch_processing(data_list, output_dir):
    processed_count = 0
    
    for i, data_item in enumerate(data_list):
        # Create document
        doc = Document()
        doc.add_paragraph(f"Document for: {data_item}")
        
        # Save with sequential naming
        output_path = f"{output_dir}/document_{i:04d}.docx"
        doc.save(output_path)
        processed_count += 1
        
        # Clean up memory periodically
        if i % 100 == 0:
            gc.collect()
    
    return processed_count

# Example usage
sample_data = [f"Item {i}" for i in range(500)]
count = optimized_batch_processing(sample_data, 'output_documents')
print(f"Processed {count} documents")

Processed 500 documents

This handles large volumes efficiently. Memory gets cleaned regularly. The system remains responsive throughout processing.

Real-World Use Cases

Batch document generation has many applications. Businesses use it for various automated processes. Here are common scenarios.

Certificate Generation

Create certificates for event participants. Each certificate includes the participant's name. Batch processing handles large groups efficiently.

Report Distribution

Generate personalized reports for clients. Each report contains specific performance data. Automation ensures timely delivery.

Contract Creation

Produce contracts for multiple parties. Key terms change based on negotiation results. Templates maintain legal consistency.

Conclusion

Python-docx enables efficient batch document generation. It saves time and ensures consistency across multiple files.

Start with simple templates and basic replacement. Gradually incorporate advanced features like tables and headers. Always include error handling for production use.

The techniques covered here provide a solid foundation. You can adapt them to various business needs. Automation transforms document creation from chore to advantage.

For more detailed guidance, explore our comprehensive Python-docx Tutorial. It covers all aspects of Word document automation.