Очаровательный Python: текстовая обработка в языке Python

Дэвид Мерц

Python - это свободно доступный, интерпретируемый язык очень высокого уровня, разработанный Гвидо ван Россумом. Он объединяет ясный синтаксис с мощной (но необязательной) объектно-ориентированной семантикой. Python широко распространен и высокопортабелен.

Строки -- неизменяемые последовательности

Как и в большинстве высокоуровневых языков программирования, строки переменной длины являются базовым типом в языке Python. Python выделяет область памяти для хранения строк (или других значений) "за кулисами", там, где программисту не нужно особенно задумываться об этом. Кроме того, Python имеет несколько возможностей управления строками, отсутствующих в других высокоуровневых языках.

В языке Python строки представляют собой "неизменяемые последовательности" ("immutable sequences"). Программа может обращаться к элементам или подпоследовательностям строк как к любым последовательностям, несмотря на то, что строки, как и кортежи (tuples), не могут быть изменены непосредственно "на месте". Python обращается к подпоследовательностям с помощью гибкой операции "среза", формат которой напоминает задание диапазона строк и столбцов в электронной таблице. Приведенная ниже интерактивная сессия иллюстрирует использование строк и срезов.

Строки и срезы

>>> s = "mary had a little lamb"
>>> s[0]          # index is zero-based

                                'm'
>>> s[3] = 
'x'
                                # changing element in-place fails
Traceback (innermost last):
  File "<stdin>"
, line 1, 
                                    in

                                 ?
TypeError: object doesn't support item assignment
>>> s[11:18]      # 'slice' a subsequence

                                'little '
>>> s[:4]         # empty slice-begin assumes zero

                                'mary'
>>> s[4]          # index 4 is not included in slice [:4]

                                ' '
>>> s[5:-5]       # can use "from end" index with negatives

                                'had a little'
>>> s[:5]+s[5:]   # slice-begin & slice-end are complimentary

                                'mary had a little lamb'

Другая многозначительная строковая операция - просто ключевое слово in. Оно предлагает две интуитивные и полезные конструкции:

Ключевое слово "in"

>>> s = "mary had a little lamb"
>>> 
                                    for
                                 c 
                                    in
                                 s[11:18]: 
                                    print
                                 c,  # print each char in slice
...
l i t t l e
>>> 
                                    if
                                
                                'x'
                                
                                    in
                                 s: 
                                    print
                                
                                'got x'
                                # test for char occurrence
...
>>> 
                                    if
                                
                                'y'
                                
                                    in
                                 s: 
                                    print
                                
                                'got y'
                                # test for char occurrence
...
got y

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

Использование тройных кавычек

>>> s2 = """Mary had a little lamb
... its fleece was white as snow
... and everywhere that Mary went
... the lamb was sure to go"""
>>> 
                                    print
                                 s2
Mary had a little lamb
its fleece was white as snow

                                    and
                                 everywhere that Mary went
the lamb was sure to go

Как одинарные, так и тройные кавычки могут предваряться буквой "r" для обозначения того, что специальные символы регулярных выражений не должны интерпретироваться Python. Например:

Использование "r-строк"

>>> s3 = "this \n and \n that"
>>> 
                                    print
                                 s3
this
 
                                    and

                                 that
>>> s4 = r"this \n and \n that"
>>> 
                                    print
                                 s4
this \n 
                                    and
                                 \n that

В "r-строках" обратный слэш, который в иных случаях может служить для задания специального символа, обрабатывается как обычный обратный слэш. Это объясняется далее при рассмотрении регулярных выражений.

Файлы и строковые переменные

Когда мы говорим "текстовая обработка", мы обычно подразумеваем обработку содержимого файла. На языке Python не составляет труда считать содержимое текстового файла в строковые переменные, где этим содержимым можно манипулировать. Файловые объекты обеспечивают три метода чтения: .read(), .readline(), and .readlines(). Каждый из этих методов может принимать аргумент для ограничения объема данных, считываемых за один раз, однако в основном они используются без аргумента. .read() считывает весь файл за один раз, и обычно используется для помещения содержимого файла в строковую переменную. Хотя .read() дает наиболее прямое строковое представление содержимого файла, он неудобен для последовательной строчно-ориентированной обработки файла, к тому же это невозможно, если размер файла превышает объем имеющейся памяти.

..readline() и .readlines() очень похожи. И та и другая используются в конструкциях наподобие следующей:

 fh = open('c:\\autoexec.bat')
