检查字符串中的位置是否在一对特定字符内

Question

In python, what would be the most efficient way to figure out if a position in a string is within a pair of certain character sequences?

       0--------------16-------------------37---------48--------57
       |               |                    |          |        |
cost=r"a) This costs \$1 but price goes as $x^2$ for \(x\) item(s)."

In the string cost , I want to figure out if a certain position is enclosed by a pair of $ or within \( and \) .

For the string cost a function is_maths(cost,x) would return True for x in [37,38,39,48] and evaluate to False for everywhere else.

The motivation is to figure out valid latex maths positions, any alternate efficient ways using python are also welcome.

Answer 1

You'll need to parse the string up to the requested position, and if inside a valid pair of LaTeX environment delimiters, up to the closing delimiter, to be able to answer with True or False . That's because you have to process each relevant metacharacter (backslashes, dollars and parentheses) to determine their effect.

I've understood that Latex's $...$ and \(...\) environment delimiters can't be nested, so you don't have to worry about nested statements here; you only need to find the nearest complete $...$ or \(...\) pair.

You can't just match literal $ or \( or \) characters, however, because each of these could be preceded by an arbitrary number of \ backslashes. Instead, tokenize the input string on backslashes, dollars or parentheses, and iterate over the tokens in order and track what was last matched to determine their effect (escape the next character, and opening and closing maths environments).

You don't need to continue parsing if you are past the requested position and outside of a maths environment section; you already have your answer then and can return False early.

Here's my implementation of such a parser:

import re

_maths_pairs = {
    # keys are opening characters, values matching closing characters
    # each is a tuple of char (string), escaped (boolean)
    ('$', False): ('$', False),
    ('(', True): (')', True),
}
_tokens = re.compile(r'[\\$()]')

def _tokenize(s):
    """Generator that produces token, pos, prev_pos tuples for s

    * token is a single character: a backslash, dollar or parethesis
    * pos is the index into s for that token
    * prev_pos is te position of the preceding token, or -1 if there
      was no preceding token

    """
    prev_pos = -1
    for match in _tokens.finditer(s):
        token, pos = match[0], match.start()
        yield token, pos, prev_pos
        prev_pos = pos

def is_maths(s, pos):
    """Determines if pos in s is within a LaTeX maths environment"""
    expected_closer = None  # (char, escaped) if within $...$ or \(...\)
    opener_pos = None  # position of last opener character
    escaped = False  # True if the most recent token was an escaping backslash

    for token, token_pos, prev_pos in _tokenize(s):
        if expected_closer is None and token_pos > pos:
            # we are past the desired position, it'll never be within a
            # maths environment.
            return False

        # if there was more text between the current token and the last
        # backslash, then that backslash applied to something else.
        if escaped and token_pos > prev_pos + 1:
            escaped = False

        if token == '\\':
            # toggle the escaped flag; doubled escapes negate
            escaped = not escaped
        elif (token, escaped) == expected_closer:
            if opener_pos < pos < token_pos:
                # position is after the opener, before the closer
                # so within a maths environment.
                return True
            expected_closer = None
        elif expected_closer is None and (token, escaped) in _maths_pairs:
            expected_closer = _maths_pairs[(token, escaped)]
            opener_pos = token_pos

        prev_pos = token_pos

    return False

Demo:

>>> cost = r'a) This costs \$1 but price goes as $x^2$ for \(x\) item(s).'
>>> is_maths(cost, 0)  # should be False
False
>>> is_maths(cost, 16)  # should be False, preceding $ is escaped
False
>>> is_maths(cost, 37)  # should be True, within $...$
True
>>> is_maths(cost, 48)  # should be True, within \(...\)
True
>>> is_maths(cost, 57)  # should be False, within unescaped (...)
False

and additional tests to show that escapes are handled correctly:

>>> is_maths(r'Doubled escapes negate: \\$x^2$', 27)  # should be true
True
>>> is_maths(r'Doubled escapes negate: \\(x\\)', 27)  # no longer escaped, so false
False

My implementation studiously ignores malformed LaTeX issues; unescaped $ characters within \(...\) or escaped \( and \) characters within $...$ are ignored, as are further \( openers inside \(...\) sequences, or \) closers without a matching \( opener preceding. This makes sure the function continues to work even when given input that LaTeX itself would not render. The parser can be altered to throw an exception or return False in those cases, however. In that case you need to add a global set created from _math_pairs.keys() | _math_pairs.values() and test (char, escaped) against that set when expected_closer is not None and (token, escaped) != expected_closer is false (detecting nested environment delimiters) and test for char == ')' and escaped and expected_closer is None to detect the \) closer without an opener problem.