Шпаргалка по регулярным выражениям Python 2023 — Machine learning на vc.ru

669 просмотров

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

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

Примеры регулярных выражений Python

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

Поиск типа IP-адреса

Здесь мы напишем программу на Python, которая использует регулярное выражение для проверки того, является ли данный IP-адрес IPv4, IPv6 или нет.

(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.( 25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.( 25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.( 25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)$»’ ipv6 = »'(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}| ([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:) {1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1 ,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4} :){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{ 1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA -F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a -fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0 -9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0, 4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1} :){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9 ])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0 -9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4] |1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4] |1{0,1}[0-9]){0,1}[0-9]))»’ def find(Ip): if re.search(ipv4, Ip): print(«IPv4») elif re.search(ipv6, Ip): print(«IPv6») else: print(«None») # Driver Code if __name__ == ‘__main__’ : # Enter the Ip address Ip = «192.
168.0.100″ find(Ip)

Сохраните и закройте файл, затем запустите программу с помощью следующей команды:

python3 checkip.py

Если IP-адрес (192.168.0.100), указанный в приведённом выше коде, является IPv4, то вы должны получить следующий вывод:

Проверьте, зарезервирован ли указанный IPv4-адрес или нет

В этом примере мы проверим, зарезервирован ли данный IP-адрес или нет. Некоторые IP-адреса зарезервированы для экспериментальных и исследовательских целей. Диапазон IP–адресов 240.0.0.0 — 255.255.255.254 зарезервирован для исследовательских целей.

Давайте создадим новый файл, чтобы проверить зарезервированный IP-адрес:

nano checkreservedip.py

Добавьте следующий код:

from ipaddress import ip_address

def reservedIPAddress(IP: str) -> str: return «Reserved» if (ip_address(IP).is_reserved) else «Not Reserved» if __name__ == ‘__main__’ : # Not Reserved print(reservedIPAddress(‘192.168.0.123’)) # Reserved print(reservedIPAddress(‘240.

[0-9].)([1][0-9][0-9].|[2][5][0-5].|[2][0-4][0-9].|[1][0-9][0-9].|[0-9][0-9].|[0-9].)([1][0-9][0-9].|[2][5][0-5].|[2][0-4][0-9].|[1][0-9][0-9].|[0-9][0-9].|[0-9].)([1][0-9][0-9]|[2][5][0-5]|[2][0-4][0-9]|[1][0-9][0-9]|[0-9][0-9]|[0-9])$»,i) k = k + 1 if ip: print («\n=====================») print («Valid IP address») print («=====================») break else : print («\nInvalid IP») else : print («\nAllowed Max 5 times»)

Сохраните и закройте файл, затем запустите скрипт со следующей командой:

python3 test.py

Вас попросят указать любой IP-адрес, как показано ниже:

Enter Ip address: 192.168.0.111

Укажите любой IP-адрес и нажмите Enter. Вы получите следующий результат:

===================== Valid IP address =====================

Теперь верните этот скрипт и укажите недопустимый IP-адрес. Вы получите следующий результат:

Enter Ip address: 10.123.342.255

Недопустимый IP-адрес

Проверьте действительный адрес электронной почты

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

Давайте создадим файл test.py, используя следующую команду:

nano test.py

Добавьте следующий код:

import re input_string = input(«Enter Email address : «) regex_pattern = r’\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b’

result = bool( re.match( regex_pattern, input_string)) if (result): print («Valid Email address») else: print («Invalid Email address»)

Сохраните и закройте файл, затем запустите его с помощью следующей команды:

python3 test.py

Вас попросят указать адрес электронной почты, как показано ниже:

Enter Email address : [email protected]

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

Valid Email address

Вывод имени хоста и IP-адреса системы

В этом примере мы выведем IP-адрес и имя хоста вашей системы.

Давайте создадим файл test.py, используя следующую команду:

nano test. py

Добавьте следующий код:

import socket hostname = socket.gethostname() IPAddr = socket.gethostbyname(hostname) print(«Your System Hostname is:» + hostname) print(«Your System IP Address is:» + IPAddr)

Сохраните и закройте файл, затем запустите этот скрипт со следующей командой:

python3 test.py

Вы должны получить следующий результат:

Your System Hostname is:newpc

Ваш системный IP-адрес:127.0.0.1

Сканирование открытого порта на удалённом хосте

В этом примере мы просканируем удалённый хост и выведем все открытые порты.

Давайте создадим скрипт test.py на python, используя следующую команду:

nano test.py

Добавьте следующий код:

from socket import * import time startTime = time.time()

if __name__ == ‘__main__’: target = input(‘Enter the host to be scanned: ‘) t_IP = gethostbyname(target) print (‘Starting scan on host: ‘, t_IP) for i in range(50, 500): s = socket(AF_INET, SOCK_STREAM) conn = s.

connect_ex((t_IP, i)) if(conn == 0) : print (‘Port %d: OPEN’ % (i,)) s.close() print(‘Time taken:’, time.time() — startTime)

Сохраните и закройте файл, затем запустите приведённый выше скрипт со следующей командой:

python3 test.py

Вас попросят указать IP-адрес удалённого хоста, как показано ниже:

Enter the host to be scanned: 172.20.10.3

Укажите IP-адрес и нажмите Enter. Вы получите следующий результат:

Starting scan on host: 172.20.10.3 Port 80: OPEN Port 111: OPEN Port 139: OPEN Port 445: OPEN Time taken: 1.1808812618255615

Заключение

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

Статья была взята из этого источника:

Понять регулярные выражения в Python

Время прочтения: 5 мин.

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

В данной статье я постараюсь описать некоторый минимум, необходимый для понимания возможностей регулярных выражений, а также приведу примеры задач, для решения которых я использовал регулярные выражения. Использоваться будет библиотека Python 3.7 «re» и regex101.com, также, информация из статьи. Пример работы:

import re
text = '''
ИНН
.,
ИНН 1234567890
Инн2 - 9876543210
просто числа 1111111111
1377
'''
smf = re.search('\d{10}', text, re.M)
smf[0] if smf else 'Не найдено'

Результат: ‘1234567890’

Рассмотрим подробнее. После импорта библиотеки и создания переменной text была вызвана функция re.search(). Это одна из функций для реализации регулярных выражений в Python, принимает регулярку, ищет где нам нужно первое совпадение, флаг re.

M обозначает многострочный поиск и возвращает объект re.Match с найденными координатами или None. Регулярное выражение в данном случае позволяет найти 10 чисел, идущих подряд. «\d» — это обозначение для числа, {10} обозначает количество символов.

Отметим, что переменная text содержит в себе следующее:

\nИНН\n.,\nИНН 1234567890\nИнн2 - 9876543210\nпросто числа 1111111111\n1377\n

В Python re существуют следующие функции:

  • re.match(pattern, string, flags=0) ищет pattern в string с флагами flags, возвращает объекты match или None. Результаты можно получить как match.groups() и match.group(num=0).
  • re.search(pattern, string, flags=0) ищет pattern в string с флагами flags, возвращает первое совпадение как объект match или None.
  • re.findall(pattern, string, flags=0) ищет pattern в string с флагами flags, возвращает объекты список совпадений или пустой список.
  • re.sub(pattern, repl, string, max=0) ищет pattern в string и заменяет на repl, количество раз max, если оно указано. выполняет поиск в начале любой строки текста (не только в начале текста).
  • re.S — изменяет значение точки (.) на совпадение с любым символом, включая новую строку.
  • re.U— интерпретирует буквы в соответствии с набором символов Unicode. Этот флаг влияет на поведение \w, \W, \b, \B. В python 3+ этот флаг установлен по умолчанию.
  • re.X— позволяет многострочный синтаксис регулярного выражения. Он игнорирует пробелы внутри паттерна (за исключением пробелов внутри набора [] или при экранировании обратным слешем) и обрабатывает не экранированный “#” как комментарий.

Далее, приведена таблица с используемыми обозначениями и простыми примерами использования:

ОбозначениеОписаниеПример в нашей строке
.любой одиночный символ, кроме «\n»«И»
\символ для экранированиядля «\.» результат – «.»
\wлюбая буква, цифра или «_»«И»
\dлюбая цифра«1»
\sлюбой символ пробела, табуляции, перевода строки«\n»
\bдолжен определять границу для \w символов, но в Python 3. 0-9]» — не цифры
()обозначает группы«(ИНН (\d{10}))» вернёт две группы — ‘ИНН 9876543210’ и ‘9876543210’