for
 line 
in fh.readlines():
print
 line

Различие между .readline() и .readlines() в том, что последняя, как и .read(), считывает весь файл за один раз. .readlines() автоматически парсит содержимое файла в список строк, который может быть обработан с помощью конструкции языка Python for ... in .... С другой стороны, .readline() считывает только одну строку за раз, и в целом работает гораздо медленнее, чем .readlines(). .readline() следует использовать, только если памяти не хватает для считывания всего файла за один раз.

Если вы используете стандартный модуль, работающий с файлами, вы можете превратить строку в "виртуальный файл" с помощью модуля cStringIO (если требуется создание производных классов, можно использовать StringIO, но начинающим это требуется редко). Например:

cStringIO-модуль

>>> 
                                    import

                                 cStringIO
>>> fh = cStringIO.StringIO()
>>> fh.write("mary had a little lamb")
>>> fh.getvalue()
'mary had a little lamb'
>>> fh.seek(5)
>>> fh.write('ATE')
>>> fh.getvalue()
'mary ATE a little lamb'

Не забывайте, однако, что, в отличие от настоящего файла, "виртуальный файл", сформированный cStringIO - временный. Он исчезнет, когда программа завершится, если вы не предпримете каких-либо шагов, чтобы его сохранить (например, запишете его в реальный файл или воспользуетесь модулем shelve либо базой данных).

Стандартный модуль: string

Модуль string, возможно, в целом наиболее полезный модуль стандартных дистрибутивов языка Python 1.5.. На самом деле похоже, что многие из возможностей модуля string будут существовать в качестве встроенных строковых методов в Python 1.6 и выше (подробности еще не были опубликованы на момент написания этой статьи). Наиболее вероятно, что любая программа, выполняющая обработку текста, должна начинаться со строки:

import string

Основное правило состоит в том, что если вы можете решить задачу с помощью модуля string, это правильный способ ее решения. В отличие от re (регулярных выражений), функции string в целом гораздо быстрее и в большинстве случаев проще для понимания и использования. Сторонние модули языка Python, включая и некоторые быстрые, написанные на С расширения, предназначены для специализированных задач, однако переносимость и простота, тем не менее, определяют привязку к string везде, где только возможно. Есть и исключения, однако не так много, как вы можете подумать, имея опыт использования других языков.

Модуль string содержит несколько типов инструментов, таких как функции, методы и классы. Он также содержит наиболее общие строковые константы. Например:

Пример 1 использования string

>>> 
                                    import

                                 string
>>> string.whitespace
'\011\012\013\014\015 '
>>> string.uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

Хотя вы можете написать эти константы сами, версии string более или менее гарантируют, что ваши константы будут правильны с точки зрения национального языка и платформы, на которой выполняется ваш скрипт на Python.

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

Пример 2 использования string

>>> 
                                    import
                                 string
>>> s = "mary had a little lamb"
>>> string.capwords(s)
'Mary Had A Little Lamb'
>>> string.replace(s, 
'little'
, 
'ferocious')
'mary had a ferocious lamb'

Существут множество других преобразований, не проиллюстрированных здесь ; вы можете найти подробности в руководстве по языку Python.

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

Пример 3 использования string

>>> 
                                    import
                                 string
>>> s = "mary had a little lamb"
>>> string.find(s, 
'had')
5
>>> string.count(s, 'a')
4

И наконец, string предоставляет очень характерную для языка Python особенность. Пара .split() и .join() обеспечивает быстрый способ преобразования строк в кортежи и наоборот, что вы найдете весьма полезным. Реализуется это просто:

Пример 4 использования string

>>> 
                                    import
                                 string
>>> s = "mary had a little lamb"
>>> L = string.split(s)
>>> L
['mary'
, 
'had'
, 
'a'
, 
'little'
, 
'lamb']
>>> string.join(L, "-")
'mary-had-a-little-lamb'

Безусловно, в реальной жизни вы скорее всего будете делать со списком что-то еще, кроме немедленного объединения его вызовом .join() (возможно, что-то, включающее знакомую конструкцию for...in...).

Стандартный модуль: re

Mодуль re делает устаревшими модули regex и regsub, которые использовались в старых кодах на языке Python. Хотя в использовании regex сохраняются небольшие преимущества, они незначительны и не стоят того, чтобы использовать его в в новом коде. Устаревшие модули скорее всего будут исключены из новых версий Python, и в 1.6, возможно, будет включен усовершенствованный модуль re. Так что пользуйтесь re для регулярных выражений.

