Как заменить подстроку в строке python

Python предоставляет встроенный метод str.replace(), который заменяет все вхождения указанной подстроки на новую. Например, «data».replace(«a», «o») вернет «doto». Этот метод работает мгновенно для строк длиной до нескольких миллионов символов и поддерживает ограничение количества замен через третий аргумент.

Для более гибкой замены стоит использовать модуль re. Функция re.sub() позволяет заменять подстроки по шаблону регулярного выражения. Например, re.sub(r»\d+», «число», «На улице 23 градуса») вернет «На улице число градуса». Такой подход эффективен при работе с динамическими шаблонами и большими текстами.

Если требуется заменить подстроку только один раз или на определенной позиции, можно комбинировать str.find() и срезы. Например, text[:index] + new_sub + text[index+len(old_sub):] позволяет точно контролировать, какая часть строки меняется, без обработки всего текста.

Использование метода str.replace для одиночных и множественных замен

Метод str.replace(old, new[, count]) заменяет все вхождения подстроки old на new. Аргумент count ограничивает количество замен. Без него происходит замена всех совпадений.

Для одиночной замены достаточно указать count=1. Пример:

text = "яблоко, апельсин, яблоко"
new_text = text.replace("яблоко", "груша", 1)
Результат: "груша, апельсин, яблоко"

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

text = "кот, собака, кот"
new_text = text.replace("кот", "тигр")
Результат: "тигр, собака, тигр"

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

text = "яблоко, апельсин, банан"
replacements = {"яблоко": "груша", "банан": "киви"}
for old, new in replacements.items():
text = text.replace(old, new)
Результат: "груша, апельсин, киви"

Метод replace чувствителен к регистру: "Кот".replace("кот", "тигр") вернёт исходную строку. Для работы без учёта регистра требуется предварительное приведение строки к единому регистру или использование регулярных выражений.

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

Замена с учетом регистра символов с помощью str.lower и str.upper

В Python стандартный метод str.replace() учитывает регистр символов. Для замены подстроки независимо от регистра можно применять str.lower() или str.upper(). Принцип работы: приводим исходную строку и искомую подстроку к одному регистру, выполняем поиск и замену, затем корректируем оригинальные сегменты при необходимости.

Пример: заменим все варианты ‘Python’, ‘PYTHON’, ‘python’ на ‘PyLang’:

text = "Python и python популярны. PYTHON развивается." target = "python" replacement = "PyLang" text_lower = text.lower() indices = [i for i in range(len(text_lower)) if text_lower.startswith(target, i)] for i in reversed(indices): text = text[:i] + replacement + text[i+len(target):] print(text)

Результат: PyLang и PyLang популярны. PyLang развивается.

Для простого подхода достаточно использовать str.lower() для поиска и str.replace() на уже нормализованной строке, если не важен исходный регистр отдельных букв. Если требуется сохранить регистр первой буквы или полностью оригинальный стиль, необходимо дополнительное сопоставление символов до замены.

Использование str.upper() аналогично: приводит строку к верхнему регистру, что полезно для текстов с преимущественно заглавными буквами, например, акронимов.

Такой метод эффективен для больших текстов, когда стандартные регулярные выражения излишни, а важна однозначная и быстрая замена с учетом регистра. Применение lower/upper позволяет контролировать замену без потери информации о позициях подстрок.

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

Пример: необходимо заменить все даты формата dd.mm.yyyy на yyyy-mm-dd. Решение:

import re pattern = r'(\d{2})\.(\d{2})\.(\d{4})' text = 'Сегодня 12.09.2025, завтра 13.09.2025' result = re.sub(pattern, r'\3-\2-\1', text) print(result)

Результат будет: Сегодня 2025-09-12, завтра 2025-09-13. Использование групп (...) позволяет менять порядок компонентов подстроки.

Регулярные выражения эффективны для замены повторяющихся или вариативных шаблонов. Например, удаление всех чисел, следующих за словом ID::

text = 'ID:123, ID:456, ID:789' result = re.sub(r'ID:\d+', 'ID:XXX', text) print(result)

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

