[Python3] Wechseln Sie zwischen Shift_JIS, UTF-8 und ASCII

Einführung

Lassen Sie uns in Python3 die verstümmelte Ausgabezeichenfolge wie `\ udc82 \ udce7 \ udc83J \ udc83 ^ \ udc8a \ udcbf \ udc8e \ udc9a' anzeigen. Es ist ein Versuch.

Referenz

• Unicode HOWTO
• Standardcodierung

Wenn die Shift_JIS-Bytezeichenfolge UTF-8-decodiert ist

Standardmäßig `` `UnicodeDecodeError```

Der Versuch, eine Shift_JIS-Bytezeichenfolge zu dekodieren (standardmäßig UTF-8), führt zu einem `` `UnicodeDecodeError```

>>> bytes_sjis = "Hirakata Kanji".encode("shift_jis")
>>> bytes_sjis
b'\x82\xd0\x82\xe7\x83J\x83^\x8a\xbf\x8e\x9a'
>>> bytes_sjis.decode()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'utf-8' codec can't decode byte 0x82 in position 0: invalid start byte

Dekodierungsergebnis, wenn ein Fehlerbehandler angegeben ist

Der Fehler tritt im vorherigen Abschnitt auf, weil das optionale Argument `error``` von` decode () `standardmäßig` "strict" `` `ist. Wenn Sie "Fehler" einen anderen Wert angeben, tritt kein Fehler auf und eine weitere Zeichenfolge wird zurückgegeben. Das Argument> error gibt an, was zu tun ist, wenn die Eingabezeichenfolge nicht gemäß den Codierungsregeln konvertiert werden kann. Die Werte, die für dieses Argument verwendet werden können, sind 'strict' (Senden Sie einen Unicodedecodeerror)、 'replace' (replacement characterIstu+fffdverwenden)、 'ignore' (Entfernen Sie einfach die Zeichen aus dem resultierenden Unicode) 、 'backslashreplace' (Fluchtabfolge\xnnEinführen)ist. Unicode HOWTO

Daneben können Sie auch "Surrogateescape" angeben.

`'Surrogateescape' - Ersetzen Sie die Byte-Zeichenfolge durch einzelne Surrogat-Codes im Bereich von U + DC80 bis U + DCFF. 7.2. Codecs - Codec-Registrierung und Basisklasse

Sehen wir uns das Ausgabeergebnis an.

>>> bytes_sjis.decode("utf-8", errors="replace")
'�Ђ�J�^����'
>>> bytes_sjis.decode("utf-8", errors="ignore")
'ЂJ^'
>>> bytes_sjis.decode("utf-8", errors="backslashreplace")
'\\x82Ђ\\xe7\\x83J\\x83^\\x8a\\xbf\\x8e\\x9a'
>>> bytes_sjis.decode("utf-8", errors="surrogateescape")
'\udc82Ђ\udce7\udc83J\udc83^\udc8a\udcbf\udc8e\udc9a'

Die Anzeige in der Windows-Umgebung (CP932 ~ Shift_JIS), die sich nicht in der UTF-8-Umgebung befindet, sieht übrigens wie folgt aus.

>>> bytes_sjis.decode("utf-8", errors="replace")
'\ufffd\u0402\ufffdJ\ufffd^\ufffd\ufffd\ufffd\ufffd'
>>> bytes_sjis.decode("utf-8", errors="ignore")
'\u0402J^'
>>> bytes_sjis.decode("utf-8", errors="backslashreplace")
'\\x82\u0402\\xe7\\x83J\\x83^\\x8a\\xbf\\x8e\\x9a'
>>> bytes_sjis.decode("utf-8", errors="surrogateescape")
'\udc82\u0402\udce7\udc83J\udc83^\udc8a\udcbf\udc8e\udc9a'

Stellen Sie die ursprüngliche Zeichenfolge aus dem Ergebnis der Dekodierung der Shift_JIS-Bytezeichenfolge mit UTF-8 wieder her.