В регулярных выражениях достаточно удобно реализованы логические отрицания, например, «\D» — это любой нецифровой символ. Аналогично и для других обозначений: «\W», «\S», «\B». Пару слов о «жадности» и «ленивости» регулярных выражений. По умолчанию, возвращается максимально длинное совпадение, например:

text = '"Рога", "Копыта" и "Ко"'
re.findall('".+"', text, re.M)

Результат: [‘»Рога», «Копыта» и «Ко»‘]

Мы хотели найти «всё внутри двойных кавычек». И нашли всё, что заключено в кавычки, как единое совпадение. Но если нужно каждое совпадение в отдельности, следует использовать «ленивый поиск»:

text = '"Рога", "Копыта" и "Ко"'
re.findall('".+?"', text, re.M)

Результат: [‘»Рога»‘, ‘»Копыта»‘, ‘»Ко»‘]

Добавив «?» к конструкции «».+»», то есть, составив выражение «».+?»» мы получили каждое минимальное совпадение с конструкцией «всё внутри двойных кавычек».

Далее – опережающие и ретроспективные проверки или же, lookahead/lookbehind. Эти конструкции позволяют реализовать поиск чего-то после и/или до определённых выражений. То есть, мы можем, не используя группы (круглые скобки), вытащить, например, что-то между кавычек:

text = '"Рога", "Копыта" и "Ко"'
re.findall('(?<=").+?(?=")', text, re.M)

Результат: [‘Рога’, ‘, ‘, ‘Копыта’, ‘ и ‘, ‘Ко’]

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

text = 'какие-то 146%, нужные проценты значение 54%, шелуха значение 987, ещё значение - 159%'
re.findall('(?<=значение).+?(\d+)(?=%)', text, re.M)

Результат: [’54’, ‘159’]

Разберём пример подробнее. Допустим, нам нужно найти в тексте число, которое следует после определённого слова (у нас – «значение»), при этом, между словом и числом может быть пробел, тире, что-то ещё, и после числа точно должен быть «%». Для понимания конструкции выше понадобится описание опережающих и ретроспективных проверок:

  • (?<=pattern) —  положительное look-behind условие;
  • (?<!pattern) — отрицательное look-behind условие;
  • (?=pattern) — положительное look-ahead условие;
  • (?!pattern) — отрицательное look-ahead условие.

Если вы подумали об указании множественных условий для таких проверок, что-то вроде, (?<=значение1|значение2) то спешу разочаровать, так как re говорит нам:

«error: look-behind requires fixed-width pattern»

И это печально. Следует учитывать, что некоторые особенности регулярок могут по-разному работать в разных реализациях, поэтому стоит «обкатывать» регулярки не только на regex101, но и в самом Python.

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

Учебники по программированию на Python


Во многих случаях программисту нужно разделить текст или что-то найти в нем. Скажем, вы ищете любые цены в тексте. По сути, вы ищете знак доллара ($), за которым следует как минимум 1 число, возможно, десятичная точка и, возможно, другие числа. Иногда перед любыми числами будет стоять десятичная точка, например, что-то меньше доллара. Попробуйте придумать способ, которым вы могли бы включить очень большое количество возможностей, это довольно сложно. Здесь на помощь приходят регулярные выражения.

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

В Python 3 используется модуль для использования регулярных выражений re, и для использования регулярных выражений его необходимо импортировать. Re является частью стандартной библиотеки, то есть вам не нужно ничего скачивать и устанавливать, чтобы использовать его, он уже есть.

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

