3. Zeichencodierung

Datenpakete bestehen aus verschiedenen Zahlen und Zeichen. Wie lassen sich diese in Einsen und Nullen übersetzen? Auf dem Computer ist jedem Zeichen eine eindeutige Zahl zugeordnet - eine sog. Zeichencodierung. Eine gängige Zeichencodierung ist etwa ASCII, 128 Zeichen, wobei für ein Zeichen genau 7 bit, also 7 Stellen mit 0 oder 1, notwendig sind. In diesen 128 möglichen Zeichen sind 33 Steuerzeichen und 95 normale Zeichen enthalten.

Steuerzeichen: spezielle Zeichen wie bspw. das Zeichen \n für einen Zeilenumbruch oder \t für einen Tabulator.

Die ASCII-Codierung enthält noch keine Umlaute, weshalb mit Latin 1, 256 Zeichen der Informationsgehalt um ein Bit erhöht wurde, so dass insgesamt 256 Zeichen codiert werden können - die ersten 128 Zeichen sind dabei identisch mit ASCII.

Zeichen	Dezimal	Binär
`\n`	10	`00001010`
`⎵`	32	`00100000`
!	33	`00100001`
&	38	`00100110`
.	46	`00101110`
,	44	`00101100`
-	45	`00101101`
.	46	`00101110`
/	47	`00101111`
0	48	`00110000`
1	49	`00110001`
2	50	`00110010`
3	51	`00110011`
4	52	`00110100`
5	53	`00110101`
6	54	`00110110`
7	55	`00110111`
8	56	`00111000`
9	57	`00111001`
:	58	`00111010`
=	61	`00111101`
?	63	`00111111`
@	64	`01000000`
A	65	`01000001`
B	66	`01000010`
C	67	`01000011`

Zeichen	Dezimal	Binär
D	68	`01000100`
E	69	`01000101`
F	70	`01000110`
G	71	`01000111`
H	72	`01001000`
I	73	`01001001`
J	74	`01001010`
K	75	`01001011`
L	76	`01001100`
M	77	`01001101`
N	78	`01001110`
O	79	`01001111`
P	80	`01010000`
Q	81	`01010001`
R	82	`01010010`
S	83	`01010011`
T	84	`01010100`
U	85	`01010101`
V	86	`01010110`
W	87	`01010111`
X	88	`01011000`
Y	89	`01011001`
Z	90	`01011010`
a	97	`01100001`
b	98	`01100010`
c	99	`01100011`

Zeichen	Dezimal	Binär
d	100	`01100100`
e	101	`01100101`
f	102	`01100110`
g	103	`01100111`
h	104	`01101000`
i	105	`01101001`
j	106	`01101010`
k	107	`01101011`
l	108	`01101100`
m	109	`01101101`
n	110	`01101110`
o	111	`01101111`
p	112	`01110000`
q	113	`01110001`
r	114	`01110010`
s	115	`01110011`
t	116	`01110100`
u	117	`01110101`
v	118	`01110110`
w	119	`01110111`
x	120	`01111000`
y	121	`01111001`
z	122	`01111010`
ä	228	`11100100`
ö	246	`11110110`
ü	252	`11111100`

Komplette Latin 1 Tabelle

Zeichen	Dezimal	Binär
	0	`00000000`
	1	`00000001`
	2	`00000010`
	3	`00000011`
	4	`00000100`
	5	`00000101`
	6	`00000110`
	7	`00000111`
	8	`00001000`
`\t`	9	`00001001`
`\n`	10	`00001010`
	11	`00001011`
	12	`00001100`
	13	`00001101`
	14	`00001110`
	15	`00001111`
	16	`00010000`
	17	`00010001`
	18	`00010010`
	19	`00010011`
	20	`00010100`
	21	`00010101`
	22	`00010110`
	23	`00010111`
	24	`00011000`
	25	`00011001`
	26	`00011010`
	27	`00011011`
	28	`00011100`
	29	`00011101`
	30	`00011110`
	31	`00011111`
`⎵`	32	`00100000`
!	33	`00100001`
"	34	`00100010`
#	35	`00100011`
$	36	`00100100`
%	37	`00100101`
&	38	`00100110`
'	39	`00100111`
(	40	`00101000`
)	41	`00101001`
*	42	`00101010`
+	43	`00101011`
,	44	`00101100`
-	45	`00101101`
.	46	`00101110`
/	47	`00101111`
0	48	`00110000`
1	49	`00110001`
2	50	`00110010`
3	51	`00110011`
4	52	`00110100`
5	53	`00110101`
6	54	`00110110`
7	55	`00110111`
8	56	`00111000`
9	57	`00111001`
:	58	`00111010`
;	59	`00111011`
<	60	`00111100`
=	61	`00111101`
>	62	`00111110`
?	63	`00111111`
@	64	`01000000`
A	65	`01000001`
B	66	`01000010`
C	67	`01000011`
D	68	`01000100`
E	69	`01000101`
F	70	`01000110`
G	71	`01000111`
H	72	`01001000`
I	73	`01001001`
J	74	`01001010`
K	75	`01001011`
L	76	`01001100`
M	77	`01001101`
N	78	`01001110`
O	79	`01001111`
P	80	`01010000`
Q	81	`01010001`
R	82	`01010010`
S	83	`01010011`
T	84	`01010100`
U	85	`01010101`

