使用python-docx处理含多合并单元格表格时查找替换报索引越界错误

我用python-docx实现Word文档的查找替换功能，采用的是adejones开发的代码。该代码在小文档中运行正常，但处理包含大量表格的大文档时，触发了list index out of range错误。经调试发现，错误出现在遍历row.cells的语句，具体是处理带有大量合并单元格的表格时出错。已确认t.rows和row均存在对象，但获取单元格时失败，无法分享文档，希望获取解决思路。

错误信息 #

File "C:\Anaconda3\lib\site-packages\docx\table.py", line 161, in _cells
    cells.append(cells[-col_count])

IndexError: list index out of range

使用的代码 #

def docx_find_replace_text(doc, search_text, replace_text):
    paragraphs = list(doc.paragraphs)
    for t in doc.tables:
        for row in t.rows:
            for cell in row.cells:
                for paragraph in cell.paragraphs:
                    paragraphs.append(paragraph)
    for p in paragraphs:
        if search_text in p.text:
            inline = p.runs
            # Replace strings and retain the same style.
            # The text to be replaced can be split over several runs so
            # search through, identify which runs need to have text replaced
            # then replace the text in those identified
            started = False
            search_index = 0
            # found_runs is a list of (inline index, index of match, length of match)
            found_runs = list()
            found_all = False
            replace_done = False
            for i in range(len(inline)):

                # case 1: found in single run so short circuit the replace
                if search_text in inline[i].text and not started:
                    found_runs.append((i, inline[i].text.find(search_text), len(search_text)))
                    text = inline[i].text.replace(search_text, str(replace_text))
                    inline[i].text = text
                    replace_done = True
                    found_all = True
                    break

                if search_text[search_index] not in inline[i].text and not started:
                    # keep looking ...
                    continue

                # case 2: search for partial text, find first run
                if search_text[search_index] in inline[i].text and inline[i].text[-1] in search_text and not started:
                    # check sequence
                    start_index = inline[i].text.find(search_text[search_index])
                    check_length = len(inline[i].text)
                    for text_index in range(start_index, check_length):
                        if inline[i].text[text_index] != search_text[search_index]:
                            # no match so must be false positive
                            break
                    if search_index == 0:
                        started = True
                    chars_found = check_length - start_index
                    search_index += chars_found
                    found_runs.append((i, start_index, chars_found))
                    if search_index != len(search_text):
                        continue
                    else:
                        # found all chars in search_text
                        found_all = True
                        break

                # case 2: search for partial text, find subsequent run
                if search_text[search_index] in inline[i].text and started and not found_all:
                    # check sequence
                    chars_found = 0
                    check_length = len(inline[i].text)
                    for text_index in range(0, check_length):
                        if inline[i].text[text_index] == search_text[search_index]:
                            search_index += 1
                            chars_found += 1
                        else:
                            break
                    # no match so must be end
                    found_runs.append((i, 0, chars_found))
                    if search_index == len(search_text):
                        found_all = True
                        break

            if found_all and not replace_done:
                for i, item in enumerate(found_runs):
                    index, start, length = [t for t in item]
                    if i == 0:
                        text = inline[index].text.replace(inline[index].text[start:start + length], str(replace_text))
                        inline[index].text = text
                    else:
                        text = inline[index].text.replace(inline[index].text[start:start + length], '')
                        inline[index].text = text

1. 绕过python-docx的单元格遍历bug #

这个错误是python-docx内部处理复杂合并单元格时的逻辑缺陷，当表格存在跨多行/多列的嵌套合并时，row.cells的索引计算会出错。可以直接通过XML节点访问来获取表格内的段落，避免触发内部bug：

from docx.oxml.table import CT_Tbl
from docx.oxml.text.paragraph import CT_P

def get_table_paragraphs(table):
    paragraphs = []
    tbl = table._element
    # 直接遍历XML中的行和单元格节点
    for tr in tbl.findall('.//w:tr'):
        for tc in tr.findall('.//w:tc'):
            for p in tc.findall('.//w:p'):
                # 转换为python-docx的Paragraph对象
                paragraphs.append(table.part.related_parts.element_part(p).element)
    return paragraphs

修改原代码中的表格遍历部分，用上述函数替代row.cells循环：

for t in doc.tables:
    paragraphs.extend(get_table_paragraphs(t))

2. 添加异常捕获跳过错误行 #

在遍历单元格的环节加入异常处理，跳过无法解析的行，保证程序能继续处理其他内容：

for t in doc.tables:
    for row in t.rows:
        try:
            cells = row.cells
        except IndexError:
            # 跳过解析失败的行
            continue
        for cell in cells:
            for paragraph in cell.paragraphs:
                paragraphs.append(paragraph)

3. 升级python-docx版本 #

部分旧版本的python-docx存在合并单元格处理的已知bug，升级到最新稳定版（如0.8.11及以上）可能已修复该问题，执行以下命令升级：

pip install --upgrade python-docx

4. 简化文档表格结构 #

如果文档允许，可先手动或通过脚本拆分不必要的合并单元格，减少复杂合并的嵌套层级，降低python-docx解析时的出错概率。

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