python中的多行模式匹配 [英] multi-line pattern matching in python

问题描述

计算机定期生成的消息(简体):

A periodic computer generated message (simplified):

Hello user123,

- (604)7080900
- 152
- minutes

Regards

使用python，我如何在两个空行(空行是\n\n之后)之间提取(604)7080900"，"152"，分钟"(即，任何跟随前导"- "模式的文本) "Hello user123"和"Regards"之前的\n\n).如果结果字符串列表存储在数组中，则更好.谢谢！

Using python, how can I extract "(604)7080900", "152", "minutes" (i.e. any text following a leading "- " pattern) between the two empty lines (empty line is the \n\n after "Hello user123" and the \n\n before "Regards"). Even better if the result string list are stored in an array. Thanks!

两个空白行之间的行数不固定.

edit: the number of lines between two blank lines are not fixed.

第二次

例如

hello

- x1
- x2
- x3

- x4

- x6
morning
- x7

world

x1 x2 x3很好，因为所有行都被2条空行包围，所以x4出于相同的原因也很好. x6不好，因为后面没有空行，x7不好，因为前面没有空行. x2很好(不像x6，x7)，因为前面的线是一条好线，后面的线也是好.

x1 x2 x3 are good, as all lines are surrounded by 2 empty lines, x4 is also good for the same reason. x6 is not good because no blank line follows it, x7 is not good as no blank in front of it. x2 is good (not like x6, x7) because the line ahead is a good line and the line following it is also good.

当我发布问题时，这种情况可能不清楚:

this conditions might be not clear when I posted the question:

a continuous of good lines between 2 empty lines

good line must have leading "- "
good line must follow an empty line or follow another good line
good line must be followed by an empty line or followed by another good line

谢谢

推荐答案

最简单的方法是遍历这些行(假设您有行列表或文件，或将字符串拆分为行列表)，直到您会看到只有'\n'的行，然后检查每行是否以'- '开头(使用startswith字符串方法)并将其切成薄片，存储结果，直到找到另一个空行.例如:

The simplest approach is to go over these lines (assuming you have a list of lines, or a file, or split the string into a list of lines) until you see a line that's just '\n', then check that each line starts with '- ' (using the startswith string method) and slicing it off, storing the result, until you find another empty line. For example:

# if you have a single string, split it into lines.
L = s.splitlines()
# if you (now) have a list of lines, grab an iterator so we can continue
# iteration where it left off.
it = iter(L)
# Alternatively, if you have a file, just use that directly.
it = open(....)

# Find the first empty line:
for line in it:
    # Treat lines of just whitespace as empty lines too. If you don't want
    # that, do 'if line == ""'.
    if not line.strip():
        break
# Now starts data.
for line in it:
    if not line.rstrip():
        # End of data.
        break
    if line.startswith('- '):
        data.append(line[:2].rstrip())
    else:
        # misformed data?
        raise ValueError, "misformed line %r" % (line,)

已由于您已详细说明了要执行的操作，因此下面是循环的更新版本.它不再循环两次，而是收集数据直到遇到坏"行，并且在遇到块分隔符时保存或丢弃收集的行.它不需要显式的迭代器，因为它不会重新启动迭代，因此您只需向其传递一行(或任何可迭代的)行即可:

Edited: Since you elaborate on what you want to do, here's an updated version of the loops. It no longer loops twice, but instead collects data until it encounters a 'bad' line, and either saves or discards the collected lines when it encounters a block separator. It doesn't need an explicit iterator, because it doesn't restart iteration, so you can just pass it a list (or any iterable) of lines:

def getblocks(L):
    # The list of good blocks (as lists of lines.) You can also make this
    # a flat list if you prefer.
    data = []
    # The list of good lines encountered in the current block
    # (but the block may still become bad.)
    block = []
    # Whether the current block is bad.
    bad = 1
    for line in L:
        # Not in a 'good' block, and encountering the block separator.
        if bad and not line.rstrip():
            bad = 0
            block = []
            continue
        # In a 'good' block and encountering the block separator.
        if not bad and not line.rstrip():
            # Save 'good' data. Or, if you want a flat list of lines,
            # use 'extend' instead of 'append' (also below.)
            data.append(block)
            block = []
            continue
        if not bad and line.startswith('- '):
            # A good line in a 'good' (not 'bad' yet) block; save the line,
            # minus
            # '- ' prefix and trailing whitespace.
            block.append(line[2:].rstrip())
            continue
        else:
            # A 'bad' line, invalidating the current block.
            bad = 1
    # Don't forget to handle the last block, if it's good
    # (and if you want to handle the last block.)
    if not bad and block:
        data.append(block)
    return data

这里正在起作用:

>>> L = """hello
...
... - x1
... - x2
... - x3
...
... - x4
...
... - x6
... morning
... - x7
...
... world""".splitlines()
>>> print getblocks(L)
[['x1', 'x2', 'x3'], ['x4']]

这篇关于python中的多行模式匹配的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！