Использование Regex для обработки текста в Python

Введение Предварительная обработка текста - одна из наиболее важных задач в обработке естественного языка [/ what-is-natural-language-processing /] (НЛП). Например, вы можете удалить все знаки препинания из текстовых документов, прежде чем их можно будет использовать для классификации текста. Точно так же вы можете извлечь числа из текстовой строки. Написание ручных сценариев для таких задач предварительной обработки требует больших усилий и подвержено ошибкам. Принимая во внимание важность этих задач предварительной обработки, t

Вступление

Предварительная обработка текста - одна из самых важных задач в обработке естественного языка (NLP). Например, вы можете удалить все знаки препинания из текстовых документов, прежде чем их можно будет использовать для классификации текста. Точно так же вы можете извлечь числа из текстовой строки. Написание ручных сценариев для таких задач предварительной обработки требует больших усилий и подвержено ошибкам. Принимая во внимание важность этих задач предварительной обработки, регулярные выражения (также известные как Regex) были разработаны на разных языках, чтобы упростить эти задачи предварительной обработки текста.

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

Для реализации регулярных выражений можно использовать пакет re Импортируйте re с помощью следующей команды:

 import re 

Поиск шаблонов в строке

Одна из наиболее распространенных задач НЛП - поиск, содержит ли строка определенный шаблон или нет. Например, вы можете захотеть выполнить операцию со строкой при условии, что строка содержит число.

Для поиска шаблона в строке findall функция match и findall пакета re

Функция соответствия

Инициализируйте переменный text текстовой строкой следующим образом:

 text = "The film Titanic was released in 1998" 

Напишем регулярное выражение, которое соответствует строке любой длины и любого символа:

 result = re.match(r".*", text) 

Первый параметр match - это выражение регулярного выражения, которое вы хотите найти. Выражение регулярного выражения начинается с алфавита r за которым следует шаблон, который вы хотите найти. Шаблон следует заключать в одинарные или двойные кавычки, как и любую другую строку.

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

 type(result) 

Выход:

 _sre.SRE_Match 

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

 result.group(0) 

Выход:

 'The film Titanic was released in 1998' 

В случае, если функция match null объект.

Теперь предыдущее выражение регулярного выражения соответствует строке любой длины и любого символа. Он также будет соответствовать пустой строке нулевой длины. Чтобы проверить это, обновите значение текстовой переменной пустой строкой:

 text = "" 

Теперь, если вы снова выполните следующее выражение регулярного выражения, совпадение будет найдено:

 result = re.match(r".*", text) 

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

Чтобы сопоставить строку длиной не менее 1, используется следующее выражение регулярного выражения:

 result = re.match(r".+", text) 

Здесь знак плюса указывает, что в строке должен быть хотя бы один символ.

Поисковые алфавиты

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

 text = "The film Titanic was released in 1998" 

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

 result = re.match(r"[a-zA-z]+", text) 

В этом регулярном выражении указано, что текстовая строка соответствует любым алфавитам от маленького a до малого z или заглавной A до заглавной Z Знак плюс указывает, что в строке должен быть хотя бы один символ. Напечатаем совпадение, найденное по приведенному выше выражению:

 print(result.group(0)) 

Выход:

 The 

В выходных данных вы можете видеть, что возвращается The Это связано с тем, что match возвращает только первое найденное совпадение. В регулярном выражении мы указали, что находят шаблоны с маленькими и прописными буквами от a до z . Первым найденным совпадением был The . После слова The идет пробел, который не рассматривается как буква алфавита, поэтому сопоставление остановлено, и выражение вернуло только The , которое является первым совпадением.

Однако с этим есть проблема. Если строка начинается с числа, а не с алфавита, match вернет null, даже если после числа есть алфавиты. Давайте посмотрим на это в действии:

 text = "1998 was the year when the film titanic was released" 
 result = re.match(r"[a-zA-z]+", text) 
 type(result) 

Выход:

 NoneType 

В приведенном выше скрипте мы обновили текстовую переменную, и теперь она начинается с цифры. Затем мы использовали match для поиска алфавитов в строке. Хотя текстовая строка содержит алфавиты, будет возвращено значение null, поскольку match только первому элементу в строке.

