Содержание


Секреты регулярных выражений (regular expressions)

Часть 2. Регулярные выражения в конкретных программах

Comments

Серия контента:

Этот контент является частью # из серии # статей: Секреты регулярных выражений (regular expressions)

Следите за выходом новых статей этой серии.

Этот контент является частью серии:Секреты регулярных выражений (regular expressions)

Следите за выходом новых статей этой серии.

1. Введение. Знание особенностей повышает эффективность

В предыдущей статье я приводил в основном примеры регулярных выражений без привязки к конкретной программе или языковой среде. Но каждая реализация механизма регулярных выражений имеет свои особенности, свои преимущества, которыми можно воспользоваться, свои недостатки, о которых следует знать, чтобы обходить их. Ведь регулярные выражения не существуют сами по себе, их применение неразрывно связано либо с некоторой утилитой (grep, sed, awk), либо с одним из языков программирования (Perl, Python, Tcl и т.д.).

Зная тонкости реализации механизма регулярных выражений в той или иной программной среде, можно существенно повысить эффективность их практического использования. Здесь я не рассматриваю регулярные выражения для утилит поиска grep/egrep/fgrep, потому что большинство примеров из первой статьи было ориентировано именно на эти программы.

2. Примеры использования регулярных выражений в Perl

Perl является "неофициальным чемпионом" по частоте использования в нём регулярных выражений для решения различных задач среди всех интерпретируемых или скриптовых языков. Несмотря на постоянно растущее скептическое отношение к Perl, он вполне справляется с той работой, для которой главным образом и предназначен – для обработки текстовых данных (вспомним один из вариантов "расшифровки" имени Perl – Practical Extraction and Report Language).

2.1. Корректная версия шаблона для поиска IP-адреса

Впрочем, пора уже перейти к обещанным примерам. Внимательный читатель при изучении примера для поиска IP-адресов из предыдущей статьи наверняка заметил самый большой его недостаток – наряду с корректными IP-адресами регулярное выражение

[1-9][0-9]\{0,2\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}

будет находить и выводить строки вида "900.800.700.600", никоим образом к IP-адресам не относящиеся. Диалект простых регулярных выражений в данном случае не позволяет без непомерных затрат времени и сил решить эту проблему. Но в Perl реализованы расширенные регулярные выражения, что позволяет упростить решение.

В первой части IP-адреса может находиться трёхзначное число, начинающееся либо с "1" (за которой могут следовать две любые цифры), либо с "2" (но в этом случае число не должно быть больше 255), или любое двузначное число, или однозначное число (цифры от 1 до 9). На диалекте расширенных регулярных выражений для Perl это можно записать следующим образом:

([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])

Обратите внимание на использование новой конструкции группирования символов, которую часто называют дизъюнкцией: a|b|c – т.е. должен совпасть только один из указанных вариантов, – либо a, либо b, либо c. В нашем примере таких взаимоисключающих вариантов пять:

  • [1-9] – соответствует значениям от 1 до 9;
  • [1-9][0-9] – соответствует значениям от 10 до 99;
  • 1[0-9][0-9] – соответствует значениям от 100 до 199;
  • 2[0-4][0-9] – соответствует значениям от 200 до 249;
  • 25[0-5] – соответствует значениям от 250 до 255.

Одиночный нуль здесь исключается, так как обычные IP-адреса не содержат значение 0 в первом байте. Это выражение можно немного улучшить, если заменить диапазон [0-9] применяемым в Perl метасимволом \d (обозначение цифрового символа). После замены выражение приобретёт вид:

([1-9]|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])

Немного короче, но ведь это шаблон только для самой первой части IP-адреса. Во второй и третьей частях допускаются нулевые значения (например, 10.0.0.1), поэтому для них шаблон нужно чуть-чуть изменить:

([0-9]|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])

Шаблон четвёртого байта зависит от контекста поиска. Если вам нужны только IP-адреса хостов, то совпадение с одиночным символом "0" должно быть исключено, и шаблон будет таким же, как для самого первого байта. Если требуются ещё и адреса сетей (подсетей), то можно воспользоваться шаблоном для второго и третьего байтов адреса.

