带正则表达式的Python分块

肯·威廉姆斯

在Perl中，很容易遍历字符串以将其分块为令牌：

$key = ".foo[4][5].bar.baz";

@chunks = $key =~ m/\G\[\d+\]|\.[^][.]+/gc;
print "@chunks\n";
#>> output: .foo [4] [5] .bar .baz

# Optional error handling:
die "Malformed key at '" . substr($key, pos($key)) . "'"
  if pos($key) != length($key);

如果需要更多控制，则可以将其变成循环：

while ($key =~ m/(\G\[\d+\]|\.[^][.]+)/g) {
  push @chunks, $1;  # Optionally process each one
}

我想找到一种干净，惯用的方式在Python中执行此操作。到目前为止，我只有这样：

import re

key = ".foo[4][5].bar.baz"

rx = re.compile(r'\[\d+\]|\.[^][.]+')
chunks = []
while True:
    m = re.match(rx, key)
    if not m:
        raise ValueError(f"Malformed key at '{key}'")
    chunk = m.group(0)
    chunks.append(chunk[1:] if chunk.startswith('.') else int(chunk[1:-1]))
    key = key[m.end(0):]

    if key == '':
        break

print(chunks)

除了冗长之外，我不喜欢这样做，因为我在处理字符串时需要销毁字符串，因为似乎不存在Perl的\G锚点（在最后一个匹配项停下来的地方拾取）。一种替代方法是在每个循环中跟踪我自己在字符串中的匹配位置，但这似乎更麻烦。

有没有我惯用的习语吗？我也尝试过使用某种解决方案，re.finditer()但似乎没有办法让每场比赛都在上一场比赛的确切结尾处开始（例如re.matchiter()，诸如此类）。

建议和讨论欢迎。

雷蒙德·海廷格（Raymond Hettinger）

概要

您所描述的re.matchiter（）没有直接等效的功能。

我想到了两种选择：

创建不匹配令牌。
用所需的行为编写自己的生成器。

不匹配令牌

Python中常用的技术是定义MISMATCH捕获标记，并在遇到该标记时引发异常。

这是一个有效的示例（我编写并放入Python文档中以便所有人都能找到的示例）：

from typing import NamedTuple
import re

class Token(NamedTuple):
    type: str
    value: str
    line: int
    column: int

def tokenize(code):
    keywords = {'IF', 'THEN', 'ENDIF', 'FOR', 'NEXT', 'GOSUB', 'RETURN'}
    token_specification = [
        ('NUMBER',   r'\d+(\.\d*)?'),  # Integer or decimal number
        ('ASSIGN',   r':='),           # Assignment operator
        ('END',      r';'),            # Statement terminator
        ('ID',       r'[A-Za-z]+'),    # Identifiers
        ('OP',       r'[+\-*/]'),      # Arithmetic operators
        ('NEWLINE',  r'\n'),           # Line endings
        ('SKIP',     r'[ \t]+'),       # Skip over spaces and tabs
        ('MISMATCH', r'.'),            # Any other character
    ]
    tok_regex = '|'.join('(?P<%s>%s)' % pair for pair in token_specification)
    line_num = 1
    line_start = 0
    for mo in re.finditer(tok_regex, code):
        kind = mo.lastgroup
        value = mo.group()
        column = mo.start() - line_start
        if kind == 'NUMBER':
            value = float(value) if '.' in value else int(value)
        elif kind == 'ID' and value in keywords:
            kind = value
        elif kind == 'NEWLINE':
            line_start = mo.end()
            line_num += 1
            continue
        elif kind == 'SKIP':
            continue
        elif kind == 'MISMATCH':
            raise RuntimeError(f'{value!r} unexpected on line {line_num}')
        yield Token(kind, value, line_num, column)

statements = '''
    IF quantity THEN
        total := total + price * quantity;
        tax := price * 0.05;
    ENDIF;
'''

for token in tokenize(statements):
    print(token)

定制发电机

另一种选择是编写具有所需行为的自定义生成器。

编译正则表达式的match（）方法为match操作提供了一个可选的起始位置。使用该工具，编写自定义生成器将match（）应用于连续的起始位置并不难：

def itermatch(pattern, string):
    p = re.compile(pattern)
    pos = 0
    while True:
        mo = p.match(string, pos)
        if mo is None:
            break             # Or raise exception
        yield mo
        pos = mo.end()

本文收集自互联网，转载请注明来源。

如有侵权，请联系 [email protected] 删除。