Модуль re в Python: эффективная обработка текста регулярками

Пройдите тест, узнайте какой профессии подходите

Сколько вам лет

До 18

От 18 до 24

От 25 до 34

От 35 до 44

От 45 до 49

От 50 до 54

Больше 55

Для кого эта статья:

Для разработчиков и программистов, желающих улучшить свои навыки работы с Python.
Для студентов и новичков, изучающих программирование и работу с текстовыми данными.
Для профессионалов в области анализа данных и автоматизации, заинтересованных в использовании регулярных выражений.
Если вы когда-нибудь пытались найти все номера телефонов в большом текстовом документе или проверить правильность email-адреса, вы знаете, насколько это может быть утомительно и подвержено ошибкам. Модуль re в Python предлагает элегантное решение таких задач через регулярные выражения — мощный инструмент для обработки текста, который существенно упрощает поиск, извлечение и манипуляции со строками. И хотя синтаксис регулярных выражений может сначала показаться странным набором символов, после освоения основных концепций вы будете удивлены, как обходились без них раньше. 🔍

Хотите профессионально овладеть Python и писать эффективный код? Курс Обучение Python-разработке от Skypro — это идеальная возможность освоить регулярные выражения и множество других инструментов на реальных проектах. Наши студенты не только изучают теорию, но и применяют регулярные выражения для анализа данных, парсинга веб-страниц и автоматизации рутинных задач под руководством практикующих разработчиков. Присоединяйтесь и превратите сложные текстовые задачи в простой код!

Что такое модуль re в Python и зачем он нужен

Модуль re — это встроенная библиотека Python для работы с регулярными выражениями (regular expressions или просто regex). Регулярные выражения представляют собой специальный язык паттернов, позволяющий эффективно искать, извлекать и манипулировать текстом на основе определённых правил.

Чтобы начать использовать регулярные выражения в Python, нужно импортировать модуль re:

import re

Зачем же нужен модуль re, когда в Python уже есть встроенные методы для работы со строками, такие как find(), replace() или split()?

Алексей Ковалёв, senior Python-разработчик

Когда я только начинал программировать, мне поручили задачу извлечь все email-адреса из текстового файла объёмом в несколько тысяч строк. Я попытался использовать обычные строковые методы, проверяя наличие символа @ и доменных зон. После нескольких часов борьбы и множества ошибок мой коллега показал мне решение в три строки кода с использованием модуля re:

Python

Скопировать код