Осталось придать нашему шаблону поиска завершённый вид, который в Perl-скрипте может быть, например, таким:

#!/usr/bin/perl -w
open( IN, "./filename.txt" );
while( <IN> )
{
  $ip_addr = <IN>;
  chomp($ip_addr);
  if( $ip_addr =~ /\/[1-9]|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]\/\.
                   \/[0-9]|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]\/\.
                   \/[0-9]|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]\/\.
                   \/[1-9]|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]\// )
  {
    print "Найден IP-адрес в строке:\n $ip_addr\n";
  }
}
close(IN);

Замечание. В Perl и шаблон регулярного выражения, и варианты в конструкции дизъюнкции записываются между парными символами "слэш" (/). Из-за этого слэши, ограничивающие варианты дизъюнкции, требуют предваряющих экранирующих символов "обратный слэш" (\). Конечно, подобная запись шаблона выглядит жутковато, но зато работает правильно.

2.2. Работа с данными, разделёнными запятыми

Многие системы управления базами данных и электронные таблицы поддерживают вывод в виде списков полей, разделённых запятыми, в качестве стандартного формата обмена данными. Этот формат обозначается аббревиатурой CSV (Comma-Separated Values – значения, разделённые запятой). На первый взгляд, решение задачи распределения таких данных по переменным с помощью Perl выглядит достаточно простым: использовать функцию split /,/ из набора штатных средств. Но внутри полей данных могут содержаться собственные запятые (в символьных строках или в числовых значениях денежных сумм в российских рублях). Что получится в результате обработки функцией split /,/ такой, например, строки данных: "Иванов", "инженер, расчётчик-математик", "4356,50 руб." ?

Чтобы обойти все эти "подводные камни", можно написать специализированную процедуру:

sub csv_parse
{
  my $str_txt = shift;    # присваивается первый элемент массива @_
  my @fields = ();        # массив для сохранения выделенных полей

  # Запись в цикле в массив значения переменной $+ - фрагмента строки,
  # для которого обнаружено соответствие шаблону в процессе самой
  # последней операции поиска (последняя обработанная пара круглых
  # скобок внутри тела шаблона поиска)
  push( @fields, $+ ) while $str_txt =~ m{
                 "([^\"\\]*(?:\\.[^\"\\]*)*)",? |
                 ([^,]+),? | , }gx;
  # Если самый последний символ в исходной строке - запятая,
  # то список полей завершается "неопределённым значением" undef
  push( @fields, undef ) if substr( $str_txt, -1, 1 ) eq ',';
  # вернуть список значений, размещённых в отдельных полях
  return @fields;
}

В приведённой выше процедуре первая часть шаблона позволяет выделить фрагмент исходной строки, заключённый в кавычки и ограниченный первой запятой, найденной вне этой пары кавычек. Внутри кавычек могут встречаться любые символы, в том числе и запятые. Вторая часть шаблона соответствует фрагменту без кавычек до первой следующей за ним запятой. Такой фрагмент тоже сохраняется в массиве fields. Последняя часть шаблона – запятая – завершает очередную итерацию цикла. Ключ g после шаблона означает его глобальное действие, т.е. запись в массив всех найденных фрагментов, а не только первого совпадающего. Ключ x позволяет игнорировать все "пробельные символы" в шаблоне (имеются в виду литеральные пробелы, а не метасимволы \s и escape-последовательности). Это немного облегчает чтение шаблона – можно вставить пробелы между символами дизъюнкции (вертикальная черта – разделитель вариантов).

2.3. Небольшие примеры использования Perl для поиска в тексте из командной строки

Нередко встречаются задачи поиска образцов, в условиях которых определено, что надо найти "образец1 И образец2 И образец3". Средства из группы grep легко справляются с задачами поиска одного из вариантов шаблона (образец1|образец2|образец3), но для предложенной задачи потребуется конвейер или другие ухищрения. С помощью Perl подобные задачи решаются "в одно действие":

perl -ne 'print if /рубль/ && /доллар/ && /евро/' список_файлов

Здесь ключ e позволяет определить строку выполняемых команд, а ключ n заставляет интерпретатор Perl считать, что заданная последовательность команд заключена в цикл while(<>), т.е. будет выполняться для всех строк перечисленных файлов.

