Методы строк translate() и maketrans() в Python

Обновлено:

Мы уже знакомы с методом:

replace()

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

Например:

text = 'banana'

print(text.replace('a', '@'))
# b@n@n@

Но иногда нам нужно одновременно заменить или удалить сразу много разных символов.

Для подобных задач в Python существуют:

  • str.translate() — выполняет преобразование строки по таблице замен;
  • str.maketrans() — помогает создать такую таблицу.

1. Метод translate()

Метод translate() принимает таблицу, которая определяет, какие символы нужно заменить, удалить или оставить без изменений.

Простейшей таблицей может быть обычный словарь:

translation_table = {
    97: 64,
    110: 35,
}

Здесь:

  • ключ — код символа, который необходимо заменить;
  • значение — код символа, на который выполняется замена.

Вспомним функции:

ord()
chr()

Например:

print(ord('a'))  # 97
print(ord('@'))  # 64

print(ord('n'))  # 110
print(ord('#'))  # 35

Числа 97, 64, 110 и 35 являются кодами соответствующих символов в Unicode. Для этих символов они также совпадают с кодами ASCII, поскольку ASCII входит в Unicode.

Получается, наша таблица описывает две замены:

'a' → '@'

'n' → '#'

Теперь передадим её методу translate():

text = 'banana'

translation_table = {
    97: 64,
    110: 35,
}

result = text.translate(
    translation_table
)

print(result)

Результат:

b@#@#@

Как работает translate()

Python обрабатывает символы исходной строки и проверяет таблицу замен.

Например:

b → нет в таблице → b
a → код 97       → @
n → код 110      → #
a → код 97       → @
n → код 110      → #
a → код 97       → @

Если символ отсутствует в таблице, он остаётся без изменений.

Как и другие строковые методы, translate() не изменяет исходный объект str, а возвращает результат преобразования.


2. Когда лучше использовать replace()

Если требуется заменить всего один символ:

text = 'banana'

result = text.replace('a', '@')

такая запись значительно проще, чем создание отдельной таблицы:

translation_table = {
    ord('a'): ord('@'),
}

result = text.translate(
    translation_table
)

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

replace()

Но если мы хотим заменить десятки разных символов, отдельная таблица становится гораздо полезнее.


3. Метод str.maketrans()

Создавать таблицы замен вручную не всегда удобно.

Нам приходится самостоятельно получать коды символов:

ord('a')
ord('@')

Поэтому в Python существует специальный метод:

str.maketrans()

Это статический метод класса str. Его можно вызывать непосредственно через класс, не создавая отдельную строку.

В простейшем варианте он принимает две строки:

str.maketrans(
    from_chars,
    to_chars,
)

Первая строка содержит символы, которые нужно заменить.

Вторая — символы, на которые выполняется замена.

Например:

translation_table = str.maketrans(
    'abc',
    '123',
)

print(translation_table)

Результат:

{
    97: 49,
    98: 50,
    99: 51,
}

Метод самостоятельно преобразовал символы в числовые коды.

Получилась таблица:

a → 1
b → 2
c → 3

4. Применяем таблицу

text = 'a cab'

translation_table = str.maketrans(
    'abc',
    '123',
)

print(
    text.translate(translation_table)
)

Результат:

1 312

Каждый символ заменяется соответствующим символом из второй строки.

Например:

a → 1
c → 3
a → 1
b → 2

Пробел не указан в таблице, поэтому остаётся прежним.


5. Длины строк должны совпадать

При создании таблицы через две строки важно, чтобы их длины были одинаковыми.

Правильно:

str.maketrans(
    'abc',
    '123',
)

Здесь обе строки содержат по три символа.

Но:

str.maketrans(
    'abc',
    '12',
)

приведёт к:

ValueError

Потому что непонятно, на какой символ нужно заменить c.

Для этого варианта maketrans() каждому символу первой строки должен соответствовать ровно один символ второй.


Удаление символов

6. Значение None в таблице

Метод translate() умеет не только заменять символы, но и удалять их.

Для этого в таблице в качестве значения используется:

None

Например:

text = 'Hello, world!'

translation_table = {
    ord(','): None,
    ord('!'): None,
}

result = text.translate(
    translation_table
)

print(result)

Результат:

Hello world

Здесь:

',' → None → удалить

'!' → None → удалить

Все остальные символы остаются без изменений.


7. Удаление через maketrans()

Создавать такую таблицу вручную необязательно.

