Обработка управляющих последовательностей в строке в Python

Иногда, когда я получаю ввод от файла или пользователя, я получаю строку с escape-последовательностями в ней. Я хотел бы обрабатывать escape-последовательности так же, как Python обрабатывает escape-последовательности в строковых литералах .

Например, допустим, myStringопределяется как:

>>> myString = "spam\\neggs"
>>> print(myString)
spam\neggs

Мне нужна функция (я ее назову process), которая делает это:

>>> print(process(myString))
spam
eggs

Важно, чтобы функция могла обрабатывать все escape-последовательности в Python (перечисленные в таблице по ссылке выше).

Есть ли у Python функция для этого?

Правильнее всего использовать код «escape-последовательность» для декодирования строки.

>>> myString = "spam\\neggs"
>>> decoded_string = bytes(myString, "utf-8").decode("unicode_escape") # python3 
>>> decoded_string = myString.decode('string_escape') # python2
>>> print(decoded_string)
spam
eggs

Не используйте AST или eval. Использование строковых кодеков намного безопаснее.

unicode_escape не работает вообще

Оказывается, решение string_escapeили unicode_escapeвообще не работает - в частности, не работает при наличии действительного Unicode.

Если вы можете быть уверены, что каждый символ, не являющийся символом ASCII, будет экранирован (и помните, что все, что выходит за пределы первых 128 символов, не является символом ASCII), все unicode_escapeбудет правильно для вас. Но если в вашей строке уже есть какие-либо буквальные символы, отличные от ASCII, все пойдет не так.

unicode_escapeв основном предназначен для преобразования байтов в текст Unicode. Но во многих местах - например, в исходном коде Python - исходные данные уже являются текстом Unicode.

Единственный способ, которым это может работать правильно, - это сначала кодировать текст в байты. UTF-8 - разумная кодировка для всего текста, так что она должна работать, верно?

Следующие примеры относятся к Python 3, поэтому строковые литералы чище, но та же проблема существует с немного разными проявлениями как на Python 2, так и на 3.

>>> s = 'naïve \\t test'
>>> print(s.encode('utf-8').decode('unicode_escape'))
naïve   test

Что ж, это неправильно.

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

>>> import codecs
>>> print(codecs.decode(s, 'unicode_escape'))
naïve   test

Не за что. (Кроме того, это UnicodeError на Python 2.)

unicode_escapeКодек, несмотря на свое название, оказывается, предположить , что все не-ASCII байты в кодировке Latin-1 (ISO-8859-1). Итак, вам нужно будет сделать это так:

>>> print(s.encode('latin-1').decode('unicode_escape'))
naïve    test

Но это ужасно. Это ограничивает вас 256 символами Latin-1, как будто Unicode никогда не был изобретен!

>>> print('Ernő \\t Rubik'.encode('latin-1').decode('unicode_escape'))
UnicodeEncodeError: 'latin-1' codec can't encode character '\u0151'
in position 3: ordinal not in range(256)

Добавление регулярного выражения для решения проблемы

(Удивительно, но сейчас у нас нет двух проблем.)

Что нам нужно сделать, так это применить unicode_escapeдекодер только к тем вещам, которые, несомненно, являются текстом ASCII. В частности, мы можем убедиться, что применили его только к допустимым escape-последовательностям Python, которые гарантированно являются текстом ASCII.

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

import re
import codecs

ESCAPE_SEQUENCE_RE = re.compile(r'''
    ( \\U........      # 8-digit hex escapes
    | \\u....          # 4-digit hex escapes
    | \\x..            # 2-digit hex escapes
    | \\[0-7]{1,3}     # Octal escapes
    | \\N\{[^}]+\}     # Unicode characters by name
    | \\[\\'"abfnrtv]  # Single-character escapes
    )''', re.UNICODE | re.VERBOSE)

def decode_escapes(s):
    def decode_match(match):
        return codecs.decode(match.group(0), 'unicode-escape')

    return ESCAPE_SEQUENCE_RE.sub(decode_match, s)

И с этим:

>>> print(decode_escapes('Ernő \\t Rubik'))
Ernő     Rubik

Фактически правильный и удобный ответ для python 3:

>>> import codecs
>>> myString = "spam\\neggs"
>>> print(codecs.escape_decode(bytes(myString, "utf-8"))[0].decode("utf-8"))
spam
eggs
>>> myString = "naïve \\t test"
>>> print(codecs.escape_decode(bytes(myString, "utf-8"))[0].decode("utf-8"))
naïve    test

Подробности относительно codecs.escape_decode:

• codecs.escape_decode это байтовый декодер
• codecs.escape_decodeдекодирует escape-последовательности ascii, такие как: b"\\n"-> b"\n", b"\\xce"-> b"\xce".
• codecs.escape_decode не заботится или не должен знать о кодировке байтового объекта, но кодировка экранированных байтов должна соответствовать кодировке остальной части объекта.

Задний план:

• @rspeer правильный: unicode_escapeэто неправильное решение для python3. Это связано с тем, что unicode_escapeдекодирует экранированные байты, а затем декодирует байты в строку Unicode, но не получает никакой информации о том, какой кодек использовать для второй операции.
• @Jerub прав: избегайте AST или eval.
• codecs.escape_decodeИз этого ответа я впервые обнаружил, что «как мне .decode ('string-escape') в Python3?» . Как говорится в этом ответе, эта функция в настоящее время не задокументирована для python 3.

В ast.literal_evalФункция приближается, но он будет ожидать , что строка , которая будет цитироваться первым.

Конечно, интерпретация Python экранирования обратной косой черты зависит от того, как заключена строка в кавычки ( ""vs r""vs u"", тройные кавычки и т. Д.), Поэтому вы можете заключить пользовательский ввод в подходящие кавычки и перейти к literal_eval. Заключение в кавычки также предотвратитliteral_eval возврат числа, кортежа, словаря и т. Д.

Все еще может стать сложным, если пользователь вводит кавычки без кавычек того типа, который вы собираетесь обернуть вокруг строки.

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

input_string = eval('b"' + sys.argv[1] + '"')

Стоит упомянуть, что существует разница между eval и ast.literal_eval (eval гораздо опаснее). См. Использование функции eval () в python и ast.literal_eval ()?

Код ниже должен работать, если \ n требуется для отображения в строке.

import string

our_str = 'The String is \\n, \\n and \\n!'
new_str = string.replace(our_str, '/\\n', '/\n', 1)
print(new_str)