Zeichen	Dezimal	Binär
V	86	`01010110`
W	87	`01010111`
X	88	`01011000`
Y	89	`01011001`
Z	90	`01011010`
[	91	`01011011`
\	92	`01011100`
]	93	`01011101`
^	94	`01011110`
_	95	`01011111`
`	96	`01100000`
a	97	`01100001`
b	98	`01100010`
c	99	`01100011`
d	100	`01100100`
e	101	`01100101`
f	102	`01100110`
g	103	`01100111`
h	104	`01101000`
i	105	`01101001`
j	106	`01101010`
k	107	`01101011`
l	108	`01101100`
m	109	`01101101`
n	110	`01101110`
o	111	`01101111`
p	112	`01110000`
q	113	`01110001`
r	114	`01110010`
s	115	`01110011`
t	116	`01110100`
u	117	`01110101`
v	118	`01110110`
w	119	`01110111`
x	120	`01111000`
y	121	`01111001`
z	122	`01111010`
{	123	`01111011`
\|	124	`01111100`
}	125	`01111101`
~	126	`01111110`
	127	`01111111`
	128	`10000000`
	129	`10000001`
	130	`10000010`
	131	`10000011`
	132	`10000100`
	133	`10000101`
	134	`10000110`
	135	`10000111`
	136	`10001000`
	137	`10001001`
	138	`10001010`
	139	`10001011`
	140	`10001100`
	141	`10001101`
	142	`10001110`
	143	`10001111`
	144	`10010000`
	145	`10010001`
	146	`10010010`
	147	`10010011`
	148	`10010100`
	149	`10010101`
	150	`10010110`
	151	`10010111`
	152	`10011000`
	153	`10011001`
	154	`10011010`
	155	`10011011`
	156	`10011100`
	157	`10011101`
	158	`10011110`
	159	`10011111`
	160	`10100000`
¡	161	`10100001`
¢	162	`10100010`
£	163	`10100011`
¤	164	`10100100`
¥	165	`10100101`
¦	166	`10100110`
§	167	`10100111`
¨	168	`10101000`
©	169	`10101001`
ª	170	`10101010`

Zeichen	Dezimal	Binär
«	171	`10101011`
¬	172	`10101100`
	173	`10101101`
®	174	`10101110`
¯	175	`10101111`
°	176	`10110000`
±	177	`10110001`
²	178	`10110010`
³	179	`10110011`
´	180	`10110100`
µ	181	`10110101`
¶	182	`10110110`
·	183	`10110111`
¸	184	`10111000`
¹	185	`10111001`
º	186	`10111010`
»	187	`10111011`
¼	188	`10111100`
½	189	`10111101`
¾	190	`10111110`
¿	191	`10111111`
À	192	`11000000`
Á	193	`11000001`
Â	194	`11000010`
Ã	195	`11000011`
Ä	196	`11000100`
Å	197	`11000101`
Æ	198	`11000110`
Ç	199	`11000111`
È	200	`11001000`
É	201	`11001001`
Ê	202	`11001010`
Ë	203	`11001011`
Ì	204	`11001100`
Í	205	`11001101`
Î	206	`11001110`
Ï	207	`11001111`
Ð	208	`11010000`
Ñ	209	`11010001`
Ò	210	`11010010`
Ó	211	`11010011`
Ô	212	`11010100`
Õ	213	`11010101`
Ö	214	`11010110`
×	215	`11010111`
Ø	216	`11011000`
Ù	217	`11011001`
Ú	218	`11011010`
Û	219	`11011011`
Ü	220	`11011100`
Ý	221	`11011101`
Þ	222	`11011110`
ß	223	`11011111`
à	224	`11100000`
á	225	`11100001`
â	226	`11100010`
ã	227	`11100011`
ä	228	`11100100`
å	229	`11100101`
æ	230	`11100110`
ç	231	`11100111`
è	232	`11101000`
é	233	`11101001`
ê	234	`11101010`
ë	235	`11101011`
ì	236	`11101100`
í	237	`11101101`
î	238	`11101110`
ï	239	`11101111`
ð	240	`11110000`
ñ	241	`11110001`
ò	242	`11110010`
ó	243	`11110011`
ô	244	`11110100`
õ	245	`11110101`
ö	246	`11110110`
÷	247	`11110111`
ø	248	`11111000`
ù	249	`11111001`
ú	250	`11111010`
û	251	`11111011`
ü	252	`11111100`
ý	253	`11111101`
þ	254	`11111110`
ÿ	255	`11111111`

Python

Auch in Python werden im Hintergrund Zahlen für Buchstaben und Binärcodes für Dezimalzahlen verwendet. In Python lässt sich die sog. Ordnungszahl eines Buchstabens mit der Funktion ord einfach in Erfahrung bringen.

`ord(<Buchstabe>)`

Die sogenannte Ordnungszahl für einen (einzelnen!) Buchstaben kann mit dem Befehl ord bestimmt werden.

ord_A = ord('A')
ord_a = ord('a')
print('Ordnungszahl A:', ord_A)
print('Ordnungszahl a:', ord_a)

`bin(<Zahl>)`

Eine Dezimalzahl kann in eine Binär-Zahl umgewandelt werden.

binaer = bin(65)
print(binaer)

Hinweis

Mit dem 0b zu Beginn zeigt Python an, dass es sich um eine Binärzahl handelt. Analog zu der Subskript-Schreibweise $1000001_2$ schreibt Python 0b1000001.

`int(<Binärzahl>)`, `int(<BinärZahl>, 2)`

Der Befehl int (Abkürzung für Integer, also Ganze Zahl) kann eine Binärzahl in eine Dezimalzahl übersetzen. Dabei gibt es mehrere Möglichkeiten:

zahl = int(0b1001) # das 0b zeigt Python, dass es sich um eine binäre Zahl handelt
print('1001 binär = ', zahl)

# Achtung! folgende Umwandlung klappt nicht, da jetzt ein Text übergeben wird:
# zahl = int('0b1001')

# oder man teilt Python explizit mit, dass es sich um die Basis 2 handelt
zahl2 = int('1011', 2)
print('1011 binär = ', zahl2)

Hinweis

Der zweite Parameter gibt die Basis des Zahlensystems an, hier also für Binär 2.

`chr(<Zahl>)`

Gibt den zu einer Ordnungszahl gehörenden Buchstaben zurück.

buchstabe = chr(77)
print(buchstabe)

Name->Bin

Ändern Sie das Programm unten so ab, dass Ihr Name ausgegeben wird.

print(bin(ord('R')))
print(bin(ord('e')))
print(bin(ord('t')))
print(bin(ord('o')))

Beschreiben Sie, was genau auf der ersten Zeile passiert. In welcher Reihenfolge werden die drei Befehle print, bin und ord ausgeführt und welche Ergebnisse liefern sie jeweils?

Bin->Name

Ändern Sie das Programm unten so ab, dass Ihr Name aus dem Binären wieder in Text umgewandelt wird.

print(chr(int('1010010', 2)))
print(chr(int('1100101', 2)))
print(chr(int('1110100', 2)))
print(chr(int('1101111', 2)))

Beschreiben Sie, was genau auf der ersten Zeile passiert. In welcher Reihenfolge werden die drei Befehle print, chr und int ausgeführt und welche Ergebnisse liefern sie jeweils?

Binärer Codierer

Aufgabe

Schreiben Sie einen binären Codierer, welcher einen Text ins binäre übersetzt. Im vorgegebenen Code sehen Sie, wie über jeden Buchstaben eines Wortes iteriert werden kann.

for buchstabe in 'Hallo':
    print(buchstabe)

Aufhübschen:

Das 0b kann weggeschnitten werden, indem nur die Buchstaben nach dem zweiten Buchstaben verwendet werden:

binaer = bin(11) # = 0b1011
binaer = binaer[2:] # alles (:) nach dem zweiten Buchstaben wird verwendet
print(binaer)

Jeder Buchstabe soll genau 1 Byte, also 8 Zeichen, umfassen. Dies erreicht man, wenn man mit Nullen (engl. Zeros) auffüllt:
```
binaer = '1011'
binaer = binaer.zfill(8)
print(binaer)
```
Statt immer eine neue Zeile zu verwenden, kann der print-Befehl auch angewiesen werden, am Ende ein Leerschlag einzufügen:
```
for buchstabe in 'Hallo':
    print(buchstabe, end=' ')
```

SSR

CC 4.0

3. Zeichencodierung

Python​

ord(<Buchstabe>)​

bin(<Zahl>)​

int(<Binärzahl>), int(<BinärZahl>, 2)​

chr(<Zahl>)​

Binärer Codierer​