Verarbeiten Sie Escape-Sequenzen in einer Zeichenfolge in Python

Wenn ich Eingaben von einer Datei oder vom Benutzer erhalte, erhalte ich manchmal eine Zeichenfolge mit Escape-Sequenzen. Ich möchte die Escape-Sequenzen genauso verarbeiten wie Python Escape-Sequenzen in String-Literalen .

Angenommen, es myStringist definiert als:

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

Ich möchte eine Funktion (ich werde sie nennen process), die dies tut:

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

Es ist wichtig, dass die Funktion alle Escape-Sequenzen in Python verarbeiten kann (in einer Tabelle im obigen Link aufgeführt).

Hat Python eine Funktion, um dies zu tun?

Das Richtige ist, den 'String-Escape'-Code zu verwenden, um den String zu dekodieren.

>>> 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

Verwenden Sie nicht den AST oder die Bewertung. Die Verwendung der String-Codecs ist viel sicherer.

unicode_escape funktioniert im Allgemeinen nicht

Es stellt sich heraus, dass die Lösung string_escapeoder unicode_escapeim Allgemeinen nicht funktioniert - insbesondere nicht , wenn tatsächlich Unicode vorhanden ist.

Wenn Sie sicher sein können, dass jedes Nicht-ASCII-Zeichen maskiert wird (und denken Sie daran, dass alles, was über die ersten 128 Zeichen hinausgeht, kein ASCII-Zeichen ist), unicode_escapewird dies das Richtige für Sie tun. Wenn Ihre Zeichenfolge jedoch bereits wörtliche Nicht-ASCII-Zeichen enthält, wird ein Fehler auftreten.

unicode_escapeist grundsätzlich darauf ausgelegt, Bytes in Unicode-Text umzuwandeln. Aber an vielen Stellen - zum Beispiel im Python-Quellcode - sind die Quelldaten bereits Unicode-Text.

Dies kann nur dann richtig funktionieren, wenn Sie den Text zuerst in Bytes codieren. UTF-8 ist die sinnvolle Codierung für den gesamten Text, damit das funktioniert, oder?

Die folgenden Beispiele befinden sich in Python 3, sodass die Zeichenfolgenliterale sauberer sind. Das gleiche Problem besteht jedoch bei leicht unterschiedlichen Erscheinungsformen in Python 2 und 3.

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

Nun, das ist falsch.

Die neue empfohlene Methode zur Verwendung von Codecs, die Text in Text dekodieren, besteht darin, codecs.decodedirekt aufzurufen . Hilft das?

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

Überhaupt nicht. (Außerdem ist das Obige ein UnicodeError unter Python 2.)

Der unicode_escapeCodec geht trotz seines Namens davon aus, dass alle Nicht-ASCII-Bytes in der Latin-1-Codierung (ISO-8859-1) vorliegen. Sie müssten es also so machen:

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

Aber das ist schrecklich. Dies beschränkt Sie auf die 256 Latin-1-Zeichen, als wäre Unicode überhaupt nicht erfunden worden!

>>> 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)

Hinzufügen eines regulären Ausdrucks zur Lösung des Problems

(Überraschenderweise haben wir jetzt keine zwei Probleme.)

Was wir tun müssen, ist, den unicode_escapeDecoder nur auf Dinge anzuwenden , von denen wir sicher sind, dass sie ASCII-Text sind. Insbesondere können wir sicherstellen, dass es nur auf gültige Python-Escape-Sequenzen angewendet wird, bei denen es sich garantiert um ASCII-Text handelt.

Der Plan ist, Escape-Sequenzen mit einem regulären Ausdruck zu finden und eine Funktion als Argument zu verwenden re.sub, um sie durch ihren nicht entkoppelten Wert zu ersetzen.

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)

Und damit:

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

Die eigentlich richtige und bequeme Antwort für 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

Details zu codecs.escape_decode:

• codecs.escape_decode ist ein Byte-zu-Byte-Decoder
• codecs.escape_decodedecodiert ASCII-Escape-Sequenzen wie: b"\\n"-> b"\n", b"\\xce"-> b"\xce".
• codecs.escape_decode kümmert sich nicht um die Codierung des Byte-Objekts oder muss diese kennen, aber die Codierung der maskierten Bytes sollte mit der Codierung des restlichen Objekts übereinstimmen.

Hintergrund:

• @rspeer ist richtig: unicode_escapeist die falsche Lösung für Python3. Dies liegt daran, dass unicode_escapedekodierte Bytes decodiert und dann Bytes in Unicode-Zeichenfolgen decodiert werden, aber keine Informationen darüber erhalten, welcher Codec für die zweite Operation verwendet werden soll.
• @ Jerub ist richtig: Vermeiden Sie die AST oder Auswertung.
• Ich entdeckte zuerst codecs.escape_decodeaus dieser Antwort: "Wie kann ich .decode ('string-Escape') in Python3?" . Wie in dieser Antwort angegeben, ist diese Funktion derzeit für Python 3 nicht dokumentiert.

Die ast.literal_evalFunktion kommt nahe, aber es wird erwartet, dass die Zeichenfolge zuerst richtig in Anführungszeichen gesetzt wird.

Natürlich hängt Pythons Interpretation von Backslash-Escapezeichen davon ab, wie die Zeichenfolge in Anführungszeichen gesetzt wird ( ""vs r""vs u"", dreifache Anführungszeichen usw.). Daher möchten Sie möglicherweise die Benutzereingaben in geeignete Anführungszeichen setzen und an übergeben literal_eval. Wenn Sie es in Anführungszeichen setzen, wird auch verhindert literal_eval, dass eine Zahl, ein Tupel, ein Wörterbuch usw. zurückgegeben werden.

Es kann immer noch schwierig werden, wenn der Benutzer nicht zitierte Anführungszeichen des Typs eingibt, den Sie um die Zeichenfolge wickeln möchten.

Dies ist eine schlechte Methode, aber es hat bei mir funktioniert, als ich versucht habe, maskierte Oktale zu interpretieren, die in einem String-Argument übergeben wurden.

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

Es ist erwähnenswert, dass es einen Unterschied zwischen eval und ast.literal_eval gibt (eval ist viel unsicherer). Siehe Verwenden von pythons eval () vs. ast.literal_eval ()?

Der folgende Code sollte funktionieren für \ n muss in der Zeichenfolge angezeigt werden.

import string

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