Вы должны сообщить модулю регулярных выражений, что: НАЧНИТЕ со знака доллара. Затем вы либо ищете группу цифр, либо непосредственную точку/десятичную точку. Отсюда вы будете продолжать искать цифры, запятые и точки, пока, наконец, не достигнете конечной точки перед пробелом (указывающим на конец предложения, а не десятичную точку) или просто пробелом. Именно так вы будете структурировать настоящее регулярное выражение.

Для видео наша задача — найти имена и возраст людей. Код:

Вот краткая шпаргалка по различным правилам в регулярных выражениях:

Идентификаторы:

  • \d = любое число
  • \D = что угодно, кроме числа
  • \s = пробел
  • \S = что угодно, кроме пробела
  • \w = любая буква
  • \W = что угодно, кроме буквы
  • . = любой символ, кроме новой строки
    • 9= соответствует началу строки
  • | = соответствует или/или. Пример x|y = будет соответствовать либо x, либо y
  • [] = диапазон или «дисперсия»
  • {x} = ожидается увидеть это количество предыдущего кода.
  • {x,y} = ожидаем увидеть эти x-y суммы предшествующего кода

Белое пространство Диаграммы:

  • \n = новая строка
  • \s = пробел
  • \t = вкладка
  • \e = побег
  • \f = подача страницы 9( ) { } | \

Скобки:

  • [] = quant[ia]tative = будет найдено либо количественное, либо количественное.
  • [a-z] = вернуть любую строчную букву az
  • [1-5a-qA-Z] = вернуть все цифры 1-5, строчные буквы a-q и прописные A-Z

Код:

Итак, у нас есть строка, которую мы собираемся искать. Мы видим, что у нас есть возрасты, которые представляют собой целые числа длиной 2-3 числа. Мы также можем ожидать цифры, равные 1, младше 10 лет. Вероятно, мы не увидим никаких цифр длиной 4, если только мы не говорим о библейских временах или о чем-то подобном.

 импорт повторно
примерная строка = '''
Джессике 15 лет, а Даниэлю 27 лет.
Эдварду 97 лет, а его дедушке Оскару 102 года.
'''

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

 возраст = re.findall(r'\d{1,3}',exampleString)
имена = re.findall(r'[AZ][az]*',exampleString)
печать (возраст)
печать (имена)
Для этого урока существует 1 задание(я) . для доступа к ним, загрузки видео и отсутствия рекламы.

Для этого урока существует 1 тест/вопрос(ы) . для доступа к ним, загрузки видео и отсутствия рекламы.

Следующее руководство:


Python 3 Notes: Регулярные выражения

Python 3 Примечания

[ ГЛАВНАЯ | ЛИНГ 1330/2330]

Регулярные выражения

<< Предыдущее примечание           Следующее примечание >>

На этой странице: модуль re, re. findall(), re.sub(), re.compile(), re.search(), re.search().group().

Модуль ре

Итак, вы узнали все о регулярных выражениях и готовы использовать их в Python. Давайте приступим! Модуль re — это стандартная библиотека Python, которая обрабатывает все регулярные выражения. Как и любой другой модуль, вы начинаете с его импорта.
 
>>> импортировать повторно
>>>

Поиск всех совпадений в строке

Предположим, вы хотите найти все слова, начинающиеся с «wo», в этом очень коротком тексте ниже. Что вы хотите использовать, так это метод re.findall(). Он принимает два аргумента: (1) шаблон регулярного выражения и (2) целевую строку для поиска совпадений.
 
