Метод str.replace() в Python

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

Сегодня расскажем про метод-функцию для строк replace(), с которым можно заменять фрагменты строк, если сказать, что именно заменить и на что. Например, можно будет заменить строчную букву «а» на заглавную, убрать запятые или добавить текст. 

В общем, мощная штука в умелых руках.

Как устроены строки в Python

Сначала вспомним, с чем предстоит работать.

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

# это строка:
'Был яркий холодный апрельский день, часы били тринадцать.'

# это тоже строка:
"Уинстон Смит, прижав подбородок к груди и ёжась от ветра, быстро скользнул в стеклянные двери дома Победы."

# и это:
"""
Но этого было недостаточно, чтобы помешать мерзкому вихрю ворваться вместе с ним.
"""

Python воспринимает строку от одного символа кавычек до другого такого же. Поэтому внутри одного типа можно использовать другие, например:

# это всё одна строка:
"Мистер Джонс с фермы 'Усадьба' закрыл на ночь курятник…"

Со строками лучше использовать кавычки именно такого типа. А вот кавычки-ёлочки «» будут восприниматься просто как текстовые символы и не дадут машине никаких команд.

Внутри строк можно использовать специальные символы, которые помогают управлять текстом. Перед ними ставится символ обратного слеша \. Вот несколько примеров:

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

# без \ кавычки сломают строку, а так можно:
text = "\"Вы — писатель?\" — с интересом спросил поэт."

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

Есть ещё подстроки. Подстрока — это часть символов в строке, которые идут непрерывно, один за другим.

# строка:
text = "\"Вы — писатель?\" — с интересом спросил поэт."
# подстрока от этой строки:
substring = "— с интере"

Введение в метод replace()

Метод str.replace() заменяет одну подстроку на другую.

Например, в предложении "Это было лучшее из всех времён" можно заменить слово «лучшее» на «худшее», чтобы получилось "Это было худшее из всех времён".

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

Параметры метода replace()

В документации Python метод записан так:

str.replace(old, new, count=-1)

Разберём, что есть что:

На последнем остановимся подробнее.

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

'Я был молод, молод и глуп, молод и самонадеян, молод и слеп'

Если мы попросим заменить слово «молод» и не укажем последний параметр, Питон заменит все подходящие фрагменты. Для примера создадим такой текст и подготовим фрагменты, которые будем в нём заменять:

# создаём строку
text = 'Я был молод, молод и глуп, молод и самонадеян, молод и слеп'

# указываем существующую часть строки и замену для неё
used = 'молод'
character = 'юн'

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

# применяем замену ко всем подходящим частям строки
specified = text.replace(used, character)
# выводим результат на экран
print(specified)

Такой код заменяет все вхождения фрагмента «молод» в строку:

Я был юн, юн и глуп, юн и самонадеян, юн и слеп

Если для count указать какое-то число, функция сработает не больше этого количества раз. Добавим в replace дополнительный параметр:

# применяем замену ко всем подходящим частям строки
specified = text.replace(used, character, 2)

Что получилось:

Я был юн, юн и глуп, молод и самонадеян, молод и слеп

Питон заменил слово «молод» только в первых двух случаях, а остальные трогать не стал.

В документации параметр по умолчанию указан как count=-1, потому что -1 означает «заменить все вхождения».

Синтаксис метода replace()

Вместо str может стоять переменная, в которой мы храним текст:

# создаём строку
string = 'Строка для работы'

# можно применять метод replace так:
string.replace('работы', 'практики')

А может — строка целиком в кавычках.

# а можно — так:
'Строка для работы'.replace('работы', 'практики')

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

# можно сохранить текст так:
occurences = string.replace('работы', 'практики')
# выводим новый текст на экран
print(occurences)

# а можно — так:
another = 'Строка для работы'.replace('работы', 'практики')
# выводим новый текст на экран
print(another)

В обоих случаях терминал выведет один результат:

Строка для практики
Строка для практики

Возвращаемое значение метода replace()

Строки нельзя изменять, поэтому после использования replace() Python всегда возвращает новую строку.

Проверим на примере — сохраним применённый метод в новую переменную и проверим, что осталось в старой:

# исходная строка (останется неизменной)
original = "Единственный выход — пройти сквозь"

# применяем replace(), результат сохраняем в новой переменной
modified = original.replace("сквозь", "наружу")

# проверяем оригинальную строку
print('В original хранится:', original)
# проверяем новую строку, созданную на основе оригинала
print('В modified хранится:', modified)

Смотрим, что хранится в памяти:

В original хранится: Единственный выход — пройти сквозь
В modified хранится: Единственный выход — пройти наружу

Старая строка не изменилась, но на её основе получилось создать новую.

Примеры использования метода replace()

Вот ещё несколько примеров использования метода.

Простой пример замены строки

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

# исходная строка с опечаткой
text = "Я люблю Pyton"

# исправляем опечатку: "Pyton" → "Python"
function = text.replace("to", "tho")

# выводим исправленный текст
print(function)

Проверяем:

Я люблю Python

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

Использование метода replace() с ограничением по количеству замен

