Регулярные выражения в python
Содержание:
- Common Problems¶
- Наиболее распространенный синтаксис и шаблоны регулярных выражений
- Modifying Strings¶
- Методы объекта сопоставления Match:
- Как заменить один текст на другой, используя регулярные выражения?
- Apple Music теперь официально работает в любом браузере
- Шаблоны регулярных выражений
- And now for something completely different
- Поисковые системы
- Match Object
- The search Function
- Сложности с обратными косыми
- Разность re.match и re.search
- Как пользоваться ADB run
- Находим множественные совпадения
- Функция match
- Основы синтаксиса
- Примеры регулярных выражений
- Search and Replace
Common Problems¶
Regular expressions are a powerful tool for some applications, but in some ways
their behaviour isn’t intuitive and at times they don’t behave the way you may
expect them to. This section will point out some of the most common pitfalls.
Use String Methods
Sometimes using the module is a mistake. If you’re matching a fixed
string, or a single character class, and you’re not using any features
such as the flag, then the full power of regular expressions
may not be required. Strings have several methods for performing operations with
fixed strings and they’re usually much faster, because the implementation is a
single small C loop that’s been optimized for the purpose, instead of the large,
more generalized regular expression engine.
One example might be replacing a single fixed string with another one; for
example, you might replace with . seems like the
function to use for this, but consider the method. Note that
will also replace inside words, turning
into , but the naive RE would have done that, too. (To
avoid performing the substitution on parts of words, the pattern would have to
be , in order to require that have a word boundary on
either side. This takes the job beyond ’s abilities.)
Another common task is deleting every occurrence of a single character from a
string or replacing it with another single character. You might do this with
something like , but is capable of
doing both tasks and will be faster than any regular expression operation can
be.
In short, before turning to the module, consider whether your problem
can be solved with a faster and simpler string method.
match() versus search()
The function only checks if the RE matches at the beginning of the
string while will scan forward through the string for a match.
It’s important to keep this distinction in mind. Remember, will
only report a successful match which will start at 0; if the match wouldn’t
start at zero, will not report it.
>>> print(re.match('super', 'superstition').span())
(0, 5)
>>> print(re.match('super', 'insuperable'))
None
On the other hand, will scan forward through the string,
reporting the first match it finds.
>>> print(re.search('super', 'superstition').span())
(0, 5)
>>> print(re.search('super', 'insuperable').span())
(2, 7)
Sometimes you’ll be tempted to keep using , and just add
to the front of your RE. Resist this temptation and use
instead. The regular expression compiler does some analysis of REs in order to
speed up the process of looking for a match. One such analysis figures out what
the first character of a match must be; for example, a pattern starting with
must match starting with a . The analysis lets the engine
quickly scan through the string looking for the starting character, only trying
the full match if a is found.
Adding defeats this optimization, requiring scanning to the end of the
string and then backtracking to find a match for the rest of the RE. Use
instead.
Greedy versus Non-Greedy
When repeating a regular expression, as in , the resulting action is to
consume as much of the pattern as possible. This fact often bites you when
you’re trying to match a pair of balanced delimiters, such as the angle brackets
surrounding an HTML tag. The naive pattern for matching a single HTML tag
doesn’t work because of the greedy nature of .
>>> s = '<html><head><title>Title</title>'
>>> len(s)
32
>>> print(re.match('<.*>', s).span())
(0, 32)
>>> print(re.match('<.*>', s).group())
<html><head><title>Title</title>
The RE matches the in , and the consumes the rest of
the string. There’s still more left in the RE, though, and the can’t
match at the end of the string, so the regular expression engine has to
backtrack character by character until it finds a match for the . The
final match extends from the in to the in
, which isn’t what you want.
In this case, the solution is to use the non-greedy qualifiers , ,
, or , which match as little text as possible. In the above
example, the is tried immediately after the first matches, and
when it fails, the engine advances a character at a time, retrying the
at every step. This produces just the right result:
>>> print(re.match('<.*?>', s).group())
<html>
(Note that parsing HTML or XML with regular expressions is painful.
Quick-and-dirty patterns will handle common cases, but HTML and XML have special
cases that will break the obvious regular expression; by the time you’ve written
a regular expression that handles all of the possible cases, the patterns will
be very complicated. Use an HTML or XML parser module for such tasks.)
Наиболее распространенный синтаксис и шаблоны регулярных выражений
Теперь, когда вы знаете как пользоваться модулем re, давайте рассмотрим некоторые обычно используемые шаблоны подстановок.
Основной синтаксис
| . | Один символ кроме новой строки |
| \. | Просто точка , обратный слеш убирает магию всех специальных символов. |
| \d | Одна цифра |
| \D | Один символ кроме цифры |
| \w | Один буквенный символ, включая цифры |
| \W | Один символ кроме буквы и цифры |
| \s | Один пробельный (включая таб и перенос строки) |
| \S | Один не пробельный символ |
| \b | Границы слова |
| \n | Новая строка |
| \t | Табуляция |
Модификаторы
| $ | Конец строки |
| ^ | Начало строки |
| ab|cd | Соответствует ab или de. |
| Один символ: a, b, c, d | |
| Любой символ, кроме: a, b, c, d | |
| () | Извлечение элементов в скобках |
| (a(bc)) | Извлечение элементов в скобках второго уровня |
Повторы
| {2} | 2 непрерывных появления a или b |
| {2,5} | от 2 до 5 непрерывных появления a или b |
| {2,} | 2 и больше непрерывных появления a или b |
| + | одно или больше |
| * | 0 или больше |
| ? | 0 или 1 |
Modifying Strings¶
Up to this point, we’ve simply performed searches against a static string.
Regular expressions are also commonly used to modify strings in various ways,
using the following pattern methods:
|
Method/Attribute |
Purpose |
|---|---|
|
Split the string into a list, splitting it |
|
|
Find all substrings where the RE matches, and |
|
|
Does the same thing as , but |
Splitting Strings
The method of a pattern splits a string apart
wherever the RE matches, returning a list of the pieces. It’s similar to the
method of strings but provides much more generality in the
delimiters that you can split by; string only supports splitting by
whitespace or by a fixed string. As you’d expect, there’s a module-level
function, too.
- (string, maxsplit=0)
-
Split string by the matches of the regular expression. If capturing
parentheses are used in the RE, then their contents will also be returned as
part of the resulting list. If maxsplit is nonzero, at most maxsplit splits
are performed.
You can limit the number of splits made, by passing a value for maxsplit.
When maxsplit is nonzero, at most maxsplit splits will be made, and the
remainder of the string is returned as the final element of the list. In the
following example, the delimiter is any sequence of non-alphanumeric characters.
>>> p = re.compile(r'\W+')
>>> p.split('This is a test, short and sweet, of split().')
>>> p.split('This is a test, short and sweet, of split().', 3)
Sometimes you’re not only interested in what the text between delimiters is, but
also need to know what the delimiter was. If capturing parentheses are used in
the RE, then their values are also returned as part of the list. Compare the
following calls:
>>> p = re.compile(r'\W+')
>>> p2 = re.compile(r'(\W+)')
>>> p.split('This... is a test.')
>>> p2.split('This... is a test.')
The module-level function adds the RE to be used as the first
argument, but is otherwise the same.
>>> re.split(r'+', 'Words, words, words.') >>> re.split(r'(+)', 'Words, words, words.') >>> re.split(r'+', 'Words, words, words.', 1)
Методы объекта сопоставления Match:
Метод возвращает строку, полученную путем подстановки обратной косой черты в шаблоне строки регулярного выражения, как это сделано методом sub(). Экранированные символы, такие как , преобразуются в соответствующие символы, а числовые обратные ссылки (, ) и именованные обратные ссылки (, ) заменяются содержимым соответствующей группы.
Метод возвращает одну или несколько подгрупп совпадения. При наличии одного аргумента результатом будет одна строка, при наличии нескольких аргументов результатом будет кортеж с одним элементом на аргумент. Без аргументов группа 1 по умолчанию равна нулю — возвращается все совпадение.
- Если аргумент равен нулю, то соответствующее возвращаемое значение является всей соответствующей строкой;
- Если номер группы находится в инклюзивном диапазоне , это строка, соответствующая соответствующей группе скобок.
- Если номер группы отрицателен или больше, чем число групп, определенных в шаблоне, возникает исключение IndexError.
- Если группа содержится в части шаблона, которая не соответствует, то соответствующий результат — .
- Если группа содержится в части шаблона, которая совпала несколько раз, возвращается последнее совпадение.
>>> import re
>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
# Совпадение со всем шаблоном
>>> m.group()
# 'Isaac Newton'
# Первая группа
>>> m.group(1)
# 'Isaac'
# Вторая группа
>>> m.group(2)
# 'Newton'
# Можно указывать несколько групп
>>> m.group(1, 2)
# ('Isaac', 'Newton')
Если регулярное выражение использует синтаксис , аргументы также могут быть строками, идентифицирующими группы по имени группы. Если строковый аргумент не используется в качестве имени группы в шаблоне регулярного выражения, возникает исключение IndexError.
Умеренно сложный пример:
>>> import re
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.group('first_name')
# 'Malcolm'
>>> m.group('last_name')
# 'Reynolds'
На именованные группы также можно ссылаться по их индексу:
>>> m.group(1) # 'Malcolm' >>> m.group(2) # 'Reynolds'
Если группа совпадает несколько раз, доступно только последнее совпадение:
>>> import re >>> m = re.match(r"(..)+", "a1b2c3") # 3 совпадения шаблона со строкой >>> m.group() # 'a1b2c3' # для извлечения доступно только последнее >>> m.group(1) # 'c3'
Метод идентичен , что позволяет легче получить доступ к отдельной группе из объекта сопоставления:
>>> import re >>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist") # полное совпадение >>> m 'Isaac Newton' # Первая заключенная в скобки подгруппа. >>> m1 # 'Isaac' # Вторая заключенная в скобки подгруппа. >>> m2 # 'Newton'
Метод вернет кортеж, содержащий все подгруппы совпадения, от 1 до любого количества групп в шаблоне. Аргумент используется для групп, которые не смогли захватить какой либо результат при сканировании строки и по умолчанию будут равны .
>>> import re
>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups()
# ('24', '1632')
Если сделать десятичную точку и все, что после нее необязательным, то не все группы получат результат захвата. Эти группы по умолчанию будут иметь значение :
>>> import re
>>> m = re.match(r"(\d+)\.?(\d+)?", "24")
# 2 группа по умолчанию None.
>>> m.groups()
# ('24', None)
# теперь 2 группа по умолчанию '0'.
>>> m.groups('0')
# ('24', '0')
Метод возвращает словарь, содержащий все именованные подгруппы совпадения, помеченные именем подгруппы . Аргумент используется для групп, которые не смогли захватить какой либо результат при сканировании строки и по умолчанию будут равны .
>>> import re
>>> m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
>>> m.groupdict()
# {'first_name': 'Malcolm', 'last_name': 'Reynolds'}
, :
Методы возвращают индексы начала и конца подстроки совпадающей с группой . По умолчанию группа равна нулю, имеется в виду вся совпадающая подстрока. Методы возвращают , если группа существует, но не смогла захватить какой либо результат. Для объекта сопоставления и группы , которая внесла свой вклад в сопоставление, подстрока, сопоставленная группе эквивалентная , является:
m.stringm.start(g):m.end(g)]
Обратите внимание, что будет равно , если группа соответствует нулевой строке. Например после выполнения , будет равно 1, это 2
и равны 2, а вызывает исключение .
Пример, который удалит из адресов электронной почты:
>>> email = "tony@tiremove_thisger.net"
>>> m = re.search("remove_this", email)
>>> email + emailm.end():]
# 'tony@tiger.net'
Метод вернет двойной кортеж вида
Обратите внимание, что если группа не внесла свой вклад в совпадение, то результатом будет кортеж. По умолчанию группа равна нулю, имеется в виду вся совпадающая подстрока
Как заменить один текст на другой, используя регулярные выражения?
Для изменения текста, используйте .
Рассмотрим следующую измененную версию текста курсов. Здесь добавлена табуляция после каждого кода курса.
Из вышеприведенного текста я хочу удалить все лишние пробелы и записать все слова в одну строку.
Для этого нужно просто использовать для замены шаблона на один пробел .
или
Предположим, вы хотите избавиться от лишних пробелов и выводить записи курса с новой строки. Чтобы это сделать, используйте регулярное выражение, которое пропускает символ новой строки, но учитывает все другие пробелы.
Это можно сделать, используя отрицательное соответствие . Шаблон проверяет наличие символа новой строки, в python это , и пропускает его.
Apple Music теперь официально работает в любом браузере
Шаблоны регулярных выражений
За исключением символов (+?. * ^ $ () [] {} | ), все остальные соответствуют самим себе. Вы можете избежать экранировать специальный символ с помощью бэкслеша ().
В таблицах ниже описаны все символы и комбинации символов для регулярных выражений, которые доступны в Python:
| № | Шаблон & Описание |
|---|---|
| 1 | ^ — соответствует началу строки. |
| 2 | $— соответствует концу строки. |
| 3 | . — соответствует любому символу, кроме новой строки. Использование флага re.M позволяет также соответствовать новой строке. |
| 4 | — соответствует любому из символов в скобках. |
| 5 | — соответствует любому символу, кроме тех, что в квадратных скобках. |
| 6 | foo* — соответствует 0 или более вхождений “foo”. |
| 7 | bar+ —- соответствует 1 или более вхождениям “bar”. |
| 8 | foo? —- соответствует 0 или 1 вхождению “foo”. |
| 9 | bar{3} —- соответствует трем подряд вхождениям “bar”. |
| 10 | foo{3,} — соответствует 3 или более вхождениям “foo”. |
| 11 | bar{2,5} —- соответствует от 2 до 5 вхождениям “bar”. |
| 12 | a|b — соответствует либо a, либо b. |
| 13 | (foo) — группирует регулярные выражения. |
| 14 | (?imx) — временно включает параметры i, m или x в регулярное выражение. Если используются круглые скобки — затрагивается только эта область. |
| 15 | (?-imx) — временно отключает опции i, m или x в регулярном выражении. Если используются круглые скобки — затрагивается только эта область. |
| 16 | (?: foo) — Группирует регулярные выражения без сохранения совпадающего текста. |
| 17 | (?imx: re) — Временно включает параметры i, m или x в круглых скобках. |
| 18 | (?-imx: re) — временно отключает опции i, m или x в круглых скобках. |
| 19 | (?#…) — комментарий. |
| 20 | (?= foo) — совпадает со всеми словами после которых » foo». |
| 21 | (?! foo) — совпадает со всеми словами после которых нет » foo». |
| 22 | (?> foo) — совпадает со всеми словами перед которыми » foo». |
| 23 | \w — совпадает с буквенным символом. |
| 24 | \W — совпадает с не буквенным символом. |
| 25 | \s — совпадает с пробельными символами (\t, \n, \r, \f и пробелом). |
| 26 | \S — все кроме пробельных символов. |
| 27 | \d — соответствует цифрам (0-9). |
| 28 | \D — все кроме цифры. |
| 29 | \A — соответствует началу строки. |
| 30 | \Z – соответствует концу строки. Включая перевод на новую строку, если такая есть. |
| 31 | \z — соответствует концу строки. |
| 32 | \G — соответствует месту, где закончилось последнее соответствие. |
| 33 | \b — соответствует границам слов, когда поставлены внешние скобки. |
| 34 | \B — все кроме границы слова. |
| 35 | **\n,\t,\r,\f ** — соответствует новым строкам, подстрокам. |
| 36 | \1…\9 — соответствует подгруппе n-й группы. |
| 37 | \10 — соответсвуйет номеру группы. В противном случае относится к восьмеричному представлению символьного кода. |
And now for something completely different
trong>Wapcaplet: (John Cleese) Welcome! Do sit down. My name’s Wapcaplet, Adrian Wapcaplet.
Mr. Simpson: how’d’y’do.
Wapcaplet: Now, Mr. Simpson… Now, I understand you want us to advertise your washing powder.
S: String.
W: String, washing powder, what’s the difference. We can sell anything.
S: Good. Well I have this large quantity of string, a hundred and twenty-two thousand miles of it to be exact, which I inherited, and I thought if I advertised it…
W: Of course! A national campaign. Useful stuff, string, no trouble there.
S: Ah, but there’s a snag, you see. Due to bad planning, the hundred and twenty-two thousand miles is in three inch lengths. So it’s not very useful.
W: Well, that’s our selling point! ‘SIMPSON’S INDIVIDUAL STRINGETTES!’
S: What?
W: ‘THE NOW STRING! READY CUT, EASY TO HANDLE, SIMPSON’S INDIVIDUAL EMPEROR STRINGETTES — JUST THE RIGHT LENGTH!’
S: For what?
W: ‘A MILLION HOUSEHOLD USES!’
S: Such as?
W: Uhmm…Tying up very small parcels, attatching notes to pigeons’ legs, uh, destroying household pests…
S: Destroying household pests?! How?
W: Well, if they’re bigger than a mouse, you can strangle them with it, and if they’re smaller than, you flog them to death with it!
S: Well surely!….
W: ‘DESTROY NINETY-NINE PERCENT OF KNOWN HOUSEHOLD PESTS WITH PRE-SLICED, RUSTPROOF, EASY-TO-HANDLE, LOW CALORIE SIMPSON’S INDIVIDUAL EMPEROR STRINGETTES, FREE FROM ARTIFICIAL COLORING, AS USED IN HOSPITALS!’
| Version | Operating System | Description | MD5 Sum | File Size | GPG |
|---|---|---|---|---|---|
| Gzipped source tarball | Source release | e19e75ec81dd04de27797bf3f9d918fd | 26724009 | SIG | |
| XZ compressed source tarball | Source release | 6ebfe157f6e88d9eabfbaf3fa92129f6 | 18866140 | SIG | |
| macOS 64-bit installer | Mac OS X | for OS X 10.9 and later | 16ca86fa3467e75bade26b8a9703c27f | 31132316 | SIG |
| Windows help file | Windows | 9ea6fc676f0fa3b95af3c5b3400120d6 | 8757017 | SIG | |
| Windows x86-64 embeddable zip file | Windows | for AMD64/EM64T/x64 | 60d0d94337ef657c2cca1d3d9a6dd94b | 8387074 | SIG |
| Windows x86-64 executable installer | Windows | for AMD64/EM64T/x64 | b61a33dc28f13b561452f3089c87eb63 | 28158664 | SIG |
| Windows x86-64 web-based installer | Windows | for AMD64/EM64T/x64 | 733df85afb160482c5636ca09b89c4c8 | 1364352 | SIG |
| Windows x86 embeddable zip file | Windows | d81fc534080e10bb4172ad7ae3da5247 | 7553872 | SIG | |
| Windows x86 executable installer | Windows | 4a2812db8ab9f2e522c96c7728cfcccb | 27066912 | SIG | |
| Windows x86 web-based installer | Windows | cdbfa799e6760c13d06d0c2374110aa3 | 1327384 | SIG |
Поисковые системы
Match Object
A Match Object is an object containing information
about the search and the result.
Note: If there is no match, the value will be
returned, instead of the Match Object.
Example
Do a search that will return a Match Object:
import retxt = «The rain in Spain»x = re.search(«ai»,
txt)
print(x) #this will print an object
The Match object has properties and methods used to retrieve information
about the search, and the result:
returns a tuple containing the start-, and end positions of the match. returns the string passed into the function returns the part of the string where there was a match
Example
Print the position (start- and end-position) of the first match occurrence.
The regular expression looks for any words that starts with an upper case
«S»:
import re
txt = «The rain in Spain»
x = re.search(r»\bS\w+», txt)
print(x.span())
Example
Print the string passed into the function:
import re
txt = «The rain in Spain»
x = re.search(r»\bS\w+», txt)
print(x.string)
Example
Print the part of the string where there was a match.
The regular expression looks for any words that starts with an upper case
«S»:
import re
txt = «The rain in Spain»
x = re.search(r»\bS\w+», txt)
print(x.group())
Note: If there is no match, the value will be
returned, instead of the Match Object.
❮ Previous
Next ❯
The search Function
This function searches for first occurrence of RE pattern within string with optional flags.
Here is the syntax for this function −
re.search(pattern, string, flags=0)
Here is the description of the parameters −
| Sr.No. | Parameter & Description |
|---|---|
| 1 |
pattern This is the regular expression to be matched. |
| 2 |
string This is the string, which would be searched to match the pattern anywhere in the string. |
| 3 |
flags You can specify different flags using bitwise OR (|). These are modifiers, which are listed in the table below. |
The re.search function returns a match object on success, none on failure. We use group(num) or groups() function of match object to get matched expression.
| Sr.No. | Match Object Methods & Description |
|---|---|
| 1 |
group(num=0) This method returns entire match (or specific subgroup num) |
| 2 |
groups() This method returns all matching subgroups in a tuple (empty if there weren’t any) |
Example
#!/usr/bin/python import re line = "Cats are smarter than dogs"; searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I) if searchObj: print "searchObj.group() : ", searchObj.group() print "searchObj.group(1) : ", searchObj.group(1) print "searchObj.group(2) : ", searchObj.group(2) else: print "Nothing found!!"
When the above code is executed, it produces following result −
searchObj.group() : Cats are smarter than dogs searchObj.group(1) : Cats searchObj.group(2) : smarter
Сложности с обратными косыми
Обратные косые немного усложняют жизнь в мире регулярных выражений Python. Это связанно с тем, что регулярные выражения используют обратные косые для определения специальных форм, или для того, чтобы искать определенный символ, вместо того, чтобы вызывать его. Как если бы мы искали символ доллара $. Если мы не используем обратную косую для этого, нам нужно просто создать анкор. Проблема возникает по той причине, что Python использует символ обратной косой по той же причине в литеральных строках.
Давайте представим, что вам нужно найти строку на подобии этой: «python». Для её поиска в регулярном выражении, вам нужно будет использовать обратную косую, но, так как Python также использует обратную косую, так что на выходе вы получите следующий поисковый паттерн: «\\python» (без скобок). К счастью, Python поддерживает сырые строки, путем подстановки буквы r перед строкой. Так что мы можем сделать выдачу более читабельной, введя следующее: r”\python”. Так что если вам нужно найти что-то с обратной косой в названии, убедитесь, что используете сырые строки для этой цели, иначе можете получить совсем не то, что ищете.
Разность re.match и re.search
re.match соответствует только начало строки, если начало строки не соответствует регулярному выражению, совпадение не найдено, функция возвращает None, и re.search совпадают со строкой, пока не найдет совпадения.
Пример:
#!/usr/bin/python3
import re
line = "Cats are smarter than dogs";
matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
print ("match --> matchObj.group() : ", matchObj.group())
else:
print ("No match!!")
matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
print ("search --> matchObj.group() : ", matchObj.group())
else:
print ("No match!!")
No match!! search --> matchObj.group() : dogs
Как пользоваться ADB run
Находим множественные совпадения
До этого момента мы научились только находить первое совпадение в строке. Но что если у вас строка, в которой содержится множество совпадений? Давайте посмотрим, как найти одно:
Python
import re
silly_string = «the cat in the hat»
pattern = «the»
match = re.search(pattern, text)
print(match.group()) # ‘the’
|
1 |
importre silly_string=»the cat in the hat» pattern=»the» match=re.search(pattern,text) print(match.group())# ‘the’ |
Теперь, как вы видите, у нас есть два экземпляра слова the, но нашли мы только одно. Существует два метода, чтобы найти все совпадения. Первый, который мы рассмотрим, это использование функции findall:
Python
import re
silly_string = «the cat in the hat»
pattern = «the»
a = re.findall(pattern, silly_string)
print(a) #
|
1 |
importre silly_string=»the cat in the hat» pattern=»the» a=re.findall(pattern,silly_string) print(a)# |
Функция findall будет искать по всей переданной ей строке, и впишет каждое совпадение в список. По окончанию поиска вышей строки, она выдаст список совпадений. Второй способ найти несколько совпадений, это использовать функцию finditer:
Python
import re
silly_string = «the cat in the hat»
pattern = «the»
for match in re.finditer(pattern, silly_string):
s = «Found ‘{group}’ at {begin}:{end}».format(
group=match.group(), begin=match.start(),
end=match.end())
print(s)
|
1 |
importre silly_string=»the cat in the hat» pattern=»the» formatch inre.finditer(pattern,silly_string) s=»Found ‘{group}’ at {begin}:{end}».format( group=match.group(),begin=match.start(), end=match.end()) print(s) |
Как вы могли догадаться, метод finditer возвращает итератор экземпляров Match, вместо строк, которые мы получаем от findall. Так что нам нужно немного подформатировать результаты перед их выводом. Попробуйте запустить данный код и посмотрите, как он работает.
Функция match
Эта функция ищет в и поддерживает настройки с помощью дополнительного .
Ниже можно увидеть синтаксис данной функции:
Описание параметров:
| № | Параметр & Описание |
|---|---|
| 1 | pattern — строка регулярного выражения () |
| 2 | string — строка, в которой мы будем искать соответствие с шаблоном в начале строки () |
| 3 | flags — модификаторы, перечисленными в таблице ниже. Вы можете указать разные флаги с помощью побитового OR |
Функция возвращает объект при успешном завершении, или при ошибке. Мы используем функцию или объекта для получения результатов поиска.
| № | Метод совпадения объектов и описание |
|---|---|
| 1 | group(num=0) — этот метод возвращает полное совпадение (или совпадение конкретной подгруппы) |
| 2 | groups() — этот метод возвращает все найденные подгруппы в tuple |
Основы синтаксиса
экранировать
Шаблоны, соответствующие одному символу
| Шаблон | Описание | Пример | Применяем к тексту |
|---|---|---|---|
| Один любой символ, кроме новой строки . |
молоко, малако, Им0л0коИхлеб |
||
| Любая цифра | СУ35, СУ111, АЛСУ14 | ||
| Любой символ, кроме цифры | 926)123, 1926-1234 | ||
| Любой пробельный символ (пробел, табуляция, конец строки и т.п.) |
бор ода, бор ода, борода |
||
| Любой непробельный символ | X123, я123, !123456, 1 + 123456 | ||
| Любая буква (то, что может быть частью слова), а также цифры и | Год, f_3, qwert | ||
| Любая не-буква, не-цифра и не подчёркивание | сом!, сом? | ||
| Один из символов в скобках, а также любой символ из диапазона |
12, 1F, 4B | ||
| Любой символ, кроме перечисленных | <1>, <a>, <>> | ||
| Буква “ё” не включается в общий диапазон букв! Вообще говоря, в включается всё, что в юникоде помечено как «цифра», а в — как буква. Ещё много всего! |
|||
| если нужен минус, его нужно указать последним или первым | |||
| внутри скобок нужно экранировать только и | |||
| Начало или конец слова (слева пусто или не-буква, справа буква и наоборот). В отличие от предыдущих соответствует позиции, а не символу |
вал, перевал, Перевалка | ||
| Не граница слова: либо и слева, и справа буквы, либо и слева, и справа НЕ буквы |
перевал, вал, Перевалка | ||
| перевал, вал, Перевалка |
Квантификаторы (указание количества повторений)
| Шаблон | Описание | Пример | Применяем к тексту |
|---|---|---|---|
| Ровно n повторений | 1, 12, 123, 1234, 12345 | ||
| От m до n повторений включительно | 1, 12, 123, 1234, 12345 | ||
| Не менее m повторений | 1, 12, 123, 1234, 12345 | ||
| Не более n повторений | 1, 12, 123 | ||
| Ноль или одно вхождение, синоним | вал, валы, валов | ||
| Ноль или более, синоним | СУ, СУ1, СУ12, … | ||
| Одно или более, синоним | a), a)), a))), ba)]) | ||
| По умолчанию квантификаторы жадные — захватывают максимально возможное число символов. Добавление делает их ленивыми, они захватывают минимально возможное число символов |
(a + b) * (c + d) * (e + f)(a + b) * (c + d) * (e + f) |
Жадность в регулярках и границы найденного шаблона
Как указано выше, по умолчанию квантификаторы жадные. Этот подход решает очень важную проблему — проблему границы шаблона. Скажем, шаблон захватывает максимально возможное количество цифр. Поэтому можно быть уверенным, что перед найденным шаблоном идёт не цифра, и после идёт не цифра. Однако если в шаблоне есть не жадные части (например, явный текст), то подстрока может быть найдена неудачно. Например, если мы хотим найти «слова», начинающиеся на , после которой идут цифры, при помощи регулярки , то мы найдём и неправильные шаблоны:
Примеры регулярных выражений
Классы персонажей
| примеров | описание |
|---|---|
| ython | Matching «Python» или «Python» |
| руб | Матч «Рубин» или «деревенщина» |
| Любой из букв в скобках соответствия | |
| Соответствует любой цифре. Аналогично | |
| Соответствует любому строчных букв | |
| Соответствует любой верхний регистр | |
| Матчи любые буквы и цифры | |
| В дополнение ко всем, кроме букв символов аеиоу | |
| Соответствующие символы, кроме цифр |
Специальные классы символов
| примеров | описание |
|---|---|
| , | Соответствует любому одному символу, кроме «\ п» есть. Для того, чтобы соответствовать в том числе ‘\ N’, в том числе любые символы, такие, как использование » режим. |
| \ D | Совпадает с цифрой. Эквивалент . |
| \ D | Соответствует не цифровых символов. Это эквивалентно . |
| \ S | Соответствует пробельные символы, включая пробелы, символы табуляции, разрывы страниц, и так далее. Эквивалентно . |
| \ S | Соответствует непробельного символы. Эквивалентно . |
| \ W | Любое слово символ, включая подчеркивание. Это эквивалентно » ‘. |
| \ W | Соответствует любому символу, кроме буквы. Это эквивалентно ». |
Предыдущая: python3 os.write метод ()
Далее: python3 CGI программирование
Search and Replace
One of the most important re methods that use regular expressions is sub.
Syntax
re.sub(pattern, repl, string, max=0)
This method replaces all occurrences of the RE pattern in string with repl, substituting all occurrences unless max provided. This method returns modified string.
Example
#!/usr/bin/python import re phone = "2004-959-559 # This is Phone Number" # Delete Python-style comments num = re.sub(r'#.*$', "", phone) print "Phone Num : ", num # Remove anything other than digits num = re.sub(r'\D', "", phone) print "Phone Num : ", num
When the above code is executed, it produces the following result −
Phone Num : 2004-959-559 Phone Num : 2004959559
