蟒蛇中的线条匹配范围（如sed范围）

Question

有时，好的旧工具仍然效果最好。在SED，我可以写这样的事情：

sed '/^Page 5:/,/^Page 6:/p' 
sed '110,/^Page 10:/+3p' 
sed '/^Page 5:/,/^Page 6:/s/this/that/g' 

第一施加取代成的那些匹配/ ^第5页之间的所有行：/和/ ^第6页：/。第二个在第110行开始打印，并在第一个匹配/第10页之后停止3行。第三个示例将替换应用于指定范围中的每一行。

我不介意使用re.search逐行搜索，但对于行范围，行号或相对偏移量，我最终不得不编写一个完整的解析器。有没有可以简化这种操作的Python成语或模块？

我不想从python中调用sed：我正在使用python类型的东西来处理文本，只是希望能够以直接的方式对线段进行操作。

编辑：如果解决方案工作在python的字符串列表上，这很好。我不想处理千兆字节的文本。但是我确实需要指定几个操作，而不仅仅是一个，并且用单行regexp替换来交叉它们。我已经看过迭代器（实际上我会欢迎使用迭代器的解决方案），但结果总是无法用于单一操作以外的任何事情。

下面是一个简单的例子：一个包含java风格评论的代码片段，将被改为python评论。 （别担心，我不是想编写使用正则表达式一个交叉编译:-)

/* 
This is a multi-line comment. 
It does not obligingly start lines with " * " 
*/ 

x++; // a single-line comment 

是微不足道的编写正则表达式是改变“//”评论“＃”（也下降分号，将“++”改为“+ = 1”等）但是我们如何在多行的java注释的每一行的开始插入“＃”？我可以将整个文件的正则表达式作为单个字符串来执行，这是一种痛苦，因为其余的转换都是面向行的。我也无法（有用地）将迭代器与面向行的正则表达式集成在一起。我会很感激的建议。

Answer 1

我会尝试使用正则表达式标记re.DOTALL或re.MULTILINE。

第一行将换行符视为常规字符，因此如果使用.*，它可能会计算模式内的换行符。

第二个差不多，但仍然可以使用linestarts（^）和endlines（$）来匹配这些。这可以用于统计线条。

现在，我可以想出这个，在“六”发生后打印ONE MORE LINE（整条线被最终的^.*?$捕获，但我确信应该有一个更好的方式）：

import re 

source = """one 
two 
three 
four 
five 
six 
seven 
eight 
nine 
ten""" 

print re.search('^three.*six.*?^.*?$', source, re.DOTALL|re.MULTILINE).group(0) 

Answer 2

对于评论至少，只需使用一个真正的解析器。

#!/usr/bin/python 

from pyparsing import javaStyleComment 
import re 

text = """ 

/* 
* foo 
* bar 
* blah 
*/ 

/*********************** 
it never ends 
***********************/ 

/* foo 

    bar blah 
*/ 

/* 
* ugly 
* comment 
*/ 

// Yet another 

int a = 100; 

char* foo; 

""" 

commentTokenStripper = re.compile(r'\s*[/\\\*]') 

for match in javaStyleComment.scanString(text): 
    start,end = match[-2:] 
    print '# comment block %d-%d ##############' % (start,end) 
    lines = ['#' + re.sub(commentTokenStripper, '', l) for l in match[0][0].splitlines()] 
    print '\n'.join(lines) 
    print 

息率

# comment block 2-30 ############## 
# 
# foo 
# bar 
# blah 
# 

# comment block 32-96 ############## 
# 
# it never ends 
# 

# comment block 98-121 ############## 
# foo 
# 
# bar blah 
# 

# comment block 123-145 ############## 
# 
# ugly 
# comment 
# 

# comment block 147-161 ############## 
# Yet another 

Answer 3

我不认为有一个简单的方法来做到这一点在Python。

但也有不同的方法，你可以遵循：

• 逐行读取文件中的行，并激活只有当你需要搜索。
  这样做的优点是只读取一次文件，但它在当时只能读取一行文件。

• 用itertools.islice()切片文件，并在那里搜索你的模式。
  你必须为每个模式重新读取文件，但它很容易实现。

• 使用mmap。
  如果你的文件不是很大，并且你有多个模式可以查找，我会选择这个模式。

编辑：如果你有兴趣在迭代器工具，itertools.takewhile()有智能拉姆达可能做的工作。

声明：我对sed一无所知。

Answer 4

就是这样。

from __future__ import print_function 

def get_lines(some_file, start_rule, end_rule, process=print): 
    line_iter= enumerate(source) 
    for n, text in line_iter: 
     if start_rule(n, text): 
      process(text) 
      break 
    for n, text in line_iter: 
     process(text) 
     if end_rule(n, text): break 

然后你就可以定义很多小功能：

def match_page_5(n, text): 
    return re.match('^Page 5:', text) 
def match_line(n, text): 
    return line == n 

或有状态，可调用的对象

class Match_Pattern(collections.Callable): 
    def __init__(self, pattern): 
     self.pat= re.compile(pattern) 
    def __call__(self, n, text): 
     return self.pat.match(text) 

class Match_Lines_Post_Pattern(collections.Callable): 
    def __init__(self, pattern, lines): 
     self.pat= re.compile(pattern) 
     self.lines= lines 
     self.saw_it= None 
    def __call__(self, n, text): 
     if self.saw_it: 
      if n == self.saw_it + self.lines 
       return True 
      if self.pat.match(text): 
       self.saw_it = n 

你可以通过这样的功能，创建语法糖。

def sed_by_pattern(filename, pattern1, pattern2): 
    with open(filename,'r') as source: 
     get_lines(source, lambda n,tx: re.match(pattern1,tx), lambda n,tx: re.match(pattern2,tx)) 

这让你像下面 这种用法的功能是作为额外标点符号SED命令一样简单。

sed_by_pattern(some_file, '^Page 5:', '^Page 6:') 

或者此位糖...

def sed_by_matcher(filename, matcher1, matcher2) 
    with open(filename, 'r') as source: 
     get_lines(source, matcher1, matcher2) 

这种用法是作为额外标点符号SED命令一样简单。

see_by_matcher(some_file, match_line(100), Match_Lines_Post_Pattern('^Page 10:', 3)) 

Answer 5

你可以尝试这样的事：

import re 

def firstline(rx, lst): 
    for n, s in enumerate(lst): 
     if re.search(rx, s): 
      return n 
    return 0 

然后：

text = ["How", "razorback", "jumping", "frogs", "can", "level", "six", "piqued", "gymnasts"] 

# prints all lines between the one matching `^r` and the one matching `^s` 
print text[firstline('^r', text)+1:firstline('^s', text)] 

这看起来过于冗长，但可以减少冗长，例如：

import functools 
L = functools.partial(firstline, lst=text) 

print text[L('^r')+1:L('^s')] 

后者几乎一样简洁作为其sed对手。