>>> wood = 'Сколько дерева мог бы забить сурок, если бы сурок мог
Чак Вуд?
>>> re.findall(r'wo\w+', wood) # r'. ..' для необработанной строки
['дерево', 'бы', 'сурок', 'сурок', 'дерево']
>>>
Прежде всего, обратите внимание, что регулярное выражение r’wo\w+’ записывается как необработанная строка , на что указывает префикс строки r’…’. Это связано с тем, что регулярные выражения, как вы уже знаете, используют обратную косую черту «\» в качестве собственного специального escape-символа, а без ‘r’ обратная косая черта интерпретируется как специальный escape-символ *Python*. По сути, на уровне строковых объектов Python «\» в «\w» следует интерпретировать как буквальный символ обратной косой черты, чтобы впоследствии его можно было интерпретировать как специальный escape-символ регулярного выражения, когда строка обрабатывается модулем re. Если все это звучит слишком сложно, просто не забудьте ВСЕГДА НАЧИВАТЬ ВАШЕ ОБЫЧНОЕ ВЫРАЖЕНИЕ С ПРЕФИКСОМ ‘r’.

Вернуться к re.findall(). Он возвращает все совпадающие части строки в виде списка. Если совпадений нет, он просто вернет пустой список:

 
>>> re. findall(r'o+', дерево)
['о', 'о', 'о', 'оо', 'оо', 'о', 'оо']
>>> re.findall(r'e+', дерево)
[]
Что делать, если вы хотите игнорировать регистр в своих совпадениях? Вы можете указать его как третий необязательный аргумент: re.IGNORECASE.
 
>>> foo = 'Это и то и это'
>>> re.findall(r'th\w+', foo)
['что те']
>>> re.findall(r'th\w+', foo, re.IGNORECASE) # регистр игнорируется при сопоставлении
['Это', 'тот', 'те']
>>>

Замена всех совпадений в строке

Что делать, если вы хотите заменить все совпадающие части чем-то другим? Это можно сделать с помощью метода re.sub(). Ниже мы находим все последовательности гласных и заменяем их на «-». Метод возвращает результат в виде новой строки.
 
>>> дерево
«Сколько древесины бросил бы сурок, если бы сурок мог бросать древесину?»
>>> re. sub(r'[aeiou]+', '-', wood) # 3 аргумента: регулярное выражение, строка-заменитель, целевая строка
'H-w m-ch w-d w-ld - w-dch-ck ch-ck -f - w-dch-ck c-ld ch-ck w-d?'
>>>
Удаление совпадающих частей также может быть достигнуто с помощью re.sub(): просто сделайте строку «заменитель» пустой строкой ».
 
>>> re.sub(r'[aeiou]+', '', wood) # заменить пустой строкой
«Hw mch wd wld wdchck chck f wdchck cld chck wd?»
>>>
Если вы используете ( ) в регулярном выражении, совпадающая часть (называемая «группой») сохраняется как \1, \2 и т. д. Это удобно, когда вы хотите заменить совпадающую часть связанной с ней формой. Ниже мы заменяем последовательность гласных (‘a’, ‘ou’ и т. д., совпадающую внутри ( )) на ее двойник (‘aa’, ‘ouou’, обозначенную как \1\1).
 
>>> re. sub(r'([aeiou]+)', r'\1\1', wood) # замена на 2x совпадение
«Хоууууууууууууууууууууууууууууууууууууууууууууууууу одного
Можешь ли ты ууууууууууу?
>>>

Компиляция объекта регулярного выражения

Если вам нужно сопоставить регулярное выражение со многими разными строками, рекомендуется создать регулярное выражение как объект Python. Таким образом, конечный автомат для регулярного выражения компилируется один раз и используется повторно. Поскольку построение FSA довольно затратно в вычислительном отношении, это снижает нагрузку на обработку. Для этого используйте метод re.compile():
 
