Разное

Findall python re: Python Regular Expressions  |  Python Education  |  Google Developers

Содержание

python — re.findall как разделить контент на группы

Мне нужно некоторое разъяснение о том, как работает regex с помощью метода re.findall.

pattern = re.compile(r'(?<=\\\\\[-16pt]\n)([\s\S]*?)(?=\\\\\n\\thinhline)')
content= ' '.join(re.findall(pattern, content))

Таким образом, вышеописанное печатает все содержимое, которое шаблон соответствует началу: \\[-16pt] и окончанию ‘\ \n thinhline’ плюс весь текст после него.
Если бы у меня было следующее содержание, которое соответствовало шаблону:

\\[-16pt]
x = 10
print ("hi")
\\
\thinhline
\\[-16pt]
y = 3
print ("bye")
\\
\thinhline
\\[-16pt]
z = 7
print ("zap")
\\
\thinhline
This is random text.
All of this is matched by re.findall, even though it is not included within the pattern.
xyz = "xyz"

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

группа 1:

x = 10
print ("hi")

группа 2:

y = 3
print ("bye")

группа 3:

z = 7
print ("zap")

и ничего из того лишнего, что подбирается после него?

Спасибо.

python

regex

python-2.7

Поделиться

Источник


zara    

02 января 2015 в 17:16

2 ответа


  • Python регулярные выражения re.findall — разбить строку на две части

    У меня есть такие струны: C BOS — Traded from Royal Disappointments И я хочу разделить их на все до тире и все после. Поэтому просто в двух переменных, new1 и new2, я хочу, чтобы вышеизложенное было: сайт new1 = C BOS новый2 = Traded from Royal Disappointments Я новичок в re, поэтому не могу…

  • Python re.search() и re.findall()

    Я пытаюсь решить эту проблему с помощью HackerRank . Это проблема машинного обучения. Сначала я попытался прочитать все слова из файла корпуса для построения униграмм частот. В соответствии с этим ML задача word определяется как Слово — это последовательность символов, содержащая только буквы от a…



1

import re
s=re.findall(r"(?<=\\\\\[-16pt]\n)([\s\S]*?)(?=\\\\\n\\thinhline)",test_str)

Findall возвращает список сопоставленных групп.

Здесь s — это list.You, который может получить доступ к тому, что вы хотите, обратившись к s[0] или s[1] .

Поделиться


vks    

02 января 2015 в 17:22



1

Рассмотрим следующую работоспособную программу:

import re

content="""\\[-16pt]
x = 10
print ("hi")
\\
thinhline
\\[-16pt]
y = 3
print ("bye")
\\
thinhline
\\[-16pt]
z = 7
print ("zap")
\\
thinhline
This is random text.
"""

pattern = re.compile(r"""(\\\[-16pt]\n)    # Start. Don't technically need to capture.
                         (.*?)             # What we want. Must capture ;)
                         (\n\\\nthinhline) # End. Also don't really need to capture
                      """, re.X | re.DOTALL)

for m in pattern.finditer(content):
    print("Matched:\n----\n%s\n----\n" % m.group(2))

Вывод при запуске:

Matched:
----
x = 10
print ("hi")
----

Matched:
----
y = 3
print ("bye")
----

Matched:
----
z = 7
print ("zap")
----

Записи:

  • С помощью опции re.X выражение может быть многострочным и закомментированным
  • При использовании опции re.DOTALL избыточные обратные косые черты могут быть отброшены
    , и группа » .*? «(т. е.» получить каждый символ без жадности до
    следующего совпадения») будет включать новые строки.
  • Я использовал finditer , а не findall …, что технически отходит
    от вашего вопроса, но вы хотели работать с каждым матчем, поэтому я решил, что это
    хороший подход.
  • Я снял табуляцию \t с thinhline , потому что не был уверен, должен ли он
    быть табуляционным символом или backlash-then-t. Не то чтобы это сильно влияло на все вышесказанное,
    но просто хотелось внести ясность.
  • Я захватываю начальную и конечную группы только для демонстрации. Только средняя
    группа действительно нужна.

Поделиться


Andrew E    

02 января 2015 в 17:34


Похожие вопросы:

Как работают группы захвата? (wrt python регулярные выражения)

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

Python re.findall() чтобы получить все совпадающие группы

Это разделенный текст, но я хочу разобрать его w/ regex. Второй столбец и следующий занимают секунды или миллисекунды. >>> import re >>> s = »’aaa bbb|30s ccc|500ms|1s»’…

Как разделить картинку на цветовые группы?

Допустим, у меня есть изображение такого шара, как этот : Я хочу разделить цвета шара на цветовые группы. В этом случае у меня должно быть 2 основные цветовые группы — brown и white. Группа brown…

Python регулярные выражения re.findall — разбить строку на две части

У меня есть такие струны: C BOS — Traded from Royal Disappointments И я хочу разделить их на все до тире и все после. Поэтому просто в двух переменных, new1 и new2, я хочу, чтобы вышеизложенное…

Python re.search() и re.findall()

Я пытаюсь решить эту проблему с помощью HackerRank . \s\w], text) Это прекрасно работает, и это действительно решает мою проблему. Чего я не понимаю, так это деталей в…

Как использовать символическое имя группы с помощью re.findall()

Можно ли получить доступ к символическому имени группы, определенному в регулярном выражении с помощью (?P<toto>…) с эквивалентом re.findall() ? Используя re.match() , MatchObject вновь…

Захват именованных групп в regex с re.findall

Когда я пытался ответить на этот вопрос: regex, чтобы разделить %ages и значения в python, я заметил, что мне пришлось переупорядочить группы из результата findall. Например: data = 34% passed 23%…

Python regex с re.findall

Я работаю с Python 2.7. Это мой первый вопрос. Вот мой код: import re string = 0581111105822222749533333 result = re.findall(r’058′,string) # [‘058’, ‘058’] Я хочу добавить 5 цифр после 058 и…

ошибка в том, чтобы разделить строку, используя «re.findall»

