Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro-preview-05-06· GoogleHugging Face LMArena Human Preference 140K

using python reportlab, how do i print two columns of text?

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with DeepSeekdeepseek-r1-0528’s answer.
  1. User

    using python reportlab, how do i print two columns of text?

  2. Gemini Assistant

    You can achieve two columns of text in ReportLab primarily using its high-level Platypus framework by defining a PageTemplate with multiple Frame objects. Text will flow from one frame to the next on the same page.

    Here's how you can do it:

    Method 1: Flowing Text (Newspaper Style Columns)

    This method is for when you have a continuous block of text that you want to flow from the bottom of the first column to the top of the second column, and then to the next page if necessary.

    from reportlab.platypus import BaseDocTemplate, PageTemplate, Frame, Paragraph, Spacer, NextPageTemplate
    from reportlab.lib.styles import getSampleStyleSheet
    from reportlab.lib.units import inch, cm
    from reportlab.lib.pagesizes import letter, A4
    import lorem # For generating sample text (pip install lorem)
    
    # 1. Document Setup
    filename = "two_column_document.pdf"
    pagesize = A4 # or letter
    doc = BaseDocTemplate(filename, pagesize=pagesize)
    
    # 2. Styles
    styles = getSampleStyleSheet()
    normal_style = styles['Normal']
    heading_style = styles['h1']
    
    # 3. Define Frames for the Two Columns
    # Page dimensions (useful for calculations)
    page_width, page_height = pagesize
    
    # Margins
    left_margin = 1 * inch
    right_margin = 1 * inch
    top_margin = 1 * inch
    bottom_margin = 1 * inch
    
    # Gutter (space between columns)
    gutter_width = 0.5 * inch
    
    # Calculate usable width and height for content
    usable_width = page_width - left_margin - right_margin
    usable_height = page_height - top_margin - bottom_margin
    
    # Calculate column width
    column_width = (usable_width - gutter_width) / 2
    
    # Define the two frames
    # Frame(x1, y1, width, height, id=None, leftPadding=6, bottomPadding=6, rightPadding=6, topPadding=6, showBoundary=0)
    # (x1, y1) is the bottom-left corner of the frame
    
    frame_left = Frame(
        x1=left_margin,
        y1=bottom_margin,
        width=column_width,
        height=usable_height,
        id='col1',
        # showBoundary=1 # Uncomment to see frame borders for debugging
    )
    
    frame_right = Frame(
        x1=left_margin + column_width + gutter_width,
        y1=bottom_margin,
        width=column_width,
        height=usable_height,
        id='col2',
        # showBoundary=1 # Uncomment to see frame borders for debugging
    )
    
    # 4. Create a PageTemplate using these frames
    # The order of frames in the list determines the flow
    two_column_template = PageTemplate(
        id='TwoColumn',
        frames=[frame_left, frame_right]
        # You can add onPage functions here for headers/footers if needed
        # onPage=my_header_footer_function
    )
    
    # Add the template to the document
    doc.addPageTemplates([two_column_template])
    
    # 5. Story - The content to be flowed
    story = []
    
    # If you have other page templates (e.g., a single column title page)
    # and want to switch to the two-column layout:
    # story.append(NextPageTemplate('TwoColumn'))
    
    story.append(Paragraph("My Two-Column Document", heading_style))
    story.append(Spacer(1, 0.3 * inch))
    
    # Generate a lot of text to see the flow
    for i in range(10): # Adjust for more or less text
        story.append(Paragraph(lorem.paragraph(), normal_style))
        story.append(Spacer(1, 0.2 * inch))
        if i == 3:
            story.append(Paragraph("--- This is an intermediate paragraph ---", styles['h3']))
            story.append(Spacer(1, 0.1 * inch))
    
    story.append(Paragraph("End of the content.", normal_style))
    
    # 6. Build the PDF
    try:
        doc.build(story)
        print(f"Successfully created {filename}")
    except Exception as e:
        print(f"Error building PDF: {e}")
    
    

    Explanation:

    1. BaseDocTemplate: Used instead of SimpleDocTemplate because we need more control over page templates and frames.
    2. Frame: Defines a rectangular area on the page where flowable elements (like Paragraphs) will be placed.
      • x1, y1: Coordinates of the bottom-left corner of the frame.
      • width, height: Dimensions of the frame.
      • id: An optional identifier for the frame.
      • showBoundary=1: Very useful during development to visualize the frame areas.
    3. PageTemplate: A blueprint for a page. It holds a list of Frame objects.
      • The frames argument takes a list of Frame objects. ReportLab will attempt to fill the first frame in the list, then the second, and so on. If the content overflows all frames on the current page, a new page (using the same template by default, or as directed by NextPageTemplate) is created, and flow continues into its first frame.
    4. doc.addPageTemplates([...]): Makes the defined page template(s) available to the document.
    5. Story: A list of Flowable objects (Paragraphs, Spacers, Images, Tables, etc.) that make up the content of your document.
    6. doc.build(story): This is where ReportLab takes your story and tries to fit it into the frames defined by your PageTemplates.

    Method 2: Independent Columns (Using a Table)

    This method is suitable if your columns are not meant to flow into each other, but rather contain distinct, parallel content (e.g., a term and its definition, or two separate lists).

    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
    from reportlab.lib.styles import getSampleStyleSheet
    from reportlab.lib.units import inch, cm
    from reportlab.lib.pagesizes import letter, A4
    from reportlab.lib import colors
    import lorem
    
    # 1. Document Setup
    filename_table = "two_column_table_document.pdf"
    pagesize = A4
    doc_table = SimpleDocTemplate(filename_table, pagesize=pagesize,
                                  leftMargin=1*inch, rightMargin=1*inch,
                                  topMargin=1*inch, bottomMargin=1*inch)
    
    # 2. Styles
    styles = getSampleStyleSheet()
    normal_style = styles['Normal']
    heading_style = styles['h2']
    
    # 3. Story
    story_table = []
    
    story_table.append(Paragraph("Two Independent Columns (Table Method)", styles['h1']))
    story_table.append(Spacer(1, 0.3 * inch))
    
    # 4. Prepare data for the table
    # Each inner list is a row. Each item in the inner list is a cell in that row.
    # Cells can contain Flowables like Paragraphs.
    
    # Calculate available width for the table (page width - margins)
    table_width = pagesize[0] - doc_table.leftMargin - doc_table.rightMargin
    col_width = table_width / 2 - (0.1 * inch) # Subtract a bit for potential internal padding/spacing
    
    data = [
        [Paragraph("<b>Feature</b>", heading_style), Paragraph("<b>Description</b>", heading_style)],
        [
            Paragraph("Column A Item 1: " + lorem.sentence(), normal_style),
            Paragraph("Column B Item 1: " + lorem.sentence(), normal_style)
        ],
        [
            Paragraph("Column A Item 2 (longer): " + lorem.paragraph()[:150] + "...", normal_style),
            Paragraph("Column B Item 2: " + lorem.sentence(), normal_style)
        ],
        [
            Paragraph("Column A Item 3: " + lorem.sentence(), normal_style),
            Paragraph("Column B Item 3 (also longer): " + lorem.paragraph()[:180] + "...", normal_style)
        ],
    ]
    
    # 5. Create the Table
    # colWidths can be absolute values (e.g., [2*inch, 3*inch]) or percentages (e.g., ['50%', '50%'])
    # but percentages in Table colWidths require more complex setup (often using a wrapping Frame).
    # Explicit widths are usually easier.
    table = Table(data, colWidths=[col_width, col_width])
    
    # 6. Add Table Style (optional, for borders, alignment, etc.)
    table_style = TableStyle([
        ('BACKGROUND', (0, 0), (-1, 0), colors.grey),      # Header row background
        ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke), # Header row text color
        ('ALIGN', (0, 0), (-1, -1), 'LEFT'),             # Left align all cells
        ('VALIGN', (0, 0), (-1, -1), 'TOP'),              # Top align all cells
        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),  # Header font
        ('BOTTOMPADDING', (0, 0), (-1, 0), 12),          # Header bottom padding
        ('GRID', (0, 0), (-1, -1), 0.5, colors.black),    # Grid lines for all cells
        ('LEFTPADDING', (0,0), (-1,-1), 6),
        ('RIGHTPADDING', (0,0), (-1,-1), 6),
        ('TOPPADDING', (0,0), (-1,-1), 6),
        ('BOTTOMPADDING', (0,1), (-1,-1), 6), # Padding for content rows
    ])
    table.setStyle(table_style)
    
    story_table.append(table)
    story_table.append(Spacer(1, 0.2*inch))
    story_table.append(Paragraph("Some text after the table.", normal_style))
    
    # 7. Build the PDF
    try:
        doc_table.build(story_table)
        print(f"Successfully created {filename_table}")
    except Exception as e:
        print(f"Error building PDF: {e}")
    
    

    When to choose which method:

    • Method 1 (Frames/Flowing Text):
      • Ideal for long articles, chapters, or any text that should naturally flow like in a newspaper or magazine.
      • Handles page breaks automatically, continuing the flow.
    • Method 2 (Table):
      • Best when you have structured data that needs to be presented side-by-side but doesn't necessarily flow from one cell to the next.
      • Good for key-value pairs, comparative lists, etc.
      • Cells in a table row will expand vertically to accommodate the tallest cell in that row.

    Choose the method that best suits the nature of the content you want to display in two columns. For typical "two columns of text," Method 1 is usually what people mean.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.