Чтобы решить эту проблему, мы можем использовать функцию search

Функция поиска

Функция search похожа на match т. Е. Пытается сопоставить указанный шаблон. Однако, в отличие от match , она соответствует шаблону глобально, а не только первому элементу. Следовательно, search вернет совпадение, даже если строка не содержит алфавита в начале строки, но содержит алфавит в другом месте строки, как показано ниже:

 text = "1998 was the year when the film titanic was released" 
 result = re.search(r"[a-zA-z]+", text) 
 print(result.group(0)) 

Выход:

 was 

Функция search возвращает «было», поскольку это первое совпадение, найденное в текстовой строке.

Соответствующая строка с самого начала

Чтобы проверить, начинается ли строка с определенного слова, вы можете использовать ключ-пряник, т.е. ^ за которым следует слово, которое соответствует search как показано ниже. Предположим, у нас есть следующая строка:

 text = "XYZ 1998 was the year when the film titanic was released" 

Если мы хотим узнать, начинается ли строка с «1998», мы можем использовать search следующим образом:

 result = re.search(r"^1998", text) 
 type(result) 

На выходе null , поскольку текстовая строка не содержит «1998» непосредственно в начале.

Теперь давайте изменим текстовую переменную содержимого и добавим «1998» в начало, а затем проверим, находится ли «1998» в начале или нет. Выполните следующий скрипт:

 text = "1998 was the year when the film titanic was released" 
 if re.search(r"^1998", text): 
 print("Match found") 
 else: 
 print("Match not found") 

Выход:

 Match found 

Соответствующие строки с конца

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

 text = "1998 was the year when the film titanic was released" 
 if re.search(r"1998$", text): 
 print("Match found") 
 else: 
 print("Match not found") 

В приведенном выше сценарии мы попытались определить, заканчивается ли текстовая строка на «1998», что не соответствует действительности.

Выход:

 Match not found 

Теперь, если мы обновим строку и добавим «1998» в конец текстовой строки, приведенный выше сценарий вернет «Соответствие найдено», как показано ниже:

 text = "was the year when the film titanic was released 1998" 
 if re.search(r"1998$", text): 
 print("Match found") 
 else: 
 print("Match not found") 

Выход:

 Match found 

Подстановка текста в строку

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

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

 text = "The film Pulp Fiction was released in year 1994" 

Чтобы заменить строку «Криминальное чтиво» на «Форрест Гамп» (другой фильм, выпущенный в 1994 году), мы можем использовать sub следующим образом:

 result = re.sub(r"Pulp Fiction", "Forrest Gump", text) 

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

Если вы напечатаете переменную результата, вы увидите новую строку.

Теперь давайте заменим все алфавиты в нашей строке на символ «X». Выполните следующий скрипт:

 text = "The film Pulp Fiction was released in year 1994" 
 result = re.sub(r"[az]", "X", text) 
 print(result) 

Выход:

 TXX XXXX PXXX FXXXXXX XXX XXXXXXXX XX XXXX 1994 

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

 result = re.sub(r"[a-zA-Z]", "X", text) 

Или вы можете передать дополнительные flags параметров подфункции и установить для нее значение re.I которое относится к нечувствительности к регистру, следующим образом:

 result = re.sub(r"[az]", "X", text, flags=re.I) 

Более подробную информацию о различных типах флагов можно найти на странице официальной документации Python regex.

Сокращенные классы символов

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

Удаление цифр из строки

Выражение регулярного выражения для поиска цифр в строке - \d . Этот шаблон можно использовать для удаления цифр из строки, заменив их пустой строкой нулевой длины, как показано ниже:

 text = "The film Pulp Fiction was released in year 1994" 
 result = re.sub(r"\d", "", text) 
 print(result) 

Выход:

 The film Pulp Fiction was released in year 

Удаление букв алфавита из строки

 text = "The film Pulp Fiction was released in year 1994" 
 result = re.sub(r"[az]", "", text, flags=re.I) 
 print(result) 

Выход:

 1994 

Удаление символов слова

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

 text = "The film, '@Pulp Fiction' was ? released in % $ year 1994." 
 result = re.sub(r"\w","", text, flags = re.I) 
 print(result) 

Выход:

 , '@ ' ? % $ . 

