# re

{% embed url="<https://docs.python.org/3/library/re.html>" %}

#### Див. також: [Регулярные выражения в Python от простого к сложному](https://habr.com/ru/articles/349860/) (Хабр)

## match

#### re.match(pattern, string)

Цей метод шукає за заданим шаблоном на початку рядка. Наприклад, якщо ми викличемо метод `match()`на рядку «AV Analytics AV» із шаблоном «AV», він завершиться успішно. Але якщо ми шукатимемо Analytics, то результат буде негативний:

```python
import re
result = re.match(r'AV', 'AV Analytics Vidhya AV')
print result

Результат:
<_sre.SRE_Match object at 0x0000000009BE4370>
```

Шуканий підряд знайдено. Щоб вивести її вміст, застосуємо метод `group()`(ми використовуємо "r" перед рядком шаблону, щоб показати, що це "сира" рядок у Python):

```python
result = re.match(r'AV', 'AV Analytics Vidhya AV')
print result.group(0)

Результат:
AV
```

Тепер спробуємо знайти «Analytics» у цьому рядку. Оскільки рядок починається на «AV», метод поверне `None`:

```python
result = re.match(r'Analytics', 'AV Analytics Vidhya AV')
print result

Результат:
None
```

Також є методи `start()`і `end()`для того, щоб дізнатися про початкову і кінцеву позицію знайденого рядка.

```python
result = re.match(r'AV', 'AV Analytics Vidhya AV')
print result.start()
print result.end()

Результат:
0
2
```

## search

#### re.search(pattern, string)

Метод `search()`шукає по всьому рядку, але повертає лише перший знайдений збіг.

Метод схожий на `match()`, але шукає не тільки на початку рядка. На відміну від попереднього, `search()`поверне об'єкт, якщо ми спробуємо знайти "Analytics":

```python
result = re.search(r'Analytics', 'AV Analytics Vidhya AV')
print result.group(0)

Результат:
Analytics
```

```python
import re

time_str = '1:02:34.05'

res = re.search('^(.+)[\.,](.+)$', time_str)

if res:
    print('res =',res) # res = <re.Match object; span=(0, 10), match='1:02:34.05'>
    print('res.groups() =',res.groups())  # ('1:02:34', '05')
    print('res.group(0) =',res.group(0))  # 1:02:34.05
    print('res.group(1) =',res.group(1))  # 1:02:34
    print('res.group(2) =',res.group(2))  # 05
else:
    print('not found')
```

## fullmatch

#### re.fullmatch(pattern, string, flags=0)

Якщо весь рядок відповідає шаблону регулярного виразу, повертає відповідний збіг. Повертає None, якщо рядок не відповідає шаблону; зауважте, що це відрізняється від збігу нульової довжини.

```python
if not re.fullmatch('\d\d\d\d', year):
    err = 1
```

## findall

#### re.findall(pattern, string)

Повертає список усіх знайдених збігів. Метод `findall()`не має обмежень на пошук на початку або в кінці рядка. Якщо ми шукатимемо «AV» у нашому рядку, він поверне всі входження «AV». Для пошуку рекомендується використовувати саме `findall()`, тому що він може працювати і як `re.search()`, і як `re.match()`.

```python
result = re.findall(r'AV', 'AV Analytics Vidhya AV')
print result

Результат:
['AV', 'AV']
```

Якщо берємо одне входження `()`, то функція поверне список:

<pre class="language-python"><code class="lang-python"><strong>any_str = ('+380 (12) 345-6789'
</strong>           '+381 (98) 765-4321')
pat = re.compile('\+(\d+)\s')
res = re.findall(pat, any_str)    # ['380', '381']
</code></pre>

Якщо берємо декілька входжень `()()()`, то функція поверне список кортежів:

```python
any_str = ('+380 (12) 345-6789'
           '+381 (98) 765-4321')
pat = re.compile('\+(\d+)\s\((\d\d)\)\s(\d{3}\-\d{4})')
res = re.findall(pat, any_str)  #[('380', '12', '345-6789'), ('381', '98', '765-4321')]
```

в цьому  випадку:

```python
for item in res:                    # 1 / 2
	print('found   =',item)     # ('380', '12', '345-6789') / ('381', '98', '765-4321')
	print('country =',item[0])  # 380 / 381
	print('city    =',item[1])  # 12 / 98
	print('number  =',item[2])  # 345-6789 / 765-432
```

## split

#### re.split(pattern, string, \[maxsplit = 0])

Цей метод поділяє рядок за заданим шаблоном.

```python
result = re.split(r'y', 'Analytics')
print result

Результат:
['Anal', 'tics']
```

У прикладі ми розділили слово "Analytics" за літерою "y". Метод `split()`приймає також аргумент `maxsplit`зі значенням за умовчанням, рівним 0. У разі він розділить рядок стільки разів, скільки можливо, але якщо вказати цей аргумент, то поділ буде зроблено трохи більше зазначеної кількості раз. Давайте подивимося на приклади Python RegEx:

```python
result = re.split(r'i', 'Analytics Vidhya')
print result

Результат:
['Analyt', 'cs V', 'dhya'] # все возможные участки.
```

```python
result = re.split(r'i', 'Analytics Vidhya',maxsplit=1)
print result

Результат:
['Analyt', 'cs Vidhya']
```

Ми встановили параметр `maxsplit`рівним 1 і в результаті рядок був розділений на дві частини замість трьох.

## sub

#### re.sub(pattern, repl, string)

Шукає шаблон у рядку та замінює його на вказаний підрядок. Якщо шаблон не знайдено, рядок залишається незмінним.

```python
result = re.sub(r'India', 'the World', 'AV is largest Analytics community of India')
print result

Результат:
'AV is largest Analytics community of the World'
```

## compile

#### re.compile(pattern, repl, string)

Ми можемо зібрати регулярне вираження в окремий об'єкт, який можна використовувати для пошуку. Це також позбавляє переписування одного і того ж виразу.

```python
pattern = re.compile('AV')
result = pattern.findall('AV Analytics Vidhya AV')
print result
result2 = pattern.findall('AV is largest analytics community of India')
print result2

Результат:
['AV', 'AV']
['AV']
```

## Приклади

#### Повернути перше слово з рядка

Спочатку спробуємо витягнути кожен символ (використовуючи `.`)

```python
result = re.findall(r'.', 'AV is largest Analytics community of India')
print result

Результат:
['A', 'V', ' ', 'i', 's', ' ', 'l', 'a', 'r', 'g', 'e', 's', 't', ' ', 'A', 'n', 'a', 'l', 'y', 't', 'i', 'c', 's', ' ', 'c', 'o', 'm', 'm', 'u', 'n', 'i', 't', 'y', ' ', 'o', 'f', ' ', 'I', 'n', 'd', 'i', 'a']
```

Для того, щоб у кінцевий результат не потрапив пробіл, використовуємо `.` `\w`.

```python
result = re.findall(r'\w', 'AV is largest Analytics community of India')
print result

Результат:
['A', 'V', 'i', 's', 'l', 'a', 'r', 'g', 'e', 's', 't', 'A', 'n', 'a', 'l', 'y', 't', 'i', 'c', 's', 'c', 'o', 'm', 'm', 'u', 'n', 'i', 't', 'y', 'o', 'f', 'I', 'n', 'd', 'i', 'a']
```

Тепер спробуємо дістати кожне слово (використовуючи `*`або `+`)

```python
result = re.findall(r'\w*', 'AV is largest Analytics community of India')
print result

Результат:
['AV', '', 'is', '', 'largest', '', 'Analytics', '', 'community', '', 'of', '', 'India', '']
```

І знову в результат потрапили прогалини, оскільки `*`означає «нуль чи більше символів». Для того, щоб їх прибрати, використовуємо `+`:

```python
result = re.findall(r'\w+', 'AV is largest Analytics community of India')
print result
Результат:
['AV', 'is', 'largest', 'Analytics', 'community', 'of', 'India']
```

Тепер витягнемо перше слово, використовуючи `^`:

```python
result = re.findall(r'^\w+', 'AV is largest Analytics community of India')
print result

Результат:
['AV']
```

Якщо ми використовуємо `$`замість `^`, ми отримаємо останнє слово, а чи не перше:

```python
result = re.findall(r'\w+$', 'AV is largest Analytics community of India')
print result

Результат:
[‘India’]
```

#### Повернути перші два символи кожного слова

Варіант 1: використовуючи `\w`, витягнути два послідовні символи, крім пробельних, з кожного слова:

```python
result = re.findall(r'\w\w', 'AV is largest Analytics community of India')
print result

Результат:
['AV', 'is', 'la', 'rg', 'es', 'An', 'al', 'yt', 'ic', 'co', 'mm', 'un', 'it', 'of', 'In', 'di']
```

Варіант 2: витягнути два послідовні символи, використовуючи символ межі слова ( `\b`):

```python
result = re.findall(r'\b\w.', 'AV is largest Analytics community of India')
print result

Результат:
['AV', 'is', 'la', 'An', 'co', 'of', 'In']
```

#### Повернути домени зі списку email-адрес

Спочатку повернемо всі символи після "@":

```python
result = re.findall(r'@\w+', 'abc.test@gmail.com, xyz@test.in, test.first@analyticsvidhya.com, first.test@rest.biz')
print result

Результат:
['@gmail', '@test', '@analyticsvidhya', '@rest']
```

Як бачимо, частини .com, .in і т. д. не потрапили в результат. Змінимо наш код:

```python
result = re.findall(r'@\w+.\w+', 'abc.test@gmail.com, xyz@test.in, test.first@analyticsvidhya.com, first.test@rest.biz')
print result

Результат:
['@gmail.com', '@test.in', '@analyticsvidhya.com', '@rest.biz']
```

Другий варіант - витягти тільки домен верхнього рівня, використовуючи групування -  `( )`:

```python
result = re.findall(r'@\w+.(\w+)', 'abc.test@gmail.com, xyz@test.in, test.first@analyticsvidhya.com, first.test@rest.biz')
print result

Результат:
['com', 'in', 'com', 'biz']
```

#### Витягти дату з рядка

Використовуємо `\d`для отримання цифр.

```python
result = re.findall(r'\d{2}-\d{2}-\d{4}', 'Amit 34-3456 12-05-2007, XYZ 56-4532 11-11-2011, ABC 67-8945 12-01-2009')
print result

Результат:
['12-05-2007', '11-11-2011', '12-01-2009']
```

Для отримання лише року нам знову допоможуть дужки:

```python
result = re.findall(r'\d{2}-\d{2}-(\d{4})', 'Amit 34-3456 12-05-2007, XYZ 56-4532 11-11-2011, ABC 67-8945 12-01-2009')
print result

Результат:
['2007', '2011', '2009']
```

#### Витягти слова, що починаються на голосну

Спочатку повернемо всі слова:

```python
result = re.findall(r'\w+', 'AV is largest Analytics community of India')
print result

Результат:
['AV', 'is', 'largest', 'Analytics', 'community', 'of', 'India']
```

А тепер — лише ті, які починаються на певні літери (використовуючи `[]`):

```python
result = re.findall(r'[aeiouAEIOU]\w+', 'AV is largest Analytics community of India')
print result

Результат:
['AV', 'is', 'argest', 'Analytics', 'ommunity', 'of', 'India']
```

Вище ми бачимо обрізані слова «argest» та «ommunity». Для того, щоб прибрати їх, використовуємо `\b`для позначення межі слова:

```python
result = re.findall(r'\b[aeiouAEIOU]\w+', 'AV is largest Analytics community of India')
print result

Результат:
['AV', 'is', 'Analytics', 'of', 'India']
```

Також ми можемо використовувати `^`всередині квадратних дужок для інвертування групи:

```python
result = re.findall(r'\b[^aeiouAEIOU]\w+', 'AV is largest Analytics community of India')
print result

Результат:
[' is', ' largest', ' Analytics', ' community', ' of', ' India']
```

В результаті потрапили слова, що «починаються» з пробілу. Приберемо їх, включивши пробіл у діапазон у квадратних дужках:

```python
result = re.findall(r'\b[^aeiouAEIOU ]\w+', 'AV is largest Analytics community of India')
print result

Результат:
['largest', 'community']
```

#### Перевірити формат телефонного номера

Номер має бути довжиною 10 знаків і починатися з 8 або 9. Є список телефонних номерів, і потрібно перевірити їх, використовуючи регулярки в Python:

```python
li = ['9999999999', '999999-999', '99999x9999']

for val in li:
    if re.match(r'[8-9]{1}[0-9]{9}', val) and len(val) == 10:
        print 'yes'
    else:
        print 'no'

Результат:
yes
no
no
```

#### Розбити рядок за кількома роздільниками

Можливе рішення:

```python
line = 'asdf fjdk;afed,fjek,asdf,foo' # String has multiple delimiters (";",","," ").
result = re.split(r'[;,\s]', line)
print result

Результат:
['asdf', 'fjdk', 'afed', 'fjek', 'asdf', 'foo']
```

Також ми можемо використовувати метод `re.sub()`для заміни всіх розділів пробілами:

```python
line = 'asdf fjdk;afed,fjek,asdf,foo'
result = re.sub(r'[;,\s]',' ', line)
print result

Результат:
asdf fjdk afed fjek asdf foo
```

#### Вийняти інформацію з html-файлу

Допустимо, потрібно витягти інформацію з html-файлу, укладену між `<td>`і `</td>`, крім першого стовпця з номером. Також вважатимемо, що html-код міститься у рядку.

Приклад вмісту html-файлу:

```html
1NoahEmma2LiamOlivia3MasonSophia4JacobIsabella5WilliamAva6EthanMia7MichaelEmily
```

За допомогою регулярних виразів у Python це можна вирішити так (якщо помістити вміст файлу в змінну `test_str`):

```python
result = re.findall(r'\d([A-Z][A-Za-z]+)([A-Z][A-Za-z]+)', test_str)
print result

Результат:
[('Noah', 'Emma'), ('Liam', 'Olivia'), ('Mason', 'Sophia'), ('Jacob', 'Isabella'), ('William', 'Ava'), ('Ethan', 'Mia'), ('Michael', 'Emily')]
```

<br>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://olexsyn.gitbook.io/enote/progr/python/modules/re.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.