使用pylatexenc解析LaTeX时，如何让多轮编辑在同一文本顺序执行？

我正在使用pylatexenc库解析LaTeX文件(.tex)为节点结构，需要对符合条件的节点对应的LaTeX代码执行删除或替换操作。但当前循环执行编辑时，每次操作都会生成独立的文本版本，请问如何确保所有编辑步骤都在同一文本上按顺序完成？

原代码如下：

from pylatexenc import latexnodes, latexwalker
from pylatexenc.latexnodes import LatexNodesCollector, LatexTokenReader
from pylatexenc.latexnodes.nodes import LatexEnvironmentNode, LatexCharsNode, LatexMacroNode, LatexGroupNode, LatexNode
from pylatexenc.latexnodes.parsers import LatexGeneralNodesParser
from pylatexenc.latexwalker import LatexWalker
import re

data=(r'''
\section{Heading}\label{heading-label}
\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\item
  Pater noster qui est in caelis.
\end{enumerate}

\section{Heading 2}
\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\setcounter{enumi}{1}
\item
  Et ne nos inducat in tempore malo.\footnote{footnote}
\item
  Gratia plena dominus tecum.
\item
  Panem nostrum quotidanum da nobis hodie.
\end{enumerate}
''')

my_latex_walker = LatexWalker(data)
my_reader = LatexTokenReader(data)
parsing_state = my_latex_walker.make_parsing_state()
nodes, parsing_state_delta = my_latex_walker.parse_content(LatexGeneralNodesParser())
def traverse(node):
    #Parsing for enumerate environments with additional arguments and removing them
        if node.isNodeType(LatexEnvironmentNode) and node.environmentname == "enumerate":
            subnodes = node.nodelist
            if subnodes[0].isNodeType(LatexCharsNode)\
            and subnodes[1].macroname == "def"\
            and subnodes[2].isNodeType(LatexMacroNode)\
            and subnodes[2].macroname == "labelenumi"\
            and subnodes[3].isNodeType(LatexGroupNode):
                string_inside_environment = (subnodes.latex_verbatim())
                string_with_environment = (node.latex_verbatim())
                if subnodes[5].macroname == "setcounter":
                    to_remove =  str(subnodes[0].latex_verbatim()) + str(subnodes[1].latex_verbatim()) + str(subnodes[2].latex_verbatim()) + str(subnodes[3].latex_verbatim()) + str(subnodes[4].latex_verbatim()) + str(subnodes[5].latex_verbatim())
                else:
                    to_remove =  str(subnodes[0].latex_verbatim()) + str(subnodes[1].latex_verbatim()) + str(subnodes[2].latex_verbatim()) + str(subnodes[3].latex_verbatim()) + str(subnodes[4].latex_verbatim())

                cleaned_string = (string_inside_environment.replace(to_remove,''))


            #Parsing the cleaned up string for first level \item commands and replace by \mypara
                my_latex_walker2 = LatexWalker(cleaned_string)
                itemnodes, parsing_state_delta2 = my_latex_walker2.parse_content(LatexGeneralNodesParser())
                for itemnode in itemnodes:
                    if itemnode.isNodeType(LatexMacroNode) and itemnode.macroname == "item":
                        revamped_string = cleaned_string.replace(itemnode.latex_verbatim(), r'\mypara ')
                        result = data.replace(string_with_environment, revamped_string)

        if node.isNodeType(LatexGroupNode): #Recurse into groupnodes
            traverse(node)

for node in nodes:
    traverse(node)

print(data)

原代码的核心问题：

• 每次修改都基于原始data字符串执行替换，而非累积之前修改后的文本，导致所有修改互相独立，最终无法叠加生效
• 依赖latex_verbatim()的字符串匹配替换，容易因重复文本出现误替换
• 嵌套解析子节点时未考虑文本修改后的位置偏移，导致后续节点定位失效

要实现所有修改在同一文本上顺序执行，需做到：

1. 维护可变的文本缓冲区，所有修改都基于该缓冲区更新
2. 利用节点的pos（起始位置）和pos_end（结束位置）属性精准定位修改区域，避免字符串匹配歧义
3. 反向遍历节点，避免前面的修改影响后续节点的位置索引