Шаблон	Описание	Пример замены
\d+	Любая последовательность цифр	re.sub(r’\d+’, ‘NUM’, ‘abc123’) → ‘abcNUM’
\w+	Любое слово (буквы, цифры, _)	re.sub(r’\w+’, ‘WORD’, ‘a_b 123’) → ‘WORD WORD’
[A-Za-z]	Любая латинская буква	re.sub(r'[A-Za-z]’, ‘X’, ‘Ab1c’) → ‘XX1X’
(pattern1\|pattern2)	Соответствие pattern1 или pattern2	re.sub(r’cat\|dog’, ‘animal’, ‘cat dog’) → ‘animal animal’
\s+	Любой пробельный символ (пробел, таб, перенос)	re.sub(r’\s+’, ‘ ‘, ‘a\tb\nc’) → ‘a b c’

Для оптимизации замен рекомендуется использовать предварительно скомпилированный шаблон через re.compile():

pattern = re.compile(r'\d{2}-\d{2}-\d{4}') result = pattern.sub('DATE', text)

Это ускоряет повторное применение сложного шаблона на больших текстах.

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

result = re.sub(r'\d+', lambda x: str(int(x.group())**2), '2 3 4') print(result)

Замена только первого или последнего вхождения подстроки

Для замены первого вхождения подстроки в Python используется метод replace с аргументом count=1. Он изменяет только первое совпадение, оставляя остальные нетронутыми. Пример:

text = "яблоко, апельсин, яблоко"
new_text = text.replace("яблоко", "груша", 1)
Результат: 'груша, апельсин, яблоко'

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

text = "яблоко, апельсин, яблоко"
index = text.rfind("яблоко")
new_text = text[:index] + "груша" + text[index + len("яблоко"):]
Результат: 'яблоко, апельсин, груша'

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

Обновление нескольких разных подстрок одной операцией

В Python заменить сразу несколько разных подстрок можно через словарь и метод re.sub из стандартного модуля re. Сначала создается словарь, где ключи – исходные подстроки, а значения – новые. Затем формируется регулярное выражение, объединяющее все ключи через оператор |, и применяется функция замены.

Пример: заменим слова «кошка» на «пёс», «молоко» на «вода», «дом» на «квартира»:

import re

replacements = {'кошка': 'пёс', 'молоко': 'вода', 'дом': 'квартира'}

pattern = re.compile('|'.join(re.escape(k) for k in replacements))

text = "Кошка пьёт молоко в доме"

result = pattern.sub(lambda x: replacements[x.group()], text)

После выполнения result будет содержать строку: «Пёс пьёт вода в квартире». Такой подход гарантирует точное совпадение каждой подстроки и возможность масштабирования на десятки замен без создания цепочек str.replace.

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

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

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

Основной метод – str.replace(old, new[, count]):

old – подстрока, которую нужно заменить;
new – строка-замена;
count (необязательный) – количество замен, если нужно ограничить.

Пример:

original = "apple banana apple"
modified = original.replace("apple", "orange")
# original: "apple banana apple"
# modified: "orange banana orange"

Для частичной замены удобно указывать count:

first_only = original.replace("apple", "orange", 1)
# first_only: "orange banana apple"

При работе с регулярными выражениями используется re.sub(pattern, repl, string, count=0), что также создаёт новую строку без изменения исходной:

import re
text = "cat bat cat"
new_text = re.sub(r"cat", "dog", text, count=1)
# text: "cat bat cat"
# new_text: "dog bat cat"

Рекомендации для сохранения исходной строки:

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

Следуя этим правилам, можно безопасно изменять строки, не рискуя потерять исходную информацию, и создавать несколько вариантов данных для анализа или обработки.

Вопрос-ответ:

Как заменить одно слово на другое в строке Python?

В Python для замены части строки можно использовать метод replace(). Например, если есть строка text = "Привет, мир" и нужно заменить «мир» на «Python», можно написать text.replace("мир", "Python"). Результат будет "Привет, Python". Этот метод создаёт новую строку, оставляя исходную без изменений.

Можно ли заменить только первое или последнее вхождение подстроки?

Метод replace() позволяет указать, сколько замен сделать, с помощью третьего аргумента. Например, text.replace("а", "о", 1) заменит только первое вхождение «а» на «о». Чтобы изменить только последнее вхождение, можно использовать комбинацию rsplit() и join(): разделить строку справа, заменить первый элемент и собрать обратно.

Как заменить подстроку с учётом регистра букв?

Метод replace() учитывает регистр, поэтому «Привет» и «привет» будут разными. Если требуется заменить подстроку независимо от регистра, можно использовать модуль re с флагом re.IGNORECASE. Например: re.sub("привет", "здравствуй", text, flags=re.IGNORECASE). Такой подход позволит найти все варианты подстроки без различия между заглавными и строчными буквами.

Можно ли заменить несколько разных подстрок одновременно?

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

Что будет, если подстрока для замены отсутствует?

Если указанная подстрока не найдена, метод replace() вернёт строку без изменений, ошибок не возникнет. То есть можно безопасно применять замену даже если точно не известно, есть ли в строке нужная последовательность символов.

Как заменить все вхождения слова в строке Python на другое слово?

В Python есть встроенный метод строк replace(), который позволяет заменить все вхождения одной подстроки на другую. Его синтаксис простой: новая_строка = старая_строка.replace('старое', 'новое'). Этот метод возвращает новую строку, оставляя исходную без изменений. Если нужно ограничить количество замен, можно указать третий аргумент: replace('старое', 'новое', 2) заменит только первые два вхождения.