В тех случаях, когда нужно найти абзацы, в которых встречаются все три указанных слова, поможет режим работы с абзацами. Для Perl этот режим активизируется ключом -00:

perl -n00e 'print "$_\n" if /рубль/ && /доллар/ && /евро/' список_файлов

А если необходимо вывести список файлов, которые содержат все три слова, то для ключа -0 надо установить такой разделитель записей, который не содержится в обычных текстовых файлах, например, NUL-символ:

perl -ln0e 'print $ARGV if /рубль/ && /доллар/ && /евро/' список_файлов

В общем, не спешите "хоронить" Perl – он ещё способен на многое, особенно там, где требуется интенсивная работа с регулярными выражениями.

3. Примеры использования регулярных выражений в Python

Диалект регулярных выражений языка Python довольно-таки близок к диалекту текстового редактора Emacs. Тем не менее в Python синтаксис записи регулярных выражений можно динамически корректировать в любой момент времени. Если вы устали от огромного количества обратных слэшей (те, кто пользовался регулярными выражениями в Emacs, сразу поймёт, что я имею в виду), то можете от них избавиться:

re.set_syntax( RE_NO_BK_PARENS | RE_NO_BK_VBAR )

Первый устанавливаемый флаг говорит о том, что для группирования в шаблонах должны использоваться неэкранированные скобки, а второй флаг – о том, что в конструкции дизъюнкции (выбора варианта) – неэкранированная вертикальная черта. Скорректированные таким образом конструкции будут читаться гораздо легче.

В Python механизм регулярных выражений подключается с помощью модуля re. Поскольку Python по своей сущности является объектно-ориентированным языком, то это в полной мере относится и к его диалекту регулярных выражений. При необходимости создаётся объект типа "регулярное выражение", который в дальнейшем вы можете применять к строкам для выполнения поиска или замены. Рассмотрим следующий фрагмент кода:

undsc_regex = re.compile( '\s+(_.+_)\s+' )
...
result_text = undsc_regex.sub( '<u>\\1</u>', input_text )

В первой строке фрагмента создаётся объект-шаблон, соответствующий любой последовательности символов в тексте, начинающейся и заканчивающейся символами подчёркивания (например: "здесь _важно_ отметить"). После создания этот объект можно применять к любым строкам, используя его методы поиска и замены. В данном случае применяется метод замены sub(), который принимает в качестве аргументов строку замены и обрабатываемый текст input_text. Обратите внимание на элемент \1, обозначающий найденный фрагмент и соответствующий той части шаблона, которая заключена в круглые скобки. В отличие от Perl, обозначение \1 включается и в строку замены. В результате обработки текст (сохраняемый в result_text) будет заключён в HTML-тэги "подчёркнутый текст", например: "здесь <u>важно</u> отметить".

А вот как решается проблема с повторяющимися словами-опечатками ("не не", "для для" и т.д.) на языке Python:

#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
import re

# Потребуются три объекта типа "регулярное выражение"
RegEx1 = re.compile( '\b(\w+)((\s|<[^>]+>)+)(\\1\b)' )
RegEx2 = re.compile( '^([^\033]*\n)+' )
RegEx3 = re.compile( '^(.)' )

# Обработка всех файлов, имена которых заданы в командной строке
for filename in sys.argv[1]:
  try:
    fd = sys.open( filename )
  except:
    raise 'Ошибка при попытке открыть файл'
    continue

  # Считать содержимое файла, обработать с помощью трёх подготовленных
  # регулярных выражений и вывести найденные совпадения
  txt_data = fd.read()
  txt_data = RegEx1.gsub( '\033[7m\\1\033[m\\2\033[7m\\4\033[m', txt_data )
  txt_data = RegEx2.gsub( '', txt_data )
  txt_data = RegEx3.gsub( filename + ': \\1', txt_data )
  print txt_data

В этой программе все обнаруженные повторения-опечатки выводятся на стандартное устройство с указанием имени файла, в котором они были найдены, и выделяются подсветкой при помощи esc-последовательностей (символ ESC \033).

4. Примеры использования регулярных выражений в Tcl

