Hallo Herr Schnoor,
danke für die Zusendung der Datei Codepage-univers.py.
Diese Datei enthält allerdings keine Berechnung von Bytes, weder eine
fehlerhafte noch eine korrekte.
Die zuvor übersandte Datei keyboard-coding-asia.py enthält jedoch eine solche
Berechnung.
Dort wird die Anzahl der Bytes eines Strings mittels der Funktion unit()
bestimmt, und zwar so:
def unit(digit): # --------------------- Analyse der Anzahl <bits>
---------------------
# digit = Ordnungszahl ord(ch) eines UTF8-Zeichens ch (Einfügung von mir,
WB)
if digit < 256:
byte = 1
elif digit > 256 and digit < 65536:
byte = 2
elif digit > 65535 and digit <16777215:
byte = 3
elif digit > 16777215:
byte = 4
return byte
Wie dieser Python-Coder verrät, sind – oder waren – Sie offenbar davon
überzeugt, dass für die Codierung der Codepoint-Nummer eines UTF8-Zeichens für
jedes der möglichen 1/2/3/4 Bytes alle 8 Bit eines Bytes zur Verfügung stehen.
(Für 1 Byte 2**8 = 256 Bit, für 2 Byte 2**16 = 65536 Bit, etc.)
Dies ist jedoch nicht der Fall. Denn die Bytes enthalten – zusätzlich zur
Codepoint-Nummer – noch einen Geheimcode (den Sie als Experte für Codierung –
unbegreiflicherweise – nicht zu kennen scheinen).
Dieser Geheimcode ist eine Markierung dafür, aus wie vielen Byte ein Zeichen
besteht.
Bei einem Ein-Byte-Zeichen beginnt dieses Solo-Byte mit einem 0-Bit.
Ein Mehr-Byte-Zeichen besteht logischerweise aus einer Gruppe zusammengehöriger
Bytes,
einem sogenannten Start-Byte und ein oder mehreren Folge-Bytes:
Das Start-Byte beginnt mit einer Folge von 1-Bits, deren Anzahl gleich der
Anzahl der Folge-Bytes entspricht (11, 111, 1111 = 2,3,4 Folge-Bytes).
In der folgenden Tabelle sind die Intervalle der Ordnungszahlen für 1/2/3/4
Bytes
sowie die geheime Bit-Struktur des Codes dargestellt ( vgl.
https://en.wikipedia.org/wiki/UTF-8#Encoding ):
Code point ↔ UTF-8 conversion
First code point Last code point Byte 1 Byte 2
Byte 3 Byte 4
U+0000 U+007F 0xxxxxxx
U+0080 U+07FF 110xxxxx 10xxxxxx
U+0800 U+FFFF 1110xxxx 10xxxxxx 10xxxxxx
U+010000 U+10FFFF 11110xxx 10xxxxxx
10xxxxxx 10xxxxxx
Aufgrund der Ordnung der Intervalle nach Byte-Anzahlen kann man nun aus der
Ordnungszahl ord(ch) eines UTF8-Zeichens ch leicht seine Byteanzahl berechnen,
etwa mit folgender Python-Funktion:
def getNumBytes(ch):
"liefert die Anzahl der Bytes (1 bis 4) des UTF8-Zeichens ch via ord(ch)"
MaxUTF8 = 1114111
point = ord(ch)
if point in range(0, 2**7): return 1
elif point in range(2**8, 2**11): return 2
elif point in range(2**11, 2**16): return 3
elif point in range(2**16, 1 + MaxUTF8): return 4
Dieser Geheimcode ist doch clever gemacht von den Entwicklern der
UTF8-Codierung der Unicode-Zeichen, oder?
W. Büchel
_______________________________________________
python-de Mailingliste -- [email protected]
Zur Abmeldung von dieser Mailingliste senden Sie eine Nachricht an
[email protected]
https://mail.python.org/mailman3/lists/python-de.python.org/
Mitgliedsadresse: [email protected]