'replace'Oder'ignore'Wenn angegeben, wurden die Informationen gelöscht und können nicht wiederhergestellt werden, aber In anderen Fällen können Sie die ursprüngliche Zeichenfolge wie unten gezeigt wiederherstellen. Warum ist das bei #backslashreplace möglich ...? ?? ??

>>> bytes_sjis = "Hirakata Kanji".encode("shift_jis")
>>> backslash_str = bytes_sjis.decode("utf-8", errors="backslashreplace")
>>> backslash_str.encode().decode("unicode_escape").encode("raw_unicode_escape").decode("shift_jis")
'Hirakata Kanji'

>>> surrogate_str = bytes_sjis.decode("utf-8", errors="surrogateescape")
>>> surrogate_str.encode("utf-8", errors="surrogateescape").decode("shift_jis")
'Hirakata Kanji'

Wenn eine UTF-8-Byte-Zeichenfolge ASCII-decodiert wird

Lassen Sie uns UTF-8-> ASCII-> UTF-8 sowie Shift_JIS-> UTF-8-> Shift_JIS-Konvertierung durchführen.

Standardmäßig `` `UnicodeDecodeError```

>>> bytes_utf8 = "Hirakata Kanji".encode("utf-8")
>>> bytes_utf8
b'\xe3\x81\xb2\xe3\x82\x89\xe3\x82\xab\xe3\x82\xbf\xe6\xbc\xa2\xe5\xad\x97'
>>> bytes_utf8.decode("ascii")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe3 in position 0: ordinal not in range(128)

Dekodierungsergebnis, wenn ein Fehlerbehandler angegeben wird

>>> bytes_utf8.decode("ascii", errors="ignore")
''
>>> bytes_utf8.decode("ascii", errors="replace")
'������������������'
>>> bytes_utf8.decode("ascii", errors="backslashreplace")
'\\xe3\\x81\\xb2\\xe3\\x82\\x89\\xe3\\x82\\xab\\xe3\\x82\\xbf\\xe6\\xbc\\xa2\\xe5\\xad\\x97'
>>> bytes_utf8.decode("ascii", errors="surrogateescape")
'\udce3\udc81\udcb2\udce3\udc82\udc89\udce3\udc82\udcab\udce3\udc82\udcbf\udce6\udcbc\udca2\udce5\udcad\udc97'

Stellt die ursprüngliche Zeichenfolge aus dem Ergebnis der Dekodierung der UTF-8-Byte-Zeichenfolge mit ASCII wieder her

Für UTF-8 und ASCII scheint es in Ordnung zu sein, `.encode (). Decode ()` auszuführen.

>>> backslash_str = bytes_utf8.decode("utf-8", errors="backslashreplace")
>>> backslash_str.encode().decode()
'Hirakata Kanji'
>>> surrogate_str = bytes_utf8.decode("utf-8", errors="surrogateescape")
>>> surrogate_str.encode().decode()
'Hirakata Kanji'

Häufige Beispiele

Lassen Sie uns abschließend ein Beispiel für den Versuch geben, es mit Gewalt wiederherzustellen, wenn Sie vergessen, es festzulegen, und die Zeichen verstümmelt sind.

Wenn Sie vergessen, `sure_ascii = False``` zu setzen, wenn Sie` json``` ausgeben

>>> import json
>>> ascii_json = json.dumps({"Schlüssel":"Wert"})
>>> ascii_json
'{"\\u30ad\\u30fc": "\\u5024"}'
>>> ascii_json.encode().decode("unicode_escape")
'{"Schlüssel": "Wert"}'
>>> ascii_json.encode().decode("raw_unicode_escape")
'{"Schlüssel": "Wert"}'

Wenn die `Codierung``` des Ergebnisses, das durch` Anfragen` `` erhalten wird, nicht geändert wird

>>> import requests
>>> r = requests.get('http://www.mof.go.jp/')
>>> r.text
'...
<meta property="og:title" content="\x8dà\x96±\x8fÈ\x83z\x81[\x83\x80\x83y\x81[\x83W" />
...'
>>> r.text.encode("raw_unicode_escape").decode("shift_jis")
'...
<meta property="og:title" content="Homepage des Finanzministeriums" />
...'