Working with tables

from pptx import Presentation
from pptx.util import Inches

prs = Presentation()
slide = prs.slides.add_slide(prs.slide_layouts[5])

# Add a 3x3 table
x, y, cx, cy = Inches(2), Inches(2), Inches(4), Inches(1.5)
shape = slide.shapes.add_table(3, 3, x, y, cx, cy)

# Access the table object
table = shape.table

prs.save('table-example.pptx')

# Get cell at row 0, column 0 (top-left)
cell = table.cell(0, 0)

# Set cell text
cell.text = 'Header 1'

# Access cell at row 1, column 2
cell = table.cell(1, 2)
cell.text = 'Data'

# Iterate all cells (left-to-right, top-to-bottom)
for cell in table.iter_cells():
    if not cell.is_spanned:
        cell.text = 'Content'

# Iterate only visible cells (not spanned by merged cells)
visible_cells = (cell for cell in table.iter_cells() if not cell.is_spanned)
for cell in visible_cells:
    print(cell.text)

# Access specific row
row = table.rows[0]
row.height = Inches(0.5)

# Access specific column
col = table.columns[1]
col.width = Inches(2)

# Iterate rows
for row in table.rows:
    print(f"Row height: {row.height.inches} inches")

# Iterate columns
for col in table.columns:
    print(f"Column width: {col.width.inches} inches")

# Merge cells from (0,0) to (1,1) - creates a 2x2 merged cell
cell = table.cell(0, 0)
other_cell = table.cell(1, 1)
cell.merge(other_cell)

# Check if cell is merge origin
if cell.is_merge_origin:
    print(f"Merged cell: {cell.span_height} rows x {cell.span_width} cols")

# Check if cell is spanned
if table.cell(0, 1).is_spanned:
    print("This cell is hidden by a merged cell")

cell = table.cell(0, 0)

if cell.is_merge_origin:
    cell.split()  # Restores underlying grid cells

# Enable first row as header
table.first_row = True

# Enable first column formatting
table.first_col = True

# Enable last row formatting (for totals)
table.last_row = True

# Enable last column formatting
table.last_col = True

# Enable horizontal banding (alternating row colors)
table.horz_banding = True

# Enable vertical banding
table.vert_banding = False

def iter_merge_origins(table):
    """Generate each merge-origin cell in table."""
    return (cell for cell in table.iter_cells() if cell.is_merge_origin)

def merged_cell_report(cell):
    """Return string describing merged cell."""
    return (
        f'merged cell at row {cell.row_idx}, col {cell.col_idx}, '
        f'{cell.span_height} cells high and {cell.span_width} cells wide'
    )

# Print report of all merged cells
for merge_origin_cell in iter_merge_origins(table):
    print(merged_cell_report(merge_origin_cell))

def has_merged_cells(table):
    """Return True if table contains any merged cells."""
    for cell in table.iter_cells():
        if cell.is_merge_origin:
            return True
    return False

if has_merged_cells(table):
    print("Table contains merged cells")

def iter_visible_cells(table):
    """Generate cells that display text (not spanned)."""
    return (cell for cell in table.iter_cells() if not cell.is_spanned)

# Set text for all visible cells
for idx, cell in enumerate(iter_visible_cells(table)):
    cell.text = f'Cell {idx}'

prs = Presentation('template.pptx')
slide = prs.slides.add_slide(prs.slide_layouts[2])  # Layout with table placeholder

# Access table placeholder (usually at index 1)
table_placeholder = slide.shapes[1]

# Insert table
shape = table_placeholder.insert_table(rows=3, cols=4)
table = shape.table

# Populate table...