мне нужно разделить строку на три значения (x,y, z) строка выглядит примерно так (48,25,19) я использовал re.findall , и он работает нормально, но иногда он выдает эту ошибку (plane_X, plane_Y,…

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

Регуля́рные выраже́ния (англ. regular expressions) — формальный язык поиска и осуществления манипуляций с подстроками в тексте. (WikiLink)

Так же их называю сокращенно regexes. Проще говоря это шаблон (pattern) для поиска определенной строки(подстроки). Разберем все на примерах.

 

Допустим нам нужно найти номер телефона 8-999-999-99-99 в строке:

\d — означает цифра от 0 до 9, тогда наш шаблон для поиска мы можем записать как

‘\d-\d\d\d-\d\d\d-\d\d-\d\d’

Но можно сделать это и попроще например:

‘\d-\d{3}-\d{3}-\d{2}-\d{2}’

{число} — означает кол-во повторений предыдущего набора символов.

 

Для использования regexes в коде python нам необходим модуль re (входит в стандартный набор python):

import re

phoneNum = re. compile(r’\d-\d{3}-\d{3}-\d{2}-\d{2}’)  # создаем объект regex,  r — перед началом шаблона означает, что строка будет «сырой»(raw), для того, чтобы не экранировать каждый обратный слеш.

 

Можно тоже самое сделать не создавая объекта regex:

phoneNum = re.findall(r’\d-\d{3}-\d{3}-\d{2}-\d{2}’, string)  # теперь phoneNum будет списком со всеми найденными номерами в string

 

Но вернемся к объекту regex.

У regex объекта есть метод .search(), который создает объект Match:

mo = phoneNum.search(‘my number is 8-999-999-99-99’)  # mo станет объектом Match в котором будет храниться первое найденное (по шаблону phoneNum) значение в строке.

print(mo.group())  # вывод значения объекта mo (!!! если .search() не найдет подстроки, то будет исключение, т.к. значение mo будет None)

 

Результат:

8-999-999-99-99

 

ГРУППЫ:

 

Допустим, мы хотим разделить весь номер на код телефона и сам номер абонента:

создадим группы в шаблоне ‘\d-(\d{3})-(\d{3}-\d{2}-\d{2})’:

 

mo = re.search(r’\d-(\d{3})-(\d{3}-\d{2}-\d{2})’, string)  # string содержит номер 8-999-999-99-99
mo.group()  # первая группа — вся найденная подстрока
‘8-999-999-99-99’
mo.group(1)  # вторая группа — код
‘999’
mo.group(2)  # третья группа — номер
‘999-99-99’ 

mo.groups()  # вернет все группы в виде кортежа(tuple)

(‘999’, ‘999-99-99’)

 

PS. если же вам нужно в шаблон добавить скобки «(» и/или «)», тогда их нужно экранировать:

r’\(‘ — будет искать ‘(‘

 

Выражение ИЛИ (используется символ ‘|’ — pipe):

Допустим, мы хотим найти слова ‘Филипп’ или ‘Киркоров’ в строке:

создадим шаблон r’Филипп|Киркоров’

 

mo = re.search(r’Филипп|Киркоров’, ‘Кто не танцует, тот Филипп Киркоров’)

mo.group()

‘Филипп’  # только Филипп т.к. .search() ищет первое совпадение, для поиска всех совпадений используйте .findall(), но тогда mo уже будет не Match объектом, а списком.

mo = re.search(r’Филипп|Киркоров’, ‘А кто такой Киркоров этот?’)

mo.group()

‘Киркоров’

 

Еще пример использования pipe:

mo = re.search(r’по(езд|иск|том)’, ‘Наш поиск не дал результатов’)

mo.group()

‘поиск’

mo.group(1)

‘иск’

 

Необязательный шаблон(символ ‘?’ — ноль или одно совпадение).

Вернемся к нашему примеру с телефоном, что если телефон записан без кода и 8-ки? Изменим наше выражение используя необязательный шаблон:

 

mo = re.search(r'(\d-\d{3}-)?\d{3}-\d{2}-\d{2}’, ‘my number is 999-99-99)

mo.group()

‘999-99-99’

 

Ноль и более совпадений (символ ‘*’).

Тоже самое, что и «?», только совпадений может быть сколько угодно:

 

mo = re.search(r’Bat(wo)*man’, ‘Batman’)

mo.group()

‘Batman’

 

mo = re.search(r’Bat(wo)*man’, ‘Batwoman’)

mo.group()

‘Batwoman’

 

mo = re.search(r’Bat(wo)*man’, ‘Batwowowoman’)

mo.group()

‘Batwowowoman’

 

Одно и более совпадение(символ «+»)

 

mo = re.search(r’Bat(wo)+man’, ‘Batwoman’)

mo.group()

‘Batwoman’

 

mo = re.search(r’Bat(wo)+man’, ‘Batwowowoman’)

mo.group()

‘Batwowowoman’

 

mo = re.search(r’Bat(wo)+man’, ‘Batman’)

mo == None

True

 

Помните, что означает {5} ?

так вот r’\d{5}’ будет искать 5-ть цифр подряд, а если мы напишем r’\d{3, 5}’, то будет поиск 3-х, 4-х или 5-ти цифр такая запись равноценна r'(\d\d\d)|(\d\d\d\d)|(\d\d\d\d\d)’

 

PS. Если используется метод .findall() то возвращаться будет список (как я уже говорил), а если использовать в шаблоне группы «( )», то вернется список с кортежами.

 

Сокращения наборов символов.

 

мы использовали сокращение \d, которое на самом деле означает r'(0|1|2|3|4|5|6|7|8|9)’

Вот еще несколько сокращений наборов:

\D — любые кроме цифр

\w — буквы, цифры, нижнее подчеркивание (можно запомнить как «word»)

\W — любые кроме букв, цифр, нижнего подчеркивания

\s — пробел, табуляция, новая линия (можно запомнить как «space»)

\S — любые кроме пробела, табуляции, новой линии

 

Наборы символов. abc] совпадение любые символы кроме включенных в скобки

 

Замена строк.

Мы можем не только находить строки(подстроки) но и заменять их.

r = re.compile(r’\d+’)

r.sub(‘*****’, ‘секретный документ №837372’)

‘секретный документ №*****’

 

Допустим мы хотим показать первые две цифры номера документа:

r = re.compile(r'(\d)(\d)\d+’)  # две первых цифры взяли в группы

r.sub(r’\1\2***’, ‘секретный документ №837372′)  # r’\1\2***’ открыли две первых цифры

‘секретный документ №83***’

 

Создание многострочных выражений.

r = re.compile(r»'(

    (\d{3}|\(\d{3}\))?  # код телефона

    (\s|-|\.)?  # разделитель

    \d{3}  # первые 3 цифры номера

    (\s|-|\.)?  # разделитель

    \d{2}  # вторые 2 цифры номера

    (\s|-|\.)?  # разделитель

    \d{2})»’, re.VERBOSE)  # последние 2 цифры номера

 

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

 

Вот хороший сайт, который поможет в создании выражений: http://regexpal.com/

 

Пример создания выражения для проверки пароля:

условия: обязательно нижний верхний регистр цифры

r’.*([a-z]{1,}[A-Z]{1,}[0-9]{1,}|[A-Z]{1,}[a-z]{1,}[0-9]{1,}|[0-9]{1,}[A-Z]{1,}[a-z]{1,}|[a-z]{1,}[0-9]{1,}[A-Z]{1,}|[A-Z]{1,}[0-9]{1,}[a-z]{1,}).*’

Мой блог: Регулярные выражения в Python

 

Регулярные выражения — это компактная форма записи представления о коллекции строк.

Регулярные выражения используются для:

— проверки наличия фрагмента текста в строке
— поиска подстрок
— поиска и замены
— разбиения строк по точкам совпадения

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

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

re.S
re.DOTALL

При наличии этого флага символ . соответствует любому символу, включая символ перевода строки.

re.X
re.VERBOSE

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

Квантификаторы

Квантификаторы записываются в виде {m,n}
m — минимальное число совпадений с выражением
n — максимальное число совпадений с выражением

Например

e{1,1}e{1,1}     две e подряд ee

или тоже самое

e{2,2}

Слову feel  они соответствуют, а слову felt нет.

Сокращения.

Если в квантификаторе указать одно число

e{2}

то оно означает и минимум и максимум

т.е  e{2}  то же что и  e{2,2}

Если квантификатор не указан, то предполагается что он равен единице {1,1}  или {1}

Иногда удобно использовать различные минимальное и  максимальное значение:

чтобы найти совпадение со словами

travelled
traveled

можно использовать выражение

travel{1,2}ed
или
travell{0,1}ed

Квантификатор {0,1}  имеет сокращение ?

travell?ed

Есть еще два сокращения для квантификаторов:

+ — не менее одного  {1,n}
* — любое число      {0,n}

где n — означает максимально допустимое для квантификатора число, которое обычно не менее 32767

Квантификатор + очень удобен.
Например, для поиска соответствий целым числам  можно было бы использовать выражение \d+
т.к. оно совпадает с одной или боее цифрами.

В строке  4588.91 регулярное выражение \d+ найдет два совпадения: 4588 и 91

С помощью belevel+ed  можно отыскать слова с одним или более символами l

Например ошибки связанные с залипанием клавиш:

beleveled
belevelled
belevellled

Квантификатор * используется реже — потому что он может приводить к получению неожиданных результатов.

Например хотим найти все строки с комментариями  #

#*     — так не годится

Это выражение найдет и пустые строки (т.е. с нулевым совпадением)
Квантификаторы * и ? могут находить соответствие при нулевом числе совпадений.

Если вы используете квантификатор * или ? , то обязательно убедитесь, что хотя бы одно подвыражение
в регулярном выражениииспользует ненулевой квантификатор (т.е. отличный от * и ?)

Часто возможно заменить квантификатор * на ? и наоборот.

tasselled

Найти слово с одним или более символами l можно так:

tassell*ed
или
tassel+ed

а с двумя или более символами l можно так:

tasselll*ed
или
tassell+ed

Регулярное выражение \d+ будет соответствовать строке 136
Почему оно соответствует всем цифрам, а не только первой?

По умолчанию все квантификаторы являются жадными (или максимальными)
они стремятся соответствовать как можно большему числу символов.

Любой квантификатор можно сделать нежадным (или минимальным), добавив после него символ ?.

Знак вопроса имеет два разных значения:

когда он употребляется самостоятельно, он интерпретируется как сокращенная форма записи квантификатора {0,1}

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

Например выражение  \d+?

обнаружит соответствие в строке 136 в трех местах:
1, 3 и 6

Ранее была представлена функция

re.search(r,s,f) 

которая находила и возвращала объект совпадения с регулярным выражением r в любом месте строки s

Существует более ограниченная функция

re.match(r,s,f)

которая находит и возвращает объект совпадения с регулярным выражением r только если он находится в начале строки s

Но существует и более продвинутая функция

re.findall(r,s,f)

которая находит и возвращает все непересекающиеся совпадения с регулярным выражением r в строке s.
Если регулярное выражение содержит сохраняющие группы, для каждого совпадения возвращается кортеж
с сохраненными фрагментами.

import re

c = re.compile(r’11G’)
str = ‘ORACLE11GR2’
match = re.match(c, str)
if match:
    print(‘found’, match.group())
else:
    print(‘did not find’)

>>did not find

import re

c = re.compile(r’11G’)
str = ’11GR2′
match = re.match(c, str)
if match:
    print(‘found’, match.group())
else:
    print(‘did not find’)

>>found 11G

import re

c = re.compile(r’11G’)
str = ‘ORACLE11GR2’
match = c.search(str)
if match:
    print(‘found’, match.group())
else:
    print(‘did not find’)

>>>found 11G

С помощью функции  re.findall
можно увидеть разницу между жадным н не жадным квантификатором:

Жадный (максимальный):

import re

c = re.comьpile(r’\d+’)
str = ‘0123456789’
tuples = re.findall(c, str)
print(tuples)

>>[‘0123456789’]

Не жадный (минимальный):

import re

c = re.compile(r’\d+?’)
str = ‘0123456789’
tuples = re.findall(c, str)
print(tuples)

>>[‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’]

Еще примеры с функцией  re.findall:

Найдем все слова в строке, котрые начинаются на букву а (русский алфавит):

import re

c = re.compile(r’\bа[а-я]*’)
str = ‘электронный адрес [email protected], еще электронный адрес [email protected]
tuples = re.findall(c, str)
print(tuples)

>>[‘адрес’, ‘адрес’]

Тоже но теперь буква a (латинский алфавит):

import re

c = re.compile(r’\ba[a-z]*’)
str = ‘электронный адрес [email protected], еще электронный адрес [email protected]
tuples = re.findall(c, str)
print(tuples)

>>[‘angor’, ‘andrey’]

Найдем все электронные адреса в строке:

import re

c = re.compile(r'[\w\.-][email protected][\w\.-]+’)
str = ‘электронный адрес [email protected], еще электронный адрес [email protected]
tuples = re.findall(c, str)
print(tuples)

>>[‘[email protected] com’, ‘[email protected]’]

Если регулярное выражение содержит сохраняющие группы, то их можно вывести в виде кортежа:

import re

c = re.compile(r'([\w\.-]+)@([\w\.-]+)’)
str = ‘электронный адрес [email protected], еще электронный адрес [email protected]
tuples = re.findall(c, str)
print(tuples)

for tuple in tuples:
    print(tuple[0])
    print(tuple[1])

>>[(‘angor’, ‘oracle.com’), (‘andrey’, ‘sun.com’)]

>>angor
>>oracle.com
>>andrey
>>sun.com

Квантификаторы регулярных выражений:

e?      Соответствует e{0,1}
        ноль или большее число вхождений выражения e
        по умолчанию жадный

e??     Соответствует e{0,1}?
        ноль или более число вхождений выражения e
        минимальный

e+      Соответствует e{1,}
        одно или более число вхождений выражения e
        по умолчанию жадный

e+?     Соответствует e{1,}?
        одно или более число вхождений выражения e
        минимальный

e*      Соответствует e{0,}
        ноль или более число вхождений выражения e
        по умолчанию жадный

e*?     Соответствует e{0,}?
        ноль или большее число вхождений выражения е
        минимальный

e{m}    Cоответствует точно m вхождениям выражения e

e{m,}   Соответствует по меньшей мере m вхождениям выражения e
        по умолчанию жадный

e{m,}?  Соответствует по меньшей мере m вхождениям выражения e
        минимальный

e{,n}   Соответствует не более чем n вхождениям выражения e
        по умолчанию жадный

e{,n}?  Соответствует не более чем n вхождениям выражения e
        минимальный
       
                       
e{m,n}  Соответствует не менее чем m и не более чем n вхождениям выражения e
        по умолчанию жадный
  

e{m,n}? Соответствует не менее чем m и не более чем n вхождениям выражения e
        минимальный

Примеры сокращенных форм:

\d+  соответствует одной или более цифрам
     стремится соответствовать как можно большему числу символов

                                                
\d+?  соответствует одной или более цифрам
      из последовательностей двух или более цифр будут найдены два или более вхождений по   одной цифре. >]*?>’)
str = ‘<….  <IMG height=202 alt=»Ленин в Смольном» src=»images/lenin-v-smolnom.jpg» width=160 align=»middle» title=»Ленин в Смольном.»>   …>’
tuples = re.findall(c, str)
print(tuples)

>>[‘<IMG height=202 alt=»Ленин в Смольном» src=»images/lenin-v-smolnom.jpg» width=160 align=»middle» title=»Ленин в Смольном.»>’]

Регуряные выражения можно объединять через ИЛИ
тогда будет отыскиваться совпадение с любым альтернативным вариантом:

import re

c = re.compile(r’подпрограмма|алгоритм|подстрока’)
str = ‘подпрограмма алгоритм подстрока’
tuples = re.findall(c, str)
print(tuples)

>>[‘подпрограмма’, ‘алгоритм’, ‘подстрока’]

Если мы применим операцию группировки (она же операция сохранения совпадения)
то то что не попало в сохранение не будет выведено функцией re.findall:

import re

c = re.compile(r'(подпрограмма|алгоритм)|подстрока’)
str = ‘подпрограмма алгоритм подстрока’
tuples = re.findall(c, str)
print(tuples)

>>[‘подпрограмма’, ‘алгоритм’, »]

Круглые скобки преследуют две цели:

— сгруппирповать выражения
— сохранить текст, совпавший с выражением

Например:

подпрограмма|подстрока|алгоритм

можно записать и так:

под(программа|строка)|алгоритм

Но во втором выражении будет побочный эффект сохранением выражений

import re

c = re.compile(r’под(программа|строка)|алгоритм’)
str = ‘подпрограмма алгоритм подстрока’
tuples = re.findall(c, str)
print(tuples)

>>[‘программа’, », ‘строка’]

Функция возвратила кортеж для сохранаемых групп.

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

под(?:программа|строка)|алгоритм

поставив вслед за открывающейся круглой скобкой символы  ?:

import re

c = re.compile(r’под(?:программа|строка)|алгоритм’)
str = ‘подпрограмма алгоритм подстрока’
tuples = re. ,$ и \A, \Z

Так совпадение обнаруживается:

import re

pattern = »’\Aabc de fgh$»’
c = re.compile(pattern)
line =’abc de fgh\n’
match = c.search(line)
if match:
    print(line, end=»»)

abc de fgh

А так не находит:

import re

pattern = »’\Aabc de fgh\Z»’
c = re.compile(pattern)
line =’abc de fgh\n’
match = c.search(line)
if match:
    print(line, end=»»)

Так тоже совпадение обнаруживается:

import re

pattern = »’abc de fgh»’
c = re.compile(pattern)
line =’abc de fgh\n’
match = c.search(line)
if match:
    print(line, end=»»)

abc de fgh

Так совпадение обнаруживается:

import re

pattern = »’abc\nde fgh»’
c = re.compile(pattern)
line =’abc\nde fgh’
match = c.search(line)
if match:
    print(line, end=»»)

abc
de fgh

Так совпадение обнаруживается:

import re

pattern = »’abc\nde fgh$»’
c = re.compile(pattern)
line =’abc\nde fgh’
match = c.search(line)
if match:
    print(line, end=»»)

abc
de fgh

И так совпадение обнаруживается:

import re

pattern = »’\Aabc\nde fgh$»’
c = re.compile(pattern)
line =’abc\nde fgh’
match = c.search(line)
if match:
    print(line, end=»»)

abc
de fgh

И так совпадение обнаруживается:

import re

pattern = »’\Aabc\nde fgh\Z»’
c = re.compile(pattern)
line =’abc\nde fgh’
match = c.search(line)
if match:
    print(line, end=»»)

abc
de fgh

Так совпадение обнаруживается:

import re

pattern = »’\Aabc\nde fgh$»’
c = re.compile(pattern)
line =’abc\nde fgh\n’
match = c.search(line)
if match:
    print(line, end=»»)

abc
de fgh

А так нет:

import re

pattern = »’\Aabc\nde fgh\Z»’
c = re.compile(pattern)
line =’abc\nde fgh\n’
match = c.search(line)
if match:
    print(line, end=»»)

В итоге получается что паттерн «строка\Z»
совпадает со строкой «строка»
и не совпадает со строкой «строка\n»
Паттерн «строка$»
совпадает и строкой «строка»
и со строкой «строка\n»

Паттерн «строка»  также
совпадает и строкой «строка»
и со строкой «строка\n»

Паттерн «строка»
совпадает и строкой «строка»
и со строкой «\nстрока\n»
но ни один из паттернов :

«^строка»
«\Aстрока»

не совпадет со строкой:

«\nстрока»

Проверки \b и \B

Регулярное выражение jet будет находить в тексте:

the jet and jetski are noisy

несколько соответствий.

Проверка \b — граница слова поможет избежать лишних нахождений.

Выражение \bjet\b  будет находить только одно соответствие.

import re

c = re.compile(r'(jet)’)
str = ‘the jet and jetski are noisy’
tuples = re.findall(c, str)
print(tuples)

C:\projects>python test1.py
[‘jet’, ‘jet’]

import re

c = re.compile(r'(\bjet\b)’)
str = ‘the jet and jetski are noisy’
tuples = re.findall(c, str)
print(tuples)

C:\projects>python test1.py
[‘jet’]

Выражение  \bg

найдет соответствие в тексте:

good 

и тексте:

a good  

но не найдет соответствия в тексте:

together

Выражение \Bg

не найдет соответствия в тексте:

good

и тексте:

a good  

но найдет соответствие в тексте:

together

import re

c = re.compile(r'(\bg)’)
str = ‘together’
tuples = re.findall(c, str)
print(tuples)

C:\projects>python test1.py
[]

import re

c = re.compile(r'(\Bg)’)
str = ‘together’
tuples = re.findall(c, str)
print(tuples)

C:\projects>python test1.py
[‘g’]

Выражение:

aircraft|airplane|jet

можно записать так:

\baircraft\b|\bairplane\b|\bjetb\

или более просто:

\b(?:aircraft|airplane|jet)\b

т.е.
граница слова, несохраняющее выражение, граница слова

так как, выражения:

aircraft|airplane|jet
\baircraft\b|\bairplane\b|\bjetb\

являются несохраняющими
то и мы должны использовать несохраняющее выражение:

\b(?:aircraft|airplane|jet)\b

Опережающие проверки.

Пусть имеется текст:

Helen Patricia Sharman
Jim Sharman
Sharman Joshi
Helen Kelly

нам необходимо отыскать текст Helen Patricia, но только если он относится к имени Sharman.

Простейший способ такой:

\b(Helen\s+Patricia)\s+Sharman\b

Этому выражению будет соответствовать текст:
Helen Patricia, только если он предшествует границе слова,
за которым следуют пробельные символы и слово Sharman и далее следует граница слова. Соответствует началу
$ Соответствует концу
.Соответствует любому символу, кроме новой строки
? Соответствует нулю или одному вхождению.
| Означает ИЛИ (соответствует любому из символов
разделенные им.
* Любое количество вхождений (включая 0 вхождений)
+ Одно или несколько вхождений
{} Укажите количество вхождений предыдущего RE
чтобы соответствовать.
() Вложить группу RE

re.search ()

re.search () либо возвращает None (если шаблон не совпадает), либо re.MatchObject , который содержит информацию о совпадающей части строки. Этот метод останавливается после первого совпадения, поэтому он лучше всего подходит для проверки регулярного выражения, а не для извлечения данных.

Пример:

import re

regex = r "([a-zA-Z] +) (\ d +) "

соответствие = повторно.поиск (регулярное выражение, «Я родился 24 июня» )

если совпадение ! = Нет :

Распечатать s,% s " % (совпадение.start (), match.end ()))

печать ( "Полное соответствие:% s" % (match.group ( 0 )))

печать ( "Месяц:% s" % (совпадение. группа ( 1 )))

печать ( "День:% s" % (match.group ( 2 ) )))

else :

печать ( «Шаблон регулярного выражения не соответствует». )

Вывод:

Соответствует индексу 14, 21
Полный матч: 24 июня
Месяц: июнь
День: 24
 
ре.findall ()

Возвращает все неперекрывающиеся совпадения шаблона в строке в виде списка строк. Строка просматривается слева направо, и совпадения возвращаются в найденном порядке.

Пример:

импорт re

строка =

4 regex 900 '

соответствует = повторно.findall (регулярное выражение, строка)

печать (совпадение)

Вывод:

['123456789', '987654321']
 

Python re.findall () — все, что вам нужно знать

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

Эта статья посвящена методу findall () библиотеки Python re . Метод findall () — это самый простой способ использования регулярных выражений в Python: если вы хотите их освоить, начните здесь!

Статья по теме: Python Regex Superpower — полное руководство

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

Так как же работает метод re.findall () ? Изучим спецификацию.

Как работает метод findall () в Python?

Метод re.findall (шаблон, строка) сканирует строку от слева направо , ища все неперекрывающихся совпадений из шаблона . Он возвращает список строк в соответствующем порядке при сканировании строки слева направо.

Спецификация :

 re.findall (шаблон, строка, флаги = 0) 

Метод re.findall () имеет до трех аргументов.

  • шаблон : шаблон регулярного выражения, которому вы хотите сопоставить.
  • строка : строка, в которой вы хотите найти шаблон.
  • flags (необязательный аргумент): более продвинутый модификатор, позволяющий настраивать поведение функции. Хотите знать, как использовать эти флаги? Прочтите эту подробную статью в блоге Finxter.

Рассмотрим каждый из них подробнее.

Возвращаемое значение:

Метод re.findall () возвращает список строк. Каждый строковый элемент является соответствующей подстрокой строкового аргумента.

Давайте посмотрим на несколько примеров!

Примеры re.findall ()

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

 импорт ре

текст = '' '
    Ха! позвольте мне увидеть ее: увы! ему холодно:
    Кровь у нее отстоялась, суставы затекли;
    Жизнь и эти губы давно разлучены:
    Смерть лежит на ней, как безвременный мороз
    На самый сладкий цветок на всем поле.'

Допустим, вы хотите найти в тексте строку "ее" :

 >>> re.findall ('она', текст)
['она', 'она', 'она'] 

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

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

 >>> re.findall ('\\ bf \ w + \\ b', текст)
['мороз', 'цветок', 'поле'] 

Регулярное выражение '\\ bf \ w + \\ b' соответствует всем словам, начинающимся с символа 'f' .

Вы можете спросить: зачем заключать регулярное выражение в начало и конец '\\ b' ? Это символ границы слова, который соответствует пустой строке в начале или в конце слова.Вы можете определить слово как последовательность символов, которые не являются пробелами или другими разделителями, например '.:,?!' .

В предыдущем примере вам нужно снова экранировать граничный символ '\ b' , потому что в строке Python значением по умолчанию для последовательности символов '\ b' является символ обратной косой черты.

В чем разница между re.findall () и re.search ()?

Между re есть два отличия.findall (шаблон, строка) и методы re.search (шаблон, строка) :

  • re.search (шаблон, строка) возвращает объект соответствия, а re.findall (шаблон, строка) возвращает список совпадающих строк.
  • re.search (шаблон, строка) возвращает только первое совпадение в строке, а re.findall (шаблон, строка) возвращает все совпадения в строке.

И то, и другое можно увидеть в следующем примере:

 >>> text = 'Python превосходит Python'
>>> ре. search ('Py ... n', текст)
<объект re.Match; span = (0, 6), match = 'Python'>
>>> re.findall ('Py ... n', текст)
['Python', 'Python'] 

Строка «Python превосходит Python» содержит два вхождения «Python» . Метод search () возвращает только объект соответствия первого вхождения. Метод findall () возвращает список всех вхождений.

В чем разница между re.findall () и re.match ()?

Между re есть два отличия.findall (шаблон, строка) и методы повторного сопоставления (шаблон, строка) :

  • re.match (шаблон, строка) возвращает объект соответствия, а re.findall (шаблон, строка) возвращает список совпадающих строк.
  • re.match (шаблон, строка) возвращает только первое совпадение в строке и только в начале, тогда как re.findall (шаблон, строка) возвращает все совпадения в строке.

И то, и другое можно увидеть в следующем примере:

 >>> text = 'Python превосходит Python'
>>> ре.match ('Py ... n', текст)
<объект re.Match; span = (0, 6), match = 'Python'>
>>> re.findall ('Py ... n', текст)
['Python', 'Python'] 

Строка «Python превосходит Python» содержит два вхождения «Python» . Метод match () возвращает только объект соответствия первого вхождения. Метод findall () возвращает список всех вхождений.

Куда идти дальше?

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

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

Тогда присоединяйтесь к моему списку рассылки «Coffee Break Python», состоящему из десятков тысяч амбициозных программистов!

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

Инженеры Facebook — мастера регулярных выражений. Социальные сети, такие как Facebook, WhatsApp и Instagram, связывают людей с помощью текстовых сообщений .

Инженеры Amazon — мастера регулярных выражений. Гиганты электронной коммерции поставляют товары на основе текстовых описаний товаров .Регулярные выражения управляют игрой, когда обработка текста встречается с информатикой.

Если вы тоже хотите стать мастером регулярных выражений, ознакомьтесь с самым полным курсом регулярных выражений Python на планете:

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

Чтобы помочь студентам достичь более высокого уровня успеха в Python, он основал веб-сайт по обучению программированию Finxter.com. Он автор популярной книги по программированию Python One-Liners (NoStarch 2020), соавтор серии самоизданных книг по Python для кофе-брейков, энтузиаст информатики, фрилансер и владелец одного из 10 крупнейших блогов Python по всему миру.

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

Python 2.

7 Учебник

На этой странице: re module, re.findall (), re.compile (), re.search (), re.search (). Group ().

Re Module

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

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

Предположим, вы хотите найти все слова, начинающиеся с «wo» в этом очень коротком тексте ниже.Вы хотите использовать метод re.findall (). Он принимает два аргумента: (1) шаблон регулярного выражения и (2) целевая строка для поиска совпадений.

>>> wood = 'Сколько дерева проглотил бы сурок, если бы сурок мог
Чак Вуд?
>>> re.findall (r'wo \ w + ', дерево)
['дерево', 'бы', 'сурок', 'сурок', 'дерево']
>>>
 

Прежде всего, обратите внимание, что регулярное выражение r’wo \ w + ‘записывается как необработанная строка , что обозначено буквой r’… ‘строковый префикс. Это связано с тем, что в регулярных выражениях, как вы уже знаете, используется обратная косая черта «\» в качестве собственного специального escape-символа, а без «r» обратная косая черта интерпретируется как специальный escape-символ * Python *. По сути, на уровне строкового объекта Python этот «\» в «\ w» следует интерпретировать как буквальный символ обратной косой черты, чтобы позже его можно было интерпретировать как специальный escape-символ регулярного выражения, когда строка обрабатывается модулем re. Если все это звучит слишком сложно, просто не забывайте ВСЕГДА ИСПОЛЬЗОВАТЬ СВОЕ ОБЫЧНОЕ ВЫРАЖЕНИЕ с ‘r’.

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

>>> re. findall (r'o + ', дерево)
['o', 'oo', 'o', 'oo', 'oo', 'o', 'oo']
>>> re.findall (r'e + ', дерево)
[]
 

Что, если вы хотите игнорировать регистр в своих матчах? Вы можете указать его как третий необязательный аргумент: re.ИГНОРИРОВАТЬ.

>>> foo = 'То, то и те'
>>> re.findall (r'th \ w + ', foo)
['что те']
>>> re.findall (r'th \ w + ', foo, re.IGNORECASE)
["Это", "то", "те"]
>>>
 

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

Если вам нужно сопоставить регулярное выражение с множеством разных строк, рекомендуется создать регулярное выражение как объект python.Таким образом, конечный автомат для регулярного выражения компилируется один раз и используется повторно. Поскольку построение FSA является довольно затратным с точки зрения вычислений, это снижает нагрузку на обработку. Для этого воспользуйтесь методом re.compile ():

>>> myre = re.compile (r '\ w + ou \ w +')
>>> myre.findall (дерево)
['бы мог']
>>> myre.findall ('Бесцветные зеленые идеи яростно спят')
['яростно']
>>> мир.findall ('Тридцать три вора думали, что они взволнованы
трон в течение четверга.
['мысль', 'повсюду']
 

После компиляции вы вызываете метод re непосредственно для объекта регулярного выражения. В приведенном выше примере myre — это скомпилированный объект регулярного выражения, соответствующий r ‘\ w + ou \ w +’, и вы вызываете .findall () для него как myre.findall (). При этом вам теперь нужно указать только один аргумент, которым является целевая строка: myre.findall (дерево).

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

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

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

>>> ре.search (r'e + ',' Бесцветные зеленые идеи яростно спят ')
<объект _sre.SRE_Match в 0x02D9CB48>
>>> re.search (r'e + ', дерево)
>>>
 

Если вы хотите увидеть фактическую совпадающую часть, вы можете использовать метод .group (), определенный для объекта соответствия. Однако есть проблема: он отлично работает, когда есть совпадение, и поэтому объект совпадения был возвращен, но когда совпадения нет, нет возвращенного объекта, поэтому…

>>> re.search (r'e + ',' Бесцветные зеленые идеи яростно спят '). group ()
'е'
>>> re.search (r'e + ', дерево) .group ()

 

Следовательно, вы хотите использовать 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 = порази.поиск (б)
        если matchobj:
            напечатать matchobj.group (), '-', b,

порази - снова порази все живое, как это сделал я.
поразили - были с ним и поразили Рефаимов в Аштероф-Карнаиме, и
порази - руку Исава: я боюсь его, чтобы он, придя, не поразил меня, и
smote - 36:35 И умер Хушам и Хадад, сын Бедада, поразивший Мадиама в
smitest - Зачем ты поражаешь ближнего твоего? 2:14 И сказал он: кто тебя сделал
порази - 3:20 И простру руку мою, и поражу Египет всем моим
порази - вот, Я ударю жезлом, который в руке моей, по воде
поразил - посох и ударил по воде, которая в реке, на глазах
smite - 8: 2 И если ты откажешься отпустить их, вот, я поражу все твои
бей розгой и бей в пыль земную, чтобы сделалась она вшами.
смутный - с тобою из старейшин Израилевых; и жезл твой, которым ты пронзил
порази - и ударишь в скалу, и потечет из нее вода,
smiteth - 21:12 Тот, кто поразит человека так, что он умрет, непременно будет предан
smiteth - 21:15 И тот, кто поразит отца своего или мать свою, непременно будет
порази - 21:18 И если люди ссорятся, и один бьет другого камнем,
...
 

В этом примере мы хотим вычеркнуть все строки из Библии, в которых есть слово «порази / порази …». Сначала мы загружаем файл Библии как * список строк * с помощью метода .readlines (). И затем, поскольку мы будем выполнять сопоставление много раз, мы делаем умную вещь, компилируя наше регулярное выражение. Затем, проходя цикл по строкам Библии, мы создаем объект соответствия с помощью .search () и распечатываем совпадающую часть и строку только в том случае, если объект соответствия существует.

Регулярное выражение в Python — AskPython

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

1. Использование модуля Python re

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

1.1) re.search ()

re.search (pattern, str) используется для поиска последовательности pattern , которая является регулярным выражением, в пределах str (строка поиска) и возвращает совпадение, если образец найден.

Давайте посмотрим на примере того же

импорт ре

str = 'Это образец текста, который мы используем для поиска шаблона в тексте.'

pat = r'text '

match = re.search (pat, str)

если совпадение отсутствует:
    print ('Шаблон не найден')
еще:
    print ('Образец найден!')
    print ('Сопоставить объект', сопоставить)
 

Выход

Выкройка найдена!
Соответствующий объект 
 

Как вы можете видеть, выходные данные показывают, что действительно существует соответствие для шаблона. Мы искали простое слово text в str , а диапазон обозначает индексы совпадения.То есть совпадают str [17] str [20] , что соответствует подстроке текста , как и ожидалось. Но это дает только первое совпадение.

1.2) re.findall ()

Чтобы получить список всех совпавших строк, мы используем re.findall (pat, str) , чтобы вернуть список всех совпавших строк (который может быть пустым).

>>> match = re.findall (pat, str)
>>> print (совпадения)
['текст', 'текст']
 

рэ.findall () — чрезвычайно мощная функция для извлечения шаблонов, и ее можно использовать для чего угодно, например для поиска в файлах. Выполнить сопоставление в начале строки {1,3} Сопоставить, если количество повторений может быть от 1 до 3 раз {3} Соответствует, если количество повторений точно 3 раза {3,} Соответствует 3 или более раз [az ] Соответствует любому одиночному символу от a до z

Вот пример использования некоторых из приведенных выше правил.

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

импорт ре

str = 'В колледже обучается от 10 000 до 20 000 студентов. Это может означать что угодно. \ N '

pat = r'are {1,} \ s [a-z0-9, \ s] + '

match = re.search (pat, str)
совпадения = re.findall (pat, str)

если совпадение отсутствует:
    print ('Шаблон не найден')
еще:
    print ('Образец найден!')
    print ('Сопоставить объект', сопоставить)
    print ('Список всех совпадений:', совпадений)
 

Выход

Выкройка найдена!
Соответствующий объект 
Список всех совпадений: ["В колледже обучается от 10 000 до 20000 студентов"]
 

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

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

4. Список литературы

Введение в регулярные выражения в Python

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

Что такое регулярные выражения?

Регулярные выражения — это в основном просто последовательность символов, которая может использоваться для определения шаблона поиска для поиска текста. Эта «поисковая машина» встроена в язык программирования Python (а также во многие другие языки) и доступна через модуль re .

Чтобы использовать регулярные выражения (или для краткости «регулярное выражение»), вы обычно указываете правила для набора возможных строк, которым вы хотите сопоставить, а затем задаете себе такие вопросы, как «Соответствует ли эта строка шаблону?» Или «Есть ли там совпадение с шаблоном где-нибудь в этой строке? «.

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

Синтаксис регулярного выражения

Регулярное выражение определяет шаблон, который стремится соответствовать входной строке., $ , * , + , ? , {, } , [, ] , \ , | , ( и ) . Это связано с тем, что они используются для функций сопоставления более высокого порядка, которые описаны далее в этой таблице:

Метасимвол Описание
* Соответствует предыдущему элементу ноль или более раз.Например, ab * c соответствует «ac», «abc», «abbbc» и т. Д. [xyz] * соответствует «», «x», «y», «z», «zx», » zyx «,» xyzzy «и т. д. (ab) * соответствует «», «ab», «abab», «ababab» и так далее.
+ Соответствует предыдущему элементу один или более раз. Например, ab + c соответствует «abc», «abbc», «abbbc» и т. Д., Но не «ac».
? Соответствует предыдущему элементу ноль или один раз.Например, ab? C соответствует только «ac» или «abc».
| Оператор выбора (также известный как чередование или объединение набора) соответствует либо выражению до, либо выражению после этого оператора. Например, abc | def может соответствовать либо «abc», либо «def».
. Соответствует любому одиночному символу (многие приложения исключают новые строки, и какие именно символы считаются новыми строками, зависит от вкуса, кодировки символов и платформы, но можно с уверенностью предположить, что символ перевода строки включен). Соответствует позиции , начинающейся с позиции в строке, как и функция startWith () . В линейных инструментах он соответствует начальной позиции любой строки.
? Соответствует позиции , завершающей строки, или позиции непосредственно перед новой строкой, заканчивающейся строкой, как функция endWith () . В линейных инструментах он соответствует конечной позиции любой строки.

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

Методы регулярных выражений в Python

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

  1. повторное сопоставление ()
  2. re.search ()
  3. re.findall ()
  4. re.split ()
  5. re.sub ()
  6. re.компиляция ()
re.match (шаблон, строка, флаги = 0)

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

Выражение ниже вернет None , потому что Python не появляется в начале строки.

  # совпадение.ру

импорт ре
result = re.match (r'Python ',' Выучить Python легко. Python также имеет элегантный синтаксис ')

печать (результат)
  
  $ python match.py
Никто
  
re.search (шаблон, строка)

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

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

  # search.py

импорт ре

если re.search ("щенок", "Дейзи нашла щенка."):
    print ("Найден щенок")
еще:
    print ("Нет щенка")
  

Здесь мы сначала импортируем модуль re и используем его для поиска вхождения подстроки «щенок» в строке «Дейзи нашла щенка». Если он существует в строке, возвращается объект re.MatchObject, который считается «правдивым» при оценке в операторе if.

  $ python search.py
Найден щенок
  
re.компилировать (шаблон, флаги = 0)

Этот метод используется для компиляции шаблона регулярного выражения в объект регулярного выражения, который можно использовать для сопоставления с помощью методов match () и search () , которые мы обсуждали выше. Это также может сэкономить время, поскольку выполнение синтаксического анализа / обработки строк регулярных выражений может быть дорогостоящим в вычислительном отношении.

  # compile.py

импорт ре

шаблон = re.compile ('Python')
result = pattern.findall ('Pythonistas - это программисты, использующие Python, простой в освоении и мощный язык.')

печать (результат)

find = pattern.findall ('Python легко выучить')

распечатать (найти)
  
  $ python compile.py
['Python', 'Python']
['Python']
  

Обратите внимание, что возвращается только соответствующая строка, в отличие от всего слова в случае «Pythonistas». Это более полезно при использовании строки регулярного выражения, в которой есть специальные символы соответствия.

re.sub (шаблон, repl, строка)

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

  # sub.py

импорт ре
result = re.sub (r'python ',' ruby ​​',' python - очень простой язык ')

печать (результат)
  
  $ python sub.py
рубин - очень простой язык
  
re.findall (узор, строка)

Как вы видели до этого раздела, этот метод находит и извлекает список всех вхождений в данной строке. Он сочетает в себе функции и свойства re.search () и re.match () . В следующем примере из строки будут извлечены все вхождения «Python».

  # findall.py

импорт ре

result = re.findall (r'Python ',' Python - простой в освоении, мощный язык программирования. Python также имеет элегантный синтаксис ')
печать (результат)
  
  $ python findall.py
['Python', 'Python']
  

Опять же, использование строки точного соответствия, подобной этой («Python»), действительно полезно только для определения того, встречается ли строка регулярного выражения в данной строке или сколько раз она встречается.

re. products / (\ d +) / $

.)

  • (\ d +) означает, что будет число (указанное как \ d + ), и мы хотим, чтобы оно было захвачено и извлечено (указано в круглых скобках)
  • / сообщает Django, что за
  • должен следовать другой символ «/».

  • $ указывает конец URL-адреса, что означает, что только строки, заканчивающиеся на /, будут соответствовать этому шаблону
  • Проверка адресов электронной почты

    Каждая система аутентификации требует, чтобы пользователи зарегистрировались и вошли в систему, прежде чем им будет разрешен доступ к системе..]. * : Соответствует всем символам , кроме «.»

  • \. [A-z] {2,10} $ : сопоставление символов ДВУ домена (с максимальной длиной 10 символов) до конца строки.
  • Итак, как и следовало ожидать, код соответствует адресу в нашем примере:

      $ python validate_email.py
    Адрес электронной почты действителен
      
    Проверка телефонных номеров

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

      # validate_numbers.(\ +1? [-.]? (\ D +)) $ "), число):
            print («Номер недействителен»)
        еще:
            print («Номер действителен»)
      
      $ python validate_numbers.py
    Номер действителен
    Номер недействителен
      

    Как видите, поскольку второе число использует символ «=» вместо «+», оно считается недействительным.

    Фильтрация нежелательного содержимого

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

      # filter.py
    
    импорт ре
    
    curse_words = ["фу", "бар", "баз"]
    comment = "Эта строка содержит слово foo."
    curse_count = 0
    
    слово в curse_words:
        если re.search (слово, комментарий):
            curse_count + = 1
    
    print ("Комментарий содержит" + str (curse_count) + "проклятые слова.")
      
      $ python filter.py
    В комментарии 1 ругательство.
      

    Заключение

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

    Python Regex Найти все совпадения

    В этой статье мы узнаем, как найти все совпадения с регулярным выражением в Python. Метод re.findall () модуля RE просматривает шаблон регулярного выражения по всей целевой строке и возвращает все найденные совпадения в виде списка Python.

    Как использовать re.findall ()

    Прежде чем двигаться дальше, давайте посмотрим на синтаксис метода re.findall () .

    Синтаксис

      re.findall (шаблон, строка, флаги = 0)  
    1. шаблон : шаблон регулярного выражения, который мы хотим найти в строке или тексте
    2. строка : это переменная, указывающая на целевую строку (в которой мы хотим искать вхождения шаблона).
    3. Флаги : Относится к необязательным флагам. по умолчанию, флаги не применяются. Например, флаг re.I используется для выполнения поиска без учета регистра.

    Шаблон регулярного выражения и целевая строка являются обязательными аргументами, а флаги — необязательными.

    Возвращаемое значение

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

    Возвращает Нет , если не удается найти вхождения шаблона или такой шаблон не существует в целевой строке.

    Пример поиска всех совпадений с шаблоном регулярного выражения

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

    Схема : \ d +

    Что означает этот узор?

    • \ d — это специальная последовательность регулярных выражений, которая соответствует любой цифре от 0 до 9 в целевой строке.
    • Метасимвол + указывает, что число может содержать минимум одну или максимум любое количество цифр.

    Простыми словами, это означает, что соответствует любому числу внутри следующей целевой строки.

      target_string = "Эмма - баскетболистка, родилась 17 июня 1993 года. Она сыграла 112 матчей, набирая в среднем 26,12 очка за игру. Ее вес 51 кг."  

    Как мы видим в приведенной выше строке, числа ’17’, ‘1993’, ‘112’, ’26’, ’12’, ’51’ присутствуют, поэтому мы должны получить все эти числа на выходе.

    Пример

      импорт ре
    
    target_string = "Эмма - баскетболистка, родилась 17 июня 1993 года. Она сыграла 112 матчей, набирая в среднем 26,12 очка за игру. Ее вес 51 кг."
    результат = re.findall (r "\ d +", target_string)
    
    # распечатать все совпадения
    print ("Найдены следующие совпадения")
    печать (результат)
    
    # Вывод ['17', '1993', '112', '26', '12', '51']
      

    Примечание :

    Прежде всего, я использовал необработанную строку , чтобы указать шаблон регулярного выражения i.e r "\ d +" . Как вы, возможно, уже знаете, в некоторых случаях обратная косая черта имеет особое значение, потому что она может указывать на escape-символ или escape-последовательность, чтобы избежать использования необработанной строки .

    метод финдитера

    Метод re.finditer () работает точно так же, как метод re.findall () , за исключением того, что возвращает итератор, выдающий объекты сопоставления, соответствующие шаблону регулярного выражения , в строке вместо списка. Он просматривает строку слева направо, и совпадения возвращаются в форме итератора.Позже мы можем использовать этот объект-итератор для извлечения всех совпадений.

    Проще говоря, finditer () возвращает итератор по объектам MatchObject.

    Но зачем использовать finditer () ?

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

    Это означает, что finditer () возвращает вызываемый объект, который при вызове загружает результаты в память. Пожалуйста, обратитесь к этому ответу Stackoverflow, чтобы узнать о преимуществах производительности итераторов.

    пример finditer

    Теперь давайте посмотрим на примере, чтобы найти все две последовательные цифры внутри целевой строки.

      импорт ре
    
    target_string = "Эмма - баскетболистка, родившаяся 17 июня 1993 года. Она сыграла 112 матчей со средним количеством очков 26.12 очков за игру. Ее вес 51 кг ».
    
    # finditer () с шаблоном регулярного выражения и целевой строкой
    # \ d {2} для соответствия двум последовательным цифрам
    результат = re.finditer (r "\ d {2}", target_string)
    
    # выводим все совпадающие объекты
    для match_obj в результате:
        # выводим каждый объект re.Match
        печать (match_obj)
        
        # извлекаем каждое совпадающее число
        печать (match_obj.group ())  

    Выход :

     re.Match объект; промежуток = (49, 51), совпадение = '17 '
    17
    объект re.Match; промежуток = (53, 55), совпадение = '19 '
    19
    ре.Соответствующий объект; промежуток = (55, 57), совпадение = '93 '
    93
    объект re.Match; промежуток = (70, 72), совпадение = '11 '
    11
    объект re.Match; промежуток = (103, 105), совпадение = '26 '
    26
    объект re.Match; диапазон = (106, 108), совпадение = '12 '
    12
    объект re.Match; промежуток = (140, 142), совпадение = '51 '
    51 

    Больше использовать

    • Используйте finditer для поиска индексов всех совпадений регулярных выражений
    • Regex найдите все специальные символы из строки

    Regex найдите все слова, начинающиеся с определенных букв

    В этом примере мы увидим решение следующих 2 сценариев

    1. найти все слова, начинающиеся с определенной буквы / символа
    2. найти все слова, начинающиеся с определенной подстроки

    Теперь предположим, что у вас есть следующая строка:

      target_string = "Джесса - разработчик Python.Она также проводит тренинг по программированию на Python " 

    Теперь давайте найдем все слова, которые начинаются с буквы p . Также найдите все слова, которые начинаются с подстроки « py »

    .

    Шаблон : \ b [p] \ w + \ b

    • \ b — это граница слова, затем p в квадратной скобке [] означает, что слово должно начинаться с буквы « p ».
    • Далее, \ w + означает один или несколько буквенно-цифровых символов после буквы «p»
    • В конце мы использовали \ b для обозначения границы слова i.е. конец слова.

    Пример

      импорт ре
    
    target_string = "Джесса - разработчик Python. Она также обучает программированию на Python"
    # все слово начинается с буквы 'p'
    print (re.findall (r '\ b [p] \ w + \ b', target_string, re.I))
    # output ['Python', 'Python', 'программирование']
    
    # все слово начинается с подстроки Py
    print (re.findall (r '\ bpy \ w + \ b', target_string, re.I))
    # output ['Python', 'Python']  

    Регулярное выражение для поиска всех слов, которые начинаются и заканчиваются определенной буквой

    В этом примере мы увидим решение следующих 2 сценариев

    1. найти все слова, которые начинаются и заканчиваются определенной буквой
    2. найти все слова, которые начинаются и заканчиваются определенной подстрокой

    Пример

      импорт ре
    
    target_string = "Джесса - разработчик Python.Она также обучает программированию на Python "
    # все слова начинаются с буквы 'p' и заканчиваются буквой 'g'
    print (re.findall (r '\ b [p] \ w + [g] \ b', target_string, re.I))
    # вывод 'программирование'
    
    # все слова начинаются с буквы 'p' или 't' и заканчиваются буквой 'g'
    print (re.findall (r '\ b [pt] \ w + [g] \ b', target_string, re.I))
    # output ['программирование', 'обучение']
    
    target_string = "Джесса любит манго и апельсин"
    # все слово начинается с подстроки 'ma' и заканчивается подстрокой 'go'
    print (re.findall (r '\ bma \ w + go \ b', target_string, re.Я))
    # вывод 'манго'
    
    target_string = "Келли любит банан и яблоко"
    # все слово начинается или заканчивается буквой 'а'
    print (re.findall (r '\ b [a] \ w + \ b | \ w + [a] \ b', target_string, re.I))
    # output ['banana', 'and', 'apple']  

    Regex для поиска всех слов, содержащих определенную букву

    В этом примере мы увидим, как найти слова, содержащие букву «i».

      импорт ре
    
    target_string = "Джесса знает толк в тестировании и машинном обучении"
    # найти все слова, содержащие букву 'i'
    печать (re.findall (r '\ b \ w * [i] \ w * \ b', target_string, re.I))
    # найдено ['is', 'testing', 'machine', 'learning']
    
    # найти все слова, содержащие подстроку 'ing'
    print (re.findall (r '\ b \ w * ing \ w * \ b', target_string, re.I))
    # найдено ['тестирование', 'обучение']  

    Regex найти все повторяющиеся символы

    Например, у вас есть строка: "" Jessa Erriika ""

    В результате вы хотите иметь следующие совпадения: (J, e, ss, a, E, rr, ii, k, a)

    Пример

      импорт ре
    
    target_string = "Джесса Эрриика"
    # Этот '\ w' соответствует любому одиночному символу
    # а затем его повторы (\ 1 *), если есть.matcher = re.compile (r "(\ w) \ 1 *")
    
    для совпадения в matcher.finditer (target_string):
        print (match.group (), end = ",")
    # вывод J, e, ss, a, E, rr, ii, k, a,  

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

    — ThePythonGuru.com

    1. Дом
    2. Блог
    3. Регулярное выражение Python

    (Спонсоры) Начните изучать Python с помощью DataCamp’s
    бесплатный вводный курс по Python.Изучите науку о данных, выполняя интерактивные задания по кодированию и просматривая видео опытных инструкторов.
    Начинай сейчас!