Соответствующие диапазоны строк в python (например, диапазоны sed)

Question

Иногда хорошие старые инструменты по-прежнему работают лучше всего. В СЭД, я мог бы написать что-то вроде этого:

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

Первый применяет замену всех линий между теми согласующего/^ Страница 5:/и/^ Page 6: /. Второй начинает печатать на линии 110 и останавливает 3 строки после одного совпадения/^ Страница 10: /. В третьем примере применяется замена каждой строки в указанном диапазоне.

Я не возражаю против поиска re.search для поиска по строкам, но для диапазонов строк, номеров строк или относительных смещений мне приходится писать весь парсер. Есть ли идиома или модуль python, которые могут упростить такие операции?

Я не хочу называть sed из python: я делаю вещи типа python с текстом и просто хочу иметь возможность работать на линейных диапазонах простым способом.

Редактировать: Это нормально, если решение работает в списке строк python. Я не хочу обрабатывать гигабайты текста. Но мне нужно указать несколько операций, а не один, и чередовать их с однострочными регулярными выражениями. Я посмотрел на итераторы (на самом деле я бы приветствовал решение с использованием итераторов), но результаты всегда выходили из-под контроля за чем-то большим, чем одиночная операция.

Вот простой пример: фрагмент кода с комментариями в стиле 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 ($). Это может быть полезно для подсчета строк.

Я мог бы, на данный момент, придумать это, которое печатает ОДИН БОЛЬШЕ ЛИНИИ после появления «шестерки» (целая линия захватывается финалом ^.*?$, но я уверен, что должно быть намного лучше):

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.
  Если ваш файл не слишком большой, и у вас есть более одного шаблона для поиска, я бы пошел с этим.

Edit: Если вы заинтересованы в итераторных инструментов, 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')] 

Последний почти такой же сжатый как его коллега.