修正后的代码如下：

from pylatexenc import latexnodes, latexwalker
from pylatexenc.latexnodes.nodes import LatexEnvironmentNode, LatexCharsNode, LatexMacroNode, LatexGroupNode
from pylatexenc.latexnodes.parsers import LatexGeneralNodesParser
from pylatexenc.latexwalker import LatexWalker

# 原始LaTeX文本转为列表，方便高效修改（字符串不可变，列表支持切片操作）
data_list = list(r'''
\section{Heading}\label{heading-label}
\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\item
  Pater noster qui est in caelis.
\end{enumerate}

\section{Heading 2}
\begin{enumerate}
\def\labelenumi{\arabic{enumi}.}
\setcounter{enumi}{1}
\item
  Et ne nos inducat in tempore malo.\footnote{footnote}
\item
  Gratia plena dominus tecum.
\item
  Panem nostrum quotidanum da nobis hodie.
\end{enumerate}
''')

def get_current_text():
    return ''.join(data_list)

# 先解析原始文本，收集所有需要处理的enumerate节点
walker = LatexWalker(get_current_text())
parsing_state = walker.make_parsing_state()
nodes, _ = walker.parse_content(LatexGeneralNodesParser())

enumerate_nodes = []
def collect_target_nodes(node):
    if node.isNodeType(LatexEnvironmentNode) and node.environmentname == "enumerate":
        enumerate_nodes.append(node)
    # 递归遍历所有子节点
    for child in node.nodelist:
        collect_target_nodes(child)

for node in nodes:
    collect_target_nodes(node)

# 反向处理节点，避免修改后位置偏移
for node in reversed(enumerate_nodes):
    subnodes = node.nodelist
    # 检查是否符合清理条件
    if (len(subnodes) >= 4 
        and subnodes[0].isNodeType(LatexCharsNode)
        and isinstance(subnodes[1], LatexMacroNode) and subnodes[1].macroname == "def"
        and isinstance(subnodes[2], LatexMacroNode) and subnodes[2].macroname == "labelenumi"
        and subnodes[3].isNodeType(LatexGroupNode)):
        
        # 确定要删除的内容范围
        if len(subnodes) >=6 and isinstance(subnodes[5], LatexMacroNode) and subnodes[5].macroname == "setcounter":
            remove_end = subnodes[5].pos_end
        else:
            remove_end = subnodes[4].pos_end
        
        # 定位环境内部起始位置，执行删除
        env_inner_start = node.pos + len(r'\begin{enumerate}')
        del data_list[env_inner_start:remove_end]
        
        # 重新获取当前文本，定位环境位置，处理\item替换
        current_text = get_current_text()
        env_start = current_text.find(r'\begin{enumerate}', node.pos)
        env_end = current_text.find(r'\end{enumerate}', env_start)
        env_content = current_text[env_start:env_end]
        
        # 解析环境内容，收集\item的绝对位置
        sub_walker = LatexWalker(env_content)
        sub_nodes, _ = sub_walker.parse_content(LatexGeneralNodesParser())
        
        item_positions = []
        for sub_node in sub_nodes:
            if isinstance(sub_node, LatexMacroNode) and sub_node.macroname == "item":
                abs_start = env_start + sub_node.pos
                abs_end = env_start + sub_node.pos_end
                item_positions.append( (abs_start, abs_end) )
        
        # 反向替换\item，避免位置偏移
        for abs_start, abs_end in reversed(item_positions):
            del data_list[abs_start:abs_end]
            data_list[abs_start:abs_start] = list(r'\mypara ')

# 输出最终结果
final_text = get_current_text()
print(final_text)

1. 用列表存储文本：字符串是不可变类型，每次修改都会生成新对象，列表支持高效的切片删除和插入操作
2. 先收集目标节点：提前遍历所有节点并收集需要处理的enumerate节点，避免修改文本后原节点位置信息失效
3. 反向处理逻辑：从后往前处理节点和替换操作，确保前面的修改不会影响后续节点的位置索引
4. 基于位置精准操作：直接使用节点的位置信息定位修改区域，避免字符串匹配带来的误替换问题

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