Регулярные выражения сложны. Можно написать книгу на эту тему, и это на самом деле многие сделали! Эта статья постарается ухватить "гештальт" (базовую суть) регулярных выражений и позволит читателю извлечь ее.

Регулярное выражение - это краткий путь к описанию образцов (pattern), которые могут встретиться в тексте. Встречаются ли некие символы? В определенном ли порядке? Повторяются ли участки текста данное число раз? Исключено ли совпадение других участков? Концептуально это не так уж непохоже на то, как вы интуитивно описываете понятие образца на естественном языке. Хитрость состоит в кодировке этого описания в компактный синтаксис регулярных выражений.

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

Начните с самых маленьких фрагментов. На нижнем уровне любое регулярное выражение будет включать сопоставление с конкретными "символьными классами" ("character classes"). Простейший символьный класс представляет собой отдельный символ, который просто входит в образец как литерал. Вам часто может понадобиться сопоставить класс символов. Вы можете обозначить класс, заключив его в квадратные скобки; внутри скобок вы можете поместить как набор, так и диапазоны символов, которые обозначаются тире. Кроме того, вы можете использовать различные именованные символьные классы, корректные для вашей платформы и национального языка. Несколько примеров:

Cимвольные классы

>>> 
                                    import
                                 re
>>> s = "mary had a little lamb"
>>> 
                                    if
                                 re.search(
"m"
, s): 
                                    print
                                
                                "Match!"
                                # char literal
...
Match!
>>> 
                                    if
                                 re.search(
"[@A-Z]"
, s): 
                                    print
                                
                                "Match!"
                                # char class
...     # match either at-sign or capital letter
...
>>> 
                                    if
                                 re.search(
"\d"
, s): 
                                    print
                                
                                "Match!"
                                # digits class
...

Вы можете представлять символьные классы в виде "атомов" регулярных выражений и скорее всего захотите сгруппировать эти атомы в "молекулы". Это можно сделать с помощью комбинации группировки и повторения. Группировка обозначается круглыми скобками: каждое из подвыражений, содержащихся в скобках, рассматривается как атомарное для последующей группировки или повторения. Повторение отмечается одним из следующих операторов: "*" означающего "нуль или более"; "+" означающего "один или более"; "?" означающего "нуль или один". В качестве примера взгляните на выражение:

ABC([d-w]*\d\d?)+XYZ

Чтобы строка соответствовала этому выражению, она должна содержать нечто, начинающееся с "ABC" и заканчивающееся на "XYZ" -- но что должно быть в середине? Средним подвыражением является ([d-w]*\d\d?), сопровождаемое оператором "один или много". Таким образом, середина строки должна состоять из одного (или двух, или одной тысячи) фрагментов, соответствующих подвыражению в скобках. Строка "ABCXYZ" ему не соответствует, так как не содержит необходимых элементов в середине.

Что же представляет собой это внутреннее подвыражение? Оно начинается с нуля или более букв в интервале от d до w. Важно отметить, что нуль букв представляет правильное сопоставление, которое может быть контринтуитивным, если вы воспользуетесь для его описания словом "несколько". В следующей строке должна быть в точности одна цифра; затем ни одной или одна дополнительная цифра. (Первый цифровой символьный класс не имеет оператора повторения, тем самым просто встречается один раз. Второй цифровой символьный класс имеет оператор "?"). Короче говоря, все это подразумевает "одну или несколько цифр". Некоторые удовлетворяющие регулярному выражению строки выглядят так:

ABC1234567890XYZ
ABCd12e1f37g3XYZ
ABC1XYZ

А вот несколько выражений, которые не сопоставляются c этим выражением:

ABC123456789dXYZ
ABCdefghijklmnopqrstuvwXYZ
ABcd12e1f37g3XYZ
ABC12345%67890XYZ
ABCD12E1F37G3XYZ

Потребуется некоторая практика, чтобы научиться созданию и пониманию регулярных выражений. Однако как только вы освоите регулярные выражения, в вашем распоряжении окажется мощная выразительная сила. Все это говорит о том, что часто проще использовать регулярные выражения для решения проблемы, которая вполне может быть решена и с помощью более примитивных (и быстрых) инструментов, например модуля string.

Очаровательный Python: текстовая обработка в языке Python (исходники)