Выходные данные показывают, что все числа и алфавиты были удалены.

Удаление символов, отличных от слов

Чтобы удалить все символы, не являющиеся словами, \W можно использовать следующим образом:

 text = "The film, '@Pulp Fiction' was ? released in % $ year 1994." 
 result = re.sub(r"\W", "", text, flags=re.I) 
 print(result) 

Выход:

 ThefilmPulpFictionwasreleasedinyear1994 

Из вывода вы можете видеть, что все было удалено (даже пробелы), кроме чисел и алфавитов.

Группировка нескольких паттернов

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

 text = "The film, '@Pulp Fiction' was ? released _ in % $ year 1994." 
 result = re.sub(r"[,@\'?\.$%_]", "", text, flags=re.I) 
 print(result) 

Выход:

 The film Pulp Fiction was released in year 1994 

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

Удаление нескольких пробелов

Иногда в результате удаления слов или знаков препинания между словами появляется несколько пробелов. Например, в выводе последнего примера есть несколько пробелов между in и year . Эти пробелы можно удалить с помощью \s , который относится к одному пробелу.

 text = "The film Pulp Fiction was released in year 1994." 
 result = re.sub(r"\s+"," ", text, flags = re.I) 
 print(result) 

Выход:

 The film Pulp Fiction was released in year 1994. 

В приведенном выше скрипте мы использовали выражение \s+ которое относится к одному или нескольким пробелам.

Удаление пробелов из начала и конца

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

 text = " The film Pulp Fiction was released in year 1994" 
 result = re.sub(r"^\s+", "", text) 
 print(result) 

Выход:

 The film Pulp Fiction was released in year 1994 

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

 text = "The film Pulp Fiction was released in year 1994 " 
 result = re.sub(r"\s+$", "", text) 
 print(result) 

Удаление одного символа

Иногда удаление знаков препинания, таких как апостроф, приводит к появлению одного символа, не имеющего значения. Например, если вы удалите апостроф из слова Jacob's и замените его пробелом, получится строка Jacob s . Здесь s не имеет смысла. Такие одиночные символы можно удалить с помощью регулярного выражения, как показано ниже:

 text = "The film Pulp Fiction s was b released in year 1994" 
 result = re.sub(r"\s+[a-zA-Z]\s+", " ", text) 
 print(result) 

Выход:

 The film Pulp Fiction was released in year 1994 

Скрипт заменяет любую строчную или заглавную букву между одним или несколькими пробелами на один пробел.

Разделение строки

Разделение строк - еще одна очень важная функция. Строки можно разделить с помощью split из пакета re. Функция split возвращает список токенов разделения. Давайте разделим строку слов с одним или несколькими пробелами, как показано ниже:

 text = "The film Pulp Fiction was released in year 1994 " 
 result = re.split(r"\s+", text) 
 print(result) 

Выход:

 ['The', 'film', 'Pulp', 'Fiction', 'was', 'released', 'in', 'year', '1994', ''] 

Точно так же вы можете использовать другие выражения регулярных выражений для разделения строки с помощью функций split Например, следующая split разделяет строку слов при нахождении запятой:

 text = "The film, Pulp Fiction, was released in year 1994" 
 result = re.split(r"\,", text) 
 print(result) 

Выход:

 ['The film', ' Pulp Fiction', ' was released in year 1994'] 

Поиск всех экземпляров

Функция match выполняет сопоставление первого элемента, в то время как search выполняет глобальный поиск по строке и возвращает первый сопоставленный экземпляр.

Например, если у нас есть следующая строка:

 text = "I want to buy a mobile between 200 and 400 euros" 

Мы хотим найти все цифры в этой строке. Если мы используем search , будет возвращено только первое вхождение цифр, то есть 200, как показано ниже:

 result = re.search(r"\d+", text) 
 print(result.group(0)) 

Выход:

 200 

С другой стороны, findall возвращает список, содержащий все совпадающие высказывания, как показано ниже:

 text = "I want to buy a mobile between 200 and 400 euros" 
 result = re.findall(r"\d+", text) 
 print(result) 

Выход:

 ['200', '400'] 

findall функция findall возвращает и «200», и «400».

Заключение

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

comments powered by Disqus