Как удалить\n, \ ", \\ и т. Д. Из строки [duplicate]

Фактически правильный и удобный ответ для 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 числа, кортежа, словаря и т. Д.

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

Если вы доверяете источнику данных, просто пошагите кавычки вокруг него и eval () it?

>>> myString = 'spam\\neggs'
>>> print eval('"' + myString.replace('"','') + '"')
spam
eggs

PS. добавлена ​​встречная мера зла-кода-exec - теперь она будет разбивать все " до eval-ing

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, находятся в латинском-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

Ответ rspeer правильно указывает на то, что unicode-escape подразумевает неявное декодирование с использованием latin-1, но не выполняет его. Если unicode-escape правильно декодирует экраны, но неправильно обрабатывает необработанные байты без ASCII, расшифровывая их как latin-1, то прямое исправление не должно принимать регулярное выражение, а затем перекодировать их как latin-1 после (отменить ошибочная часть процесса), а затем декодировать в правильной кодировке. Например, неправильное использование образца:

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

можно сделать тривиально правильным, добавив .encode('latin-1').decode('utf-8'), сделав его:

>>> s = 'naïve \\t test'
>>> print(s.encode('utf-8').decode('unicode_escape').encode('latin-1').decode('utf-8'))
naïve    test
# Or using codecs.decode to replace the first encode/decode pair with a single text->text transform:
>>> print(codecs.decode(s, 'unicode_escape').encode('latin-1').decode('utf-8'))
naïve    test

Конечно, это много назад и вперед, и я бы не хотел его встроить в свой код, но его можно разделить на автономную функцию, которая работает как для str, так и для bytes (с необязательным шагом декодирования для bytes if результат в известной кодировке):

def decode_escapes(s, encoding=None):
    if isinstance(s, str):
        if encoding is not None:
            return TypeError("Do not pass encoding for string arguments")
        # UTF-8 will allow correct interpretation of escapes when bytes form
        # interpreted as latin-1
        s = s.encode('utf-8')
        encoding = 'utf-8'
    decoded = s.decode('unicode_escape').encode('latin-1')
    if encoding is not None:
        # If encoding is provided, or we started with an arbitrary string, decode
        decoded = decode.decode(encoding)
    return decoded

Ниже приведен код, который должен работать для\n, который должен отображаться в строке.

import string

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