import re
with open('document.txt', 'r') as file:
emails = re.findall(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', file.read())

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

Вот ключевые преимущества использования модуля re:

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

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

Задача	Без регулярных выражений	С регулярными выражениями
Валидация email	Множество проверок, включая наличие `@`, проверку доменной части, запрещённых символов	Одна строка с шаблоном email
Извлечение дат из текста	Поиск по разным форматам дат требует сложной логики	Единый шаблон для всех форматов дат
Парсинг HTML/XML	Сложные строковые манипуляции с высоким риском ошибок	Точные шаблоны для извлечения данных из тегов
Очистка текста	Множество замен для разных типов ненужных символов	Один шаблон для всех нежелательных элементов

Базовые функции модуля re для обработки текста

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

1. re.search() — поиск первого совпадения в строке

Функция re.search() ищет первое совпадение с шаблоном в строке и возвращает объект Match или None, если совпадений не найдено:

import re

text = "Python был создан в 1991 году Гвидо ван Россумом"
result = re.search(r"Python", text)
print(result) # <re.Match object; span=(0, 6), match='Python'>

# Извлечение совпадения
if result:
print(f"Найдено: {result.group()}") # Найдено: Python

2. re.match() — поиск совпадения в начале строки

Функция re.match() похожа на search(), но проверяет только начало строки:

# Это найдёт совпадение
result1 = re.match(r"Python", "Python был создан в 1991 году")
print(result1) # <re.Match object; span=(0, 6), match='Python'>

# А это не найдёт
result2 = re.match(r"Python", "Язык Python был создан в 1991 году")
print(result2) # None

3. re.findall() — поиск всех совпадений

Функция re.findall() находит все совпадения с шаблоном и возвращает их в виде списка:

text = "Python 2 был выпущен в 2000 году, а Python 3 — в 2008"
numbers = re.findall(r"\d+", text)
print(numbers) # ['2', '2000', '3', '2008']

4. re.finditer() — итератор по всем совпадениям

Функция re.finditer() возвращает итератор по всем объектам Match, найденным в строке:

text = "Email: user@example.com, альтернативный: admin@test.org"
for match in re.finditer(r"\S+@\S+\.\S+", text):
print(f"Найден email: {match.group()} на позиции {match.start()}-{match.end()}")

5. re.sub() — замена по шаблону

Функция re.sub() заменяет все совпадения с шаблоном на указанную строку:

text = "Телефоны: +7-999-123-4567, 8(495)765-4321"
masked = re.sub(r"\d", "*", text)
print(masked) # Телефоны: +*-***-***-****, *(***)**-****

6. re.split() — разделение строки по шаблону

Функция re.split() разбивает строку по совпадениям с шаблоном:

text = "apple,banana;cherry:orange"
fruits = re.split(r"[,;:]", text)
print(fruits) # ['apple', 'banana', 'cherry', 'orange']

7. re.compile() — компиляция шаблона для повторного использования

Функция re.compile() компилирует регулярное выражение в объект Pattern, который можно использовать многократно:

# Скомпилированный шаблон для поиска email
email_pattern = re.compile(r"\S+@\S+\.\S+")

text1 = "Контакт: user@example.com"
text2 = "Пишите на admin@company.org"

print(email_pattern.search(text1).group()) # user@example.com
print(email_pattern.search(text2).group()) # admin@company.org

Функция	Возвращает	Типичное применение
re.search()	Объект Match или None	Проверка наличия шаблона в тексте
re.match()	Объект Match или None	Проверка начинается ли текст с шаблона
re.findall()	Список строк	Извлечение всех совпадений
re.finditer()	Итератор объектов Match	Обработка каждого совпадения с доп. информацией
re.sub()	Изменённая строка	Замена, маскирование, форматирование текста
re.split()	Список строк	Разделение текста по сложным разделителям
re.compile()	Объект Pattern	Оптимизация при многократном использовании шаблона

Основные метасимволы и их применение в регулярках

Регулярные выражения обладают своим "алфавитом" — метасимволами, которые имеют специальное значение и позволяют создавать гибкие шаблоны для поиска. Понимание этих метасимволов — ключ к эффективному использованию модуля re. 🔑

Базовые метасимволы для сопоставления

. — любой символ, кроме новой строки
^ — начало строки
$ — конец строки
\ — экранирование специальных символов

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

import re

# Точка соответствует любому символу
print(re.findall(r"c.t", "cat cut cot c.t")) # ['cat', 'cut', 'cot', 'c.t']

# ^ и $ для привязки к началу и концу строки
print(re.findall(r"^Python", "Python is great\nPython is popular")) # ['Python']
print(re.findall(r"Python$", "I love Python")) # ['Python']

# Экранирование специальных символов
print(re.findall(r"\.", "site.com")) # ['.']

Квантификаторы (указатели количества)

* — 0 или более повторений (жадный)
+ — 1 или более повторений (жадный)
? — 0 или 1 повторение (жадный)
{n} — ровно n повторений
{n,} — не менее n повторений
{n,m} — от n до m повторений

Примеры использования квантификаторов:

# * – ноль или более повторений
print(re.findall(r"ab*c", "ac abc abbc")) # ['ac', 'abc', 'abbc']

# + – один или более повторений
print(re.findall(r"ab+c", "ac abc abbc")) # ['abc', 'abbc']

# ? – ноль или одно повторение
print(re.findall(r"colou?r", "color colour")) # ['color', 'colour']

# {n}, {n,} и {n,m} для точного количества повторений
print(re.findall(r"\d{2}", "12 345 6789")) # ['12', '34', '67', '89']
print(re.findall(r"\d{2,}", "12 345 6789")) # ['12', '345', '6789']
print(re.findall(r"\d{2,3}", "12 345 6789")) # ['12', '345', '678', '9']

Классы символов и специальные последовательности

[abc] — один из перечисленных символов
[^abc] — любой символ, кроме перечисленных
[a-z] — любой символ из диапазона
\d — цифра (эквивалент [0-9])
\D — не цифра (эквивалент ^0-9)
\w — буква, цифра или (эквивалент [a-zA-Z0-9])
\W — не \w (эквивалент ^a-zA-Z0-9_)
\s — пробельный символ (пробел, табуляция, новая строка)
\S — не пробельный символ
\b — граница слова

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

# Классы символов
print(re.findall(r"[aeiou]", "hello world")) # ['e', 'o', 'o']
print(re.findall(r"[^aeiou\s]", "hello world")) # ['h', 'l', 'l', 'w', 'r', 'l', 'd']

# Специальные последовательности
print(re.findall(r"\d+", "Phone: 123-456-7890")) # ['123', '456', '7890']
print(re.findall(r"\w+", "hello@world.com")) # ['hello', 'world', 'com']
print(re.findall(r"\b\w{5}\b", "hello world python")) # ['hello', 'world']

Группировка и захват

(expr) — группировка и захват совпадения
(?:expr) — группировка без захвата
\1, \2, ... — обратные ссылки на захваченные группы

Примеры группировки и захвата:

# Захват групп
match = re.search(r"(\d{3})-(\d{3})-(\d{4})", "Phone: 123-456-7890")
if match:
print(match.group(0)) # 123-456-7890 (всё совпадение)
print(match.group(1)) # 123 (первая группа)
print(match.group(2)) # 456 (вторая группа)
print(match.groups()) # ('123', '456', '7890') (все группы)

# Обратные ссылки
print(re.findall(r"(\w+) \1", "hello hello world world")) # ['hello', 'world']

Ирина Соколова, Data Scientist

Помню свой первый проект по анализу отзывов клиентов. Мне нужно было извлечь все упоминания продуктов вместе с оценками из тысяч текстовых комментариев. Формат был примерно такой: "Продукт X – 4/5", "Y получает 3 из 5" и десятки вариаций.
Сначала я пыталась обрабатывать каждый формат отдельно, но быстро утонула в условиях. Тогда я решила освоить регулярные выражения и создала универсальный шаблон:
Python
Скопировать код
pattern = r"([A-Z][a-z]+(?:\s[A-Za-z]+)*)\s*[-–:]\s*(\d)[\/\s]*(?:из|of|\/)\s*(\d)"
matches = re.findall(pattern, text)
Этот шаблон находил продукты и их рейтинги во всех форматах. Но настоящий прорыв произошёл, когда я поняла силу именованных групп:
Python
Скопировать код
pattern = r"(?P<product>[A-Z][a-z]+(?:\s[A-Za-z]+)*)\s*[-–:]\s*(?P<score>\d)[\/\s]*(?:из|of|\/)\s*(?P<scale>\d)"
for match in re.finditer(pattern, text):
product = match.group('product')
score = int(match.group('score'))
scale = int(match.group('scale'))
normalized_score = score / scale * 5 # приведение к шкале 0-5
Это сделало код не только более эффективным, но и гораздо более читаемым для коллег, которым предстояло его поддерживать.

Альтернативы и утверждения

| — альтернатива (или)
(?=...) — позитивное предварительное утверждение
(?!...) — негативное предварительное утверждение
(?<=...) — позитивное ретроспективное утверждение
(?<!...) — негативное ретроспективное утверждение

Примеры использования альтернатив и утверждений:

# Альтернативы
print(re.findall(r"apple|banana", "I like apple and banana")) # ['apple', 'banana']

# Позитивное предварительное утверждение – найти слова, за которыми следует число
print(re.findall(r"\w+(?=\s+\d+)", "apple 5 banana 8 cherry")) # ['apple', 'banana']

# Негативное предварительное утверждение – найти слова, за которыми НЕ следует число
print(re.findall(r"\w+(?!\s+\d+)", "apple 5 banana 8 cherry")) # ['cherry']

# Ретроспективные утверждения
print(re.findall(r"(?<=\$)\d+", "$100 €50")) # ['100']
print(re.findall(r"(?<!\$)\d+", "$100 €50")) # ['50']

Практические задачи с регулярными выражениями

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

1. Извлечение email-адресов из текста

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

import re

text = """
Контакты компании:
- Общие вопросы: info@example.com
- Техподдержка: support@example.com, help.desk@company-name.org
- Директор: ceo@example.com
"""

# Простой шаблон для email
email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
emails = re.findall(email_pattern, text)

print(f"Найдено {len(emails)} email-адресов:")
for email in emails:
print(f"- {email}")

2. Валидация пароля с определенными требованиями

Проверка, соответствует ли пароль требованиям безопасности:

def is_strong_password(password):
"""
Проверяет, является ли пароль надежным:
- Минимум 8 символов
- Содержит хотя бы одну цифру
- Содержит хотя бы одну прописную букву
- Содержит хотя бы одну строчную букву
- Содержит хотя бы один специальный символ
"""
# Проверка на минимальную длину
if len(password) < 8:
return False

# Проверка на наличие цифры
if not re.search(r"\d", password):
return False

# Проверка на наличие прописной буквы
if not re.search(r"[A-Z]", password):
return False

# Проверка на наличие строчной буквы
if not re.search(r"[a-z]", password):
return False

# Проверка на наличие специального символа
if not re.search(r"[!@#$%^&*(),.?\":{}|<>]", password):
return False

return True

# Альтернативный вариант — все проверки в одном выражении
def is_strong_password_alt(password):
pattern = r"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*(),.?\":{}|<>])[A-Za-z\d!@#$%^&*(),.?\":{}|<>]{8,}$"
return bool(re.match(pattern, password))

# Проверяем несколько паролей
passwords = [
"Pass123!", 
"weakpass", 
"NOLOWERCASE123!", 
"nodigit!", 
"NoSpecial123",
"Short1!"
]

for pwd in passwords:
print(f"Пароль '{pwd}' надежный: {is_strong_password(pwd)}")

3. Извлечение и форматирование телефонных номеров

Поиск телефонных номеров в различных форматах и приведение их к единому стандарту:

def standardize_phone(text):
"""Находит телефонные номера в тексте и стандартизирует их формат"""

# Шаблон для российских номеров в различных форматах
pattern = r'(?:\+7|8)[\s\-]?\(?(\d{3})\)?[\s\-]?(\d{3})[\s\-]?(\d{2})[\s\-]?(\d{2})'

# Функция для форматирования найденного номера
def format_number(match):
return f"+7 ({match.group(1)}) {match.group(2)}-{match.group(3)}-{match.group(4)}"

# Замена всех найденных номеров на стандартизированный формат
result = re.sub(pattern, format_number, text)
return result

# Пример использования
text = """
Контактные телефоны:
8(495)123-4567
+7 999 888 7766
8-900-555-44-33
"""

standardized = standardize_phone(text)
print(standardized)

4. Парсинг HTML-тегов

Извлечение данных из HTML-разметки (хотя для полноценного парсинга HTML лучше использовать специализированные библиотеки):

html = """
<div class="article">
<h2>Заголовок статьи</h2>
<p>Первый абзац статьи.</p>
<p>Второй абзац с <a href="https://example.com">ссылкой</a>.</p>
<ul>
<li>Пункт 1</li>
<li>Пункт 2</li>
</ul>
</div>
"""

# Извлечение заголовка
title = re.search(r'<h2>(.*?)</h2>', html).group(1)
print(f"Заголовок: {title}")

# Извлечение всех абзацев
paragraphs = re.findall(r'<p>(.*?)</p>', html)
print("Абзацы:")
for i, p in enumerate(paragraphs, 1):
print(f"{i}. {p}")

# Извлечение всех ссылок с их URL и текстом
links = re.findall(r'<a href="(.*?)">(.*?)</a>', html)
print("Ссылки:")
for url, text in links:
print(f"- {text}: {url}")

# Извлечение элементов списка
list_items = re.findall(r'<li>(.*?)</li>', html)
print("Элементы списка:")
for item in list_items:
print(f"* {item}")

5. Разбор и извлечение данных из сложного текста

Извлечение структурированной информации из неструктурированного текста:

log_entry = """
[2023-04-15 08:45:23] ERROR [server.py:127] Failed to connect to database: 
Connection refused (111). Retrying in 5s...
[2023-04-15 08:45:28] INFO [server.py:130] Successfully connected to database.
[2023-04-15 08:46:03] WARNING [auth.py:52] User 'admin' attempted to access 
restricted area from IP 192.168.1.105
"""

# Извлечение всех записей лога с разбивкой на компоненты
log_pattern = r'\[([\d\-\s:]+)\]\s+(\w+)\s+\[([\w\.]+):(\d+)\]\s+(.*?)(?=\n\[|\Z)'
log_entries = re.findall(log_pattern, log_entry, re.DOTALL)

for timestamp, level, module, line, message in log_entries:
print(f"Время: {timestamp}")
print(f"Уровень: {level}")
print(f"Модуль: {module}:{line}")
print(f"Сообщение: {message.strip()}")
print("-" * 50)

Тип задачи	Сложность регулярного выражения	Типичные метасимволы
Извлечение email	Средняя	\w, +, @, ., []
Валидация пароля	Высокая	?=, \d, [A-Z], [a-z], [!@#$%...]
Форматирование телефонов	Средняя	\d, {n}, (), ?:, \s, –
Парсинг HTML	Высокая	<>, .*?, (),
Разбор текстовых логов	Очень высокая	[], \s, \w, :, (?=), \Z

Оптимизация работы с re для эффективного кода

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

1. Компилируйте регулярные выражения для многократного использования

Если вы используете одно и то же регулярное выражение многократно, компилируйте его один раз с помощью re.compile():

import re
import time

# Плохо: компиляция при каждом вызове
def find_emails_bad(text):
return re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', text)

# Хорошо: компиляция один раз
email_pattern = re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b')
def find_emails_good(text):
return email_pattern.findall(text)

# Проверка производительности
text = "Контакты: user1@example.com, user2@example.com" * 1000

start = time.time()
for _ in range(100):
find_emails_bad(text)
print(f"Без компиляции: {time.time() – start:.4f} сек.")

start = time.time()
for _ in range(100):
find_emails_good(text)
print(f"С компиляцией: {time.time() – start:.4f} сек.")

2. Используйте сырые строки (r-префикс)

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

# Плохо: без r-префикса приходится экранировать \
bad_pattern = "\\d+\\.\\d+" # ищет числа с точкой, например 3.14

# Хорошо: с r-префиксом код чище и понятнее
good_pattern = r"\d+\.\d+" # то же самое, но читается лучше

3. Выбирайте правильные функции для конкретных задач

Используйте наиболее подходящие функции модуля re для вашей задачи:

text = "Python программирование python python PYTHON"

# Плохо: использование findall, когда нам нужно только проверить наличие
if re.findall(r"python", text, re.IGNORECASE):
print("Найдено слово Python")

# Хорошо: search быстрее, когда нам нужно только проверить наличие
if re.search(r"python", text, re.IGNORECASE):
print("Найдено слово Python")

# Если нам нужно заменить только первое вхождение
# Плохо: sub заменяет все вхождения
text_replaced_all = re.sub(r"python", "Java", text, flags=re.IGNORECASE)

# Хорошо: для замены только первого вхождения указываем count=1
text_replaced_first = re.sub(r"python", "Java", text, count=1, flags=re.IGNORECASE)

4. Избегайте излишне общих шаблонов и жадных квантификаторов

Слишком общие шаблоны и жадные квантификаторы (*, +) могут вызвать проблемы с производительностью:

html = "<div>Первый блок</div><div>Второй блок</div>"

# Плохо: жадное соответствие захватит всё между первым открывающим и последним закрывающим тегом
print(re.findall(r"<div>(.*)</div>", html)) # ['Первый блок</div><div>Второй блок']

# Хорошо: нежадное соответствие с *? найдет каждый блок отдельно
print(re.findall(r"<div>(.*?)</div>", html)) # ['Первый блок', 'Второй блок']

5. Используйте флаги для оптимизации и упрощения шаблонов

Python предлагает ряд флагов, которые могут сделать ваши регулярные выражения более эффективными:

# re.IGNORECASE (re.I): игнорирует регистр
print(re.findall(r"python", "Python PYTHON python", re.IGNORECASE)) # ['Python', 'PYTHON', 'python']

# re.MULTILINE (re.M): ^ и $ соответствуют началу и концу каждой строки
multiline_text = """Первая строка
Вторая строка
Третья строка"""
print(re.findall(r"^(.+)$", multiline_text, re.MULTILINE)) # ['Первая строка', 'Вторая строка', 'Третья строка']

# re.DOTALL (re.S): точка соответствует любому символу, включая новую строку
print(re.findall(r"<div>(.*?)</div>", "<div>Строка 1\nСтрока 2</div>", re.DOTALL)) # ['Строка 1\nСтрока 2']

# re.VERBOSE (re.X): игнорирует пробелы и комментарии в шаблоне
phone_pattern = re.compile(r"""
\((\d{3})\) # код города в скобках
\s* # опциональные пробелы
(\d{3}) # первые три цифры номера
- # дефис
(\d{4}) # последние четыре цифры
""", re.VERBOSE)
print(phone_pattern.match("(123) 456-7890").groups()) # ('123', '456', '7890')

6. Используйте группы без захвата, когда не нужны данные

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

# Плохо: лишний захват группы
urls_bad = re.findall(r"(https?://(www\.)?example\.com)", "https://www.example.com and http://example.com")
print(urls_bad) # [('https://www.example.com', 'www.'), ('http://example.com', '')]

# Хорошо: группа без захвата для www.
urls_good = re.findall(r"(https?://(?:www\.)?example\.com)", "https://www.example.com and http://example.com")
print(urls_good) # ['https://www.example.com', 'http://example.com']

7. Используйте предварительную фильтрацию данных

Перед применением сложных регулярных выражений к большим объемам текста, попробуйте предварительно отфильтровать данные более простыми методами:

import re

def extract_emails_optimized(text):
# Сначала проверим, есть ли вообще символ @ в тексте
if '@' not in text:
return []

# Затем разобьем текст на слова и отфильтруем только те, которые содержат @
potential_emails = [word for word in text.split() if '@' in word]

# Теперь применим регулярное выражение только к потенциальным email-адресам
email_pattern = re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b')
return [word for word in potential_emails if email_pattern.match(word)]

# Пример использования
large_text = "Это большой текст без email-адресов." * 1000
large_text_with_emails = large_text + " contact@example.com support@company.org"

# Измерение времени выполнения
import time

start = time.time()
emails1 = extract_emails_optimized(large_text_with_emails)
end1 = time.time()

# Для сравнения: прямое применение регулярного выражения
start = time.time()
email_pattern = re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b')
emails2 = email_pattern.findall(large_text_with_emails)
end2 = time.time()

print(f"С оптимизацией: {end1 – start:.6f} сек.")
print(f"Без оптимизации: {end2 – start:.6f} сек.")
print(f"Найденные email: {emails1}")

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

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

Читайте также

Проверь как ты усвоил материалы статьи

Пройди тест и узнай насколько ты лучше других читателей

Что позволяет делать модуль re в Python?

1 / 5

Свежие материалы

Анализ данных и генерация текста с помощью ChatGPT API

6 сентября 2024

Как скачать и установить Python на Android

6 сентября 2024

Видео уроки по анализу данных

6 сентября 2024

Модуль re в Python: эффективная обработка текста регулярками

Что такое модуль re в Python и зачем он нужен

Базовые функции модуля re для обработки текста

Основные метасимволы и их применение в регулярках

Практические задачи с регулярными выражениями

Оптимизация работы с re для эффективного кода

Загрузка...