С replace() можно сделать замену в нескольких местах текста, но нельзя указать точно, где именно: замены всегда начнутся с первого совпадения.

Уберём первые два слова «не» из фразы. Для этого заменим само слово и пробел после него, иначе получится два пробела:

# строка с повторяющимися словами
text = ("Он повторял это снова и снова: \"Я не виноват, "
       "я не виноват, я ни в чём не виноват!\"")

# заменяем только первые два "не" и пробел после них на отсутствие символов: ""
new_text = text.replace("не ", "", 2)

# проверяем
print(new_text)

Строка очистилась от первых двух совпадений:

Он повторял это снова и снова: "Я виноват, я виноват, я ни в чём не виноват!"

Чувствительность к регистру в методе replace()

Метод чувствителен к регистру, поэтому если мы попросим заменить строчные буквы «а» в слове «Анаграмма», первая заглавная буква останется без изменений.

Проверим на таком примере:

# создаём строку
text = 'Бен Роджерс, если бы я был такой неуч, я бы больше молчал'

Попробуем заменить слова без учёта регистра:

# применяем метод
new_text = text.replace('бен роджерс', 'Джо Гарпер')

# проверяем результат
print(new_text)

Выводим текст на экран и видим, что replace() оставил его без изменений:

Бен Роджерс, если бы я был такой неуч, я бы больше молчал

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

# пробуем заменить слова без учёта регистра
new_text = text.replace('Бен Роджерс', 'Джо Гарпер')

# проверяем результат
print(new_text)

Теперь программа находит нужное место:

Джо Гарпер, если бы я был такой неуч, я бы больше молчал

Замена нескольких значений с помощью метода replace()

Если немного усложнить логику, можно заменять несколько слов в тексте. Мы покажем, как это делать с использованием словаря и списка.

Замена с использованием словаря

Словарь — структура элементов, которая состоит из пар «ключ-значение». Это подходит под формулу replace(), если в качестве ключа передавать существующий фрагмент строки, а вместо значения — строку для замены.

Сначала посмотрим на код, а потом разберём его подробнее:

# исходная строка
text = "Я люблю яблоки и бананы"

# словарь замен: что → на что
replacements = {
   "яблоки": "апельсины",
   "бананы": "клубнику"
}

# применяем все замены по очереди
for old, new in replacements.items():
   text = text.replace(old, new)

print(text)

В программе мы:

Выводим обработанный текст на экран:

Я люблю апельсины и клубнику

Замена с использованием списков

Можно заранее подготовить списки: один — что менять, другой — на что менять. Это примерно похоже на две колонки в таблице, «старое» и «новое».

Как выглядит код:

# исходная строка
text = "1, 2, 3, 4"

# списки для замены
old_items = ["1", "2", "3", "4"]
new_items = ["один", "два", "три", "четыре"]

# заменяем элементы один за другим
for old, new in zip(old_items, new_items):
   text = text.replace(old, new)

# выводим результат на экран
print(text)

Как он работает:

Получаем новую строку:

один, два, три, четыре

Альтернативные методы замены строк

У replace() есть свои ограничения. Для более сложных задач в Python можно использовать другие инструменты.

Использование re.sub() для сложных замен

Модуль re используется для работы с регулярными выражениями — текстовыми составными шаблонами, которые можно настроить почти под любую задачу. Проще говоря, если вы хорошо умеете работать с регулярками, то можете сделать с текстом вообще что угодно. Из этого модуля для замены текста используется метод sub().

Когда полезен этот метод:

Для примера сделаем регистронезависимую замену. В исходном тексте создадим слово в верхнем регистре, а в функции укажем в нижнем:

# импортируем модуль re
import re

# создаём исходный текст
strings = "Python is GREAT"

# проводим замену и указываем искомую часть
# строки для замены без учёта регистра.
# для этого указываем флаг re.IGNORECASE
new_text = re.sub(r'great', 'awesome', strings, flags=re.IGNORECASE)

# выводим результат на экран
print(new_text)

Запускаем код и смотрим на результат в консоли:

Python is awesome

Использование translate() для удаления символов

Метод translate() удобен для удаления или замены отдельных символов. Например, можно убрать все точки или запятые из текста. Вот ещё несколько случаев, когда он будет полезен:

Как это может выглядеть в коде:

# создаём текст для работы
text = "Hello, World!"

# создаём таблицу замены и удаления
table = str.maketrans("!", "?", ",")

# применяем таблицу к тексту и сохраняем
new_text = text.translate(table)

# выводим изменённый текст на экран
print(new_text)

Что выйдет в качестве результата в терминале:

Hello World?

Теперь — как именно это работает.

Сначала мы создаём строковую таблицу str.maketrans, в которой указываем через запятую три вида символов: 

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

table = str.maketrans("", "", ",")

Вам слово

Приходите к нам в соцсети поделиться своим мнением об этом методе работы со строками и почитать, что пишут другие. А ещё там выходит дополнительный контент, которого нет на сайте: шпаргалки, опросы и разная дурка. В общем, вот тележка, вот ВК — велком!