>>> myre = re.compile(r'\w+ou\w+') # компилируем myre как регулярное выражение
>>> myre.findall(wood) # вызов .findall() непосредственно на myre
['бы мог']
>>> myre.findall('Бесцветные зеленые идеи яростно спят')
['яростно']
>>> myre.findall('Тридцать три вора думали, что они взволнованы
трон в течение четверга. ')
['мысль', 'на протяжении']
После компиляции вы вызываете метод re непосредственно для объекта регулярного выражения. В приведенном выше примере myre — это скомпилированный объект регулярного выражения, соответствующий r’\w+ou\w+’, и вы вызываете для него .findall() как myre.findall(). При этом теперь вам нужно указать на один аргумент меньше: нужна только целевая строка myre.findall(wood).

Проверка наличия совпадения

Иногда нас интересует только подтверждение того, есть ли совпадение в данной строке. Для этого re.findall() является излишним, потому что он сканирует всю строку, чтобы создать *каждую* совпадающую подстроку. Это нормально, когда вы имеете дело с несколькими короткими строками, как мы здесь, но в реальном мире ваши строки могут быть намного длиннее, и/или вы будете выполнять сопоставление тысячи или даже миллионы раз, так что разница складывается.

В этом контексте хорошей альтернативой является re.search(). Этот метод находит только первое совпадение, а затем завершает работу. Если совпадение найдено, возвращается «объект совпадения». Но если нет, возвращается… ничего . Ниже r’e+’ успешно сопоставляется в строке «Бесцветный…», поэтому возвращается объект совпадения. Как ни странно, в нашем лесу нет ни одной буквы «е», поэтому тот же поиск ничего не дает.

 
>>> re.search(r'e+', 'Бесцветные зеленые идеи яростно спят')
<_sre.SRE_Match объект по адресу 0x02D9CB48>
>>> re.search(r'e+', дерево)
>>>
Если вы хотите увидеть фактическую совпадающую часть, вы можете использовать метод .group(), определенный для объекта совпадения. Однако есть проблема: он отлично работает, когда есть совпадение, и поэтому объект совпадения был возвращен, но когда совпадения нет, возвращенного объекта нет, поэтому…
 
>>> re. search(r'e+', 'Бесцветные зеленые идеи яростно спят').group()
'е'
>>> re.search(r'e+', wood).group()
Traceback (последний последний вызов):
  Файл "", строка 1, в 
    re.search(r'e+', дерево).group()
AttributeError: объект «NoneType» не имеет атрибута «группа»
Поэтому вы хотите использовать re.search() в контексте оператора if. Ниже строка if… проверяет, есть ли объект, возвращенный методом re.search, и только после этого вы переходите к печати совпадающей части и совпадающей строки. (ПРИМЕЧАНИЕ: если someobj возвращает True, если someobj не является одним из следующих: «ничего», целое число 0, пустая строка «», пустой список [] и пустой словарь {}.)
  
 >>> f = open('D:\\Lab\\ling1330\\bible-kjv.txt')
>>> blines = f.readlines()
>>> f.close()
>>> smite = re.compile(r'sm(i|o)te\w*')
>>> для b в бликах:
 matchobj = smite. search(b)
 if matchobj: # Истинно, если matchobj не "ничего"
 печать (matchobj.group(), '-', b, конец = '')
порази - снова порази все живое, как это сделал я.
поразили - были с ним, и поразили Рефаимов в Аштерот-Карнаиме, и
порази руку Исава: ибо я боюсь его, как бы он не пришел и не поразил меня, и
36:35 И умер Хушам и Гадад, сын Бедада, которые поразили Мадианитян в
smitest - Почему ты бьешь своего ближнего? 2:14 Он сказал: кто сделал тебя
порази - 3:20 И простру руку Мою, и поражу Египет всем
порази – вот, я поражу жезлом, который в руке Моей, по водам
ударил жезлом, и ударил по водам, которые были в реке, в прицеле
порази - 8:2 И если ты не отпустишь их, вот, я поражу всех твоих
порази жезлом и порази прах земной, чтобы он сделался вшами
смотест - с тобою из старейшин Израиля; и жезл твой, которым ты ударил
ударь — и ударишь в скалу, и пойдет из нее вода,
smiteth - 21:12 Кто ударит человека так, что он умрет, непременно предан будет
бьет - 21:15 И кто ударит отца своего или мать свою, непременно
21:18 И если люди соревнуются друг с другом, и один ударит другого камнем,
.
No related posts.
Добавить комментарий 
Ваш адрес email не будет опубликован. Обязательные поля помечены *