У str.maketrans() существует третий необязательный аргумент:

str.maketrans(
    from_chars,
    to_chars,
    delete_chars,
)

В нём можно указать символы, которые необходимо удалить.

Например:

text = 'Hello, world!'

translation_table = str.maketrans(
    '',
    '',
    ',!',
)

result = text.translate(
    translation_table
)

print(result)

Результат:

Hello world

Первые две строки пустые:

''
''

потому что мы не собираемся ничего заменять.

А третья строка:

',!'

содержит символы, которые нужно удалить.

В результате maketrans() создаст таблицу, в которой соответствующим символам сопоставлено значение None.


8. Замена и удаление одновременно

Можно одновременно передать все три аргумента.

Например:

text = 'we are ready! yes?'

translation_table = str.maketrans(
    'ae',
    '@3',
    '!?',
)

result = text.translate(
    translation_table
)

print(result)

Результат:

w3 @r3 r3@dy y3s

Здесь выполняются сразу четыре правила:

a → @

e → 3

! → удалить

? → удалить

Таким образом, одна таблица позволяет выполнять одновременно разные преобразования.


9. Шифр Цезаря

Рассмотрим более интересный пример применения translate().

Шифр Цезаря — это простой способ шифрования текста, при котором каждая буква заменяется другой буквой, находящейся на определённом расстоянии в алфавите.

Например, при сдвиге на пять позиций:

a → f
b → g
c → h
d → i
e → j

Если мы дойдём до конца алфавита, продолжаем с его начала:

v → a
w → b
x → c
y → d
z → e

Для реализации используем знакомую нам константу из модуля string:

from string import ascii_lowercase

Она содержит английский алфавит в нижнем регистре:

abcdefghijklmnopqrstuvwxyz

10. Реализация шифра Цезаря

from string import ascii_lowercase


def caesar_cipher(
    original_text: str,
    shift: int = 5,
) -> str:
    shift %= len(ascii_lowercase)

    shifted_alphabet = (
        ascii_lowercase[shift:]
        + ascii_lowercase[:shift]
    )

    translation_table = str.maketrans(
        ascii_lowercase,
        shifted_alphabet,
    )

    return original_text.lower().translate(
        translation_table
    )

Используем:

print(
    caesar_cipher('Hello world')
)

Результат:

mjqqt btwqi

11. Разбираем алгоритм по шагам

Первый шаг. Получаем алфавит

ascii_lowercase

содержит:

abcdefghijklmnopqrstuvwxyz

Длина алфавита:

len(ascii_lowercase)

равна:

26

Второй шаг. Нормализуем сдвиг

shift %= len(ascii_lowercase)

Эта операция позволяет корректно обрабатывать разные величины сдвига.

Например:

shift = 5  → 5

shift = 31 → 5

shift = -5 → 21

Почему сдвиг 31 эквивалентен 5?

Потому что после полного обхода всех 26 букв мы возвращаемся к началу алфавита.

Третий шаг. Создаём сдвинутый алфавит

shifted_alphabet = (
    ascii_lowercase[shift:]
    + ascii_lowercase[:shift]
)

При сдвиге 5:

ascii_lowercase[5:]

даёт:

fghijklmnopqrstuvwxyz

А:

ascii_lowercase[:5]

даёт:

abcde

Объединяем:

fghijklmnopqrstuvwxyzabcde

Теперь у нас два алфавита:

Исходный:
abcdefghijklmnopqrstuvwxyz

Сдвинутый:
fghijklmnopqrstuvwxyzabcde

Каждая буква из первой строки должна заменяться соответствующей буквой из второй.

Четвёртый шаг. Создаём таблицу

translation_table = str.maketrans(
    ascii_lowercase,
    shifted_alphabet,
)

Python автоматически создаёт таблицу замен для всех 26 букв.

Например:

a → f
b → g
c → h
...
x → c
y → d
z → e

Пятый шаг. Преобразуем строку

return original_text.lower().translate(
    translation_table
)

Сначала:

original_text.lower()

переводит текст в нижний регистр.

Затем:

translate(translation_table)

заменяет английские буквы по подготовленной таблице.

Пробелы и знаки пунктуации остаются без изменений.


12. Расшифровка

Чтобы расшифровать сообщение, нужно выполнить обратный сдвиг.

encrypted_text = caesar_cipher(
    'Hello world',
    5,
)

print(encrypted_text)
# mjqqt btwqi

Теперь:

decrypted_text = caesar_cipher(
    encrypted_text,
    -5,
)

print(decrypted_text)
# hello world

Отрицательный сдвиг возвращает буквы на прежние позиции.

Обратите внимание: функция предварительно использует lower(), поэтому исходный регистр букв при расшифровке не восстанавливается.

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


Замена одного символа целой строкой

13. Ещё одна возможность translate()

До сих пор мы рассматривали замену:

один символ → один символ

Но translate() умеет заменять один символ целой строкой произвольной длины.

Например, у нас есть текст:

text = 'Room 204 is ready'

Мы хотим заменить цифры на соответствующие английские слова.

Создадим словарь:

digit_names = {
    '0': 'zero',
    '2': 'two',
    '4': 'four',
}

Теперь передадим этот словарь в str.maketrans():

translation_table = str.maketrans(
    digit_names
)

Это ещё одна форма вызова maketrans() — с одним словарём.

В данном случае:

  • ключами могут быть отдельные символы или их Unicode-коды;
  • значениями — Unicode-коды, строки любой длины или None.

Метод преобразует символьные ключи в числовые коды и возвращает таблицу.

Применяем:

result = text.translate(
    translation_table
)

print(result)

Результат:

Room twozerofour is ready

Каждая цифра была заменена целым словом.

При этом translate() не воспринимает 204 как одно число. Он обрабатывает символы по отдельности:

2 → two
0 → zero
4 → four

14. Отличие translate() от replace()

Метод:

replace()

может заменять целые подстроки.

Например:

text = 'Hello world'

print(
    text.replace('world', 'Python')
)

Результат:

Hello Python

Здесь:

'world'

— целая последовательность символов.

translate() так работать не умеет. Он применяет правила к отдельным символам, а не ищет целые подстроки для замены.

Поэтому:

Задача Подходящий метод
Заменить один символ другим replace()
Заменить слово или подстроку replace()
Заменить много отдельных символов по таблице translate()
Удалить много разных символов translate()
Заменить каждый символ целой строкой translate()

Конкретный выбор также может зависеть от читаемости и производительности.


Сравнение производительности

15. Удаление всех ASCII-цифр из строки

Предположим, у нас есть длинная строка с цифрами.

Мы хотим удалить из неё все символы:

0123456789

Сравним четыре способа:

  1. Несколько вызовов replace().
  2. Генераторное выражение и join().
  3. translate() с созданием таблицы при каждом вызове.
  4. translate() с заранее подготовленной таблицей.

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

Код для сравнения

from string import digits
from timeit import timeit


text = (
    'order204 batch17 code903 status50 '
    'user128 product67 retry05 '
) * 30


# Таблица создаётся один раз.
DIGIT_DELETE_TABLE = str.maketrans(
    '',
    '',
    digits,
)


def remove_digits_replace(text: str) -> str:
    for digit in digits:
        text = text.replace(digit, '')

    return text


def remove_digits_generator(text: str) -> str:
    return ''.join(
        char
        for char in text
        if char not in digits
    )


def remove_digits_translate_new(
    text: str,
) -> str:
    table = str.maketrans(
        '',
        '',
        digits,
    )

    return text.translate(table)


def remove_digits_translate_ready(
    text: str,
) -> str:
    return text.translate(
        DIGIT_DELETE_TABLE
    )


print(
    timeit(
        lambda: remove_digits_replace(text),
        number=5000,
    )
)

print(
    timeit(
        lambda: remove_digits_generator(text),
        number=5000,
    )
)

print(
    timeit(
        lambda: remove_digits_translate_new(text),
        number=5000,
    )
)

print(
    timeit(
        lambda: remove_digits_translate_ready(text),
        number=5000,
    )
)

Все четыре функции выполняют одинаковую задачу: удаляют ASCII-цифры из строки.


16. Почему результаты могут отличаться

Первый вариант — replace()

for digit in digits:
    text = text.replace(digit, '')

Для каждой цифры от 0 до 9 вызывается отдельный replace().

То есть мы выполняем десять последовательных операций замены.

При каждой операции обрабатывается текущая строка.

Для одной-двух замен это удобно, но для десяти разных символов код становится менее компактным.

Второй вариант — генераторное выражение

''.join(
    char
    for char in text
    if char not in digits
)

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

Здесь значительная часть работы выполняется на уровне Python, поэтому в подобных простых задачах такой вариант часто оказывается заметно медленнее встроенных строковых методов.