В Tcl для работы с регулярными выражениями имеются две функции: regexp – для поиска и regsub – для поиска с заменой и созданием копии исходной строки. Синтаксис вызова функции regexp:

regexp [ключи] регулярное_выражение строка_поиска [строка_приёмник ... ]

Если совпадение с регулярным выражением найдено в строке поиска, то функция возвращает 1, в противном случае – 0. В строку-приёмник (если она задана) копируется совпавший фрагмент. Если заданы имена нескольких строк-приёмников, то им последовательно присваиваются фрагменты, совпавшие с элементами шаблона в круглых скобках, а тем, кому "не хватило" совпадений, присваиваются пустые строки. Если не обнаружено ни одного совпадения с регулярным выражением, то строки-приёмники не изменяются.

Предположим, что имеется файл с записями автомобильных номерных знаков и фамилиями владельцев соответствующих автомобилей. Поиск на языке Tcl может быть записан следующим образом:

if [regexp -nocase {^([А-Я]666[А-Я][А-Я][0-9][0-9]) (.+)} $str_txt {} num owner]
{
  puts "$num $owner"
}

В этом примере будут найдены все владельцы автомобилей с "числом зверя" в номере вне зависимости от регистра букв, которыми записан номерной знак (ключ -nocase). Весь совпавший фрагмент не будет сохранён, так как на первом месте в списке строк-приёмников стоит пара фигурных скобок {}, а не имя переменной. Первый фрагмент в скобках (номерной знак) запоминается в переменной num, второй фрагмент в скобках (фамилия владельца) – в переменной owner. Затем значения этих переменных выводятся.

Функция regsub работает аналогично функции regexp:

regsub [ключи] регулярное_выражение строка_поиска строка_замены строка_приёмник

Отличие состоит лишь в том, что после строки поиска записывается строка замены, а строка-приёмник может быть задана только одна.

5. Примеры использования регулярных выражений в sed

Потоковый редактор sed используется главным образом для выполнения массовых замен в текстовых файлах, обрабатываемых построчно. Всем, кто хотя бы немного знаком с sed, известна классическая команда удаления всех пустых строк в обрабатываемом файле:

sed '/^$/d' filename

Эту операцию можно усовершенствовать таким образом, чтобы удалялись не только пустые строки, но и строки, содержащие только символы пробелов и табуляций:

sed '/^[ TAB]*$/d' filename

Здесь под обозначением TAB подразумевается "настоящий", литеральный символ табуляции (генерируемый при нажатии клавиши Tab на клавиатуре).

Если в тексте слишком много последовательностей пробелов, в которых нет необходимости, то замена таких цепочек пробелов на один символ пробела осуществляется следующей командой:

sed '  */ /g' filename

Ключ g в конце регулярного выражения сообщает о необходимости выполнения команды глобально, т.е. для всех найденных совпадений, поскольку по умолчанию sed ограничивается только первым найденным совпадением.

Если же, напротив, в начале каждой не пустой строки требуется вставка, например, пары пробелов, то можно воспользоваться функцией логического отрицания:

sed '/^$/!s/^/  /g' filename

6. Заключение

Сколько ни говори о регулярных выражениях, всех секретов не раскроешь, обо всех тонкостях не расскажешь. Но даже по тем, далеко не самых сложным примерам, которые я описал в этом цикле статей, можно понять, насколько мощным и гибким инструментом обработки данных являются регулярные выражения. Их можно изучать и совершенствовать бесконечно, делая всё новые открытия и изобретая, казалось бы, немыслимые способы их практического применения.

Напомню, что в первой статье цикла было дано общее представление о регулярных выражениях и областях их использования, приведен краткий обзор различных диалектов, представлены примеры составления регулярных выражений. В данной статье, завершающей цикл, рассматривалась практическая работа в конкретных программах и языковых средах.


Ресурсы для скачивания


Комментарии

Войдите или зарегистрируйтесь для того чтобы оставлять комментарии или подписаться на них.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=40
Zone=Linux
ArticleID=494958
ArticleTitle=Секреты регулярных выражений (regular expressions): Часть 2. Регулярные выражения в конкретных программах
publish-date=06082010