Третий вариант — translate() с созданием таблицы

def remove_digits_translate_new(
    text: str,
) -> str:
    table = str.maketrans(
        '',
        '',
        digits,
    )

    return text.translate(table)

При каждом вызове функции сначала создаётся новый словарь с правилами удаления.

Затем вызывается translate().

Само создание таблицы тоже требует времени.

Четвёртый вариант — заранее подготовленная таблица

DIGIT_DELETE_TABLE = str.maketrans(
    '',
    '',
    digits,
)


def remove_digits_translate_ready(
    text: str,
) -> str:
    return text.translate(
        DIGIT_DELETE_TABLE
    )

Теперь таблица создаётся только один раз.

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

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

Вывод

Для удаления большого набора ASCII-символов заранее подготовленный translate() часто оказывается одним из самых быстрых вариантов.

Но конкретные результаты зависят от версии Python, длины строки, её содержимого и количества замен.

Поэтому правильнее сравнивать реальные измерения через timeit(), а не считать какой-либо метод всегда самым быстрым.


17. Сравнение при удалении одного символа

Теперь рассмотрим противоположную задачу.

Допустим, нам требуется удалить только:

0

Сравним:

replace()

генераторное выражение и:

translate()

Код для сравнения

from timeit import timeit


text = (
    'order204 batch170 code903 '
    'user100 product700 '
) * 30


ZERO_DELETE_TABLE = str.maketrans(
    '',
    '',
    '0',
)


def remove_zero_replace(text: str) -> str:
    return text.replace('0', '')


def remove_zero_generator(text: str) -> str:
    return ''.join(
        char
        for char in text
        if char != '0'
    )


def remove_zero_translate(text: str) -> str:
    return text.translate(
        ZERO_DELETE_TABLE
    )


print(
    timeit(
        lambda: remove_zero_replace(text),
        number=5000,
    )
)

print(
    timeit(
        lambda: remove_zero_generator(text),
        number=5000,
    )
)

print(
    timeit(
        lambda: remove_zero_translate(text),
        number=5000,
    )
)

Здесь во многих версиях CPython replace() оказывается быстрее остальных вариантов.

Почему?

Потому что мы выполняем всего одну простую замену:

text.replace('0', '')

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

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

Кроме того, replace() здесь значительно понятнее.


18. Почему таблицу лучше создавать заранее

Предположим, у нас есть функция, которую программа вызывает тысячи раз.

Если написать:

def clean_text(text: str) -> str:
    table = str.maketrans(
        '',
        '',
        '0123456789',
    )

    return text.translate(table)

то при каждом вызове будет создаваться новая таблица.

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

DIGIT_DELETE_TABLE = str.maketrans(
    '',
    '',
    '0123456789',
)


def clean_text(text: str) -> str:
    return text.translate(
        DIGIT_DELETE_TABLE
    )

Теперь все вызовы функции используют один готовый словарь.

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

Такой приём особенно полезен при многократной обработке строк по одним и тем же правилам.


Краткая таблица возможностей

Конструкция Назначение
text.translate(table) Применить таблицу преобразований
str.maketrans('ab', '12') Создать таблицу замен a → 1, b → 2
str.maketrans('', '', '!?') Создать таблицу удаления ! и ?
str.maketrans('ab', '12', '!?') Одновременно замена и удаление
str.maketrans({'a': 'apple'}) Замена одного символа целой строкой
text.replace('abc', 'xyz') Замена целой подстроки

Главное по теме

Метод:

translate()

использует таблицу для преобразования символов строки.

Например:

table = {
    ord('a'): ord('@'),
}

print('banana'.translate(table))
# b@n@n@

Для удобного создания таблиц существует статический метод:

str.maketrans()

Простейший вариант:

table = str.maketrans(
    'abc',
    '123',
)

Удаление символов:

table = str.maketrans(
    '',
    '',
    '!?',
)

Замена и удаление одновременно:

table = str.maketrans(
    'ae',
    '@3',
    '!?',
)

Применение:

result = text.translate(table)

Также translate() умеет заменять один символ целой строкой, если соответствующая таблица содержит строковые значения.

Практическое правило:

  • Для простой замены одного символа или целой подстроки обычно используем replace().
  • Для большого количества разных посимвольных замен и удалений удобно использовать translate().
  • Если таблица одинаковая для многих вызовов, лучше подготовить её один раз и использовать повторно.

Официальная документация: Python — методы строк translate() и maketrans().