Bits und Bytes

Bit

Computer sind prinzipiell dumm und kennen eigentlich nur zwei Zustände: 0 für Strom aus oder Kondensator nicht geladen und 1 für Strom ein oder Kondensator geladen. Ein Zustand entspricht dabei einem Bit als kleinste Informationseinheit. Ein Bit kann daher entweder 0 oder 1 als Wert enthalten. Wenn man nur zwei Ziffern in einem Zahlensystem zur Verfügung hat, spricht man von einem binären Zahlensystem. Aus diesem Grund werden alle Daten im Computer in das binäre Zahlensystem umgewandelt.

In [2]:
# Graphische Aufbereitung der ersten Zahlen des binären Zahlensystems
Out[2]:
structs table Dezimal = *2³ *2² *2¹ *2° = Binär 0 = 0 0 0 0 = 0 1 = 0 0 0 1 = 1 2 = 0 0 1 0 = 10 3 = 0 0 1 1 = 11 4 = 0 1 0 0 = 100 5 = 0 1 0 1 = 101 6 = 0 1 1 0 = 110 7 = 0 1 1 1 = 111 8 = 1 0 0 0 = 1000 9 = 1 0 0 1 = 1001 10 = 1 0 1 0 = 1010 11 = 1 0 1 1 = 1011 12 = 1 1 0 0 = 1100 13 = 1 1 0 1 = 1101 14 = 1 1 1 0 = 1110 15 = 1 1 1 1 = 1111

Byte

Das binäre Zahlensystem ist jedoch in der Darstellung viel zu umfangreich und es lohnt sich jeweils 3 Bits zu einer Ziffer des oktalen Zahlensystems (in dem insgesamt 8 Ziffern von 0 bis 7 zur Verfügung stehen) oder 4 Bits zu einer Ziffer des hexadezimalen Zahlensystems (in dem insgesamt 16 Ziffern von 0 bis 9 sowie von a bis f zur Verfügung stehen). 2 dieser hexadezimalen Ziffern, d.h. also 8 Bit werden nun in allen heute gebräuchlichen Rechnersystemen zu einem Byte zusammengefasst, einer der Grundeinheiten der Darstellung von Zahlen und Zeichen in Computersystemen.

In [3]:
# Graphische Aufbereitung der ersten 256 Zahlen in Bytestruktur
Out[3]:
structs table Dezimal = *2**7 *2**6 *2**5 *2**4 *2³ *2² *2¹ *2° = Binär = Octal = Hexadezimal 0 = 0 0 0 0 0 0 0 0 = 00000000 = 000 = 00 1 = 0 0 0 0 0 0 0 1 = 00000001 = 001 = 01 2 = 0 0 0 0 0 0 1 0 = 00000010 = 002 = 02 3 = 0 0 0 0 0 0 1 1 = 00000011 = 003 = 03 4 = 0 0 0 0 0 1 0 0 = 00000100 = 004 = 04 5 = 0 0 0 0 0 1 0 1 = 00000101 = 005 = 05 6 = 0 0 0 0 0 1 1 0 = 00000110 = 006 = 06 7 = 0 0 0 0 0 1 1 1 = 00000111 = 007 = 07 ... 248 = 1 1 1 1 1 0 0 0 = 11111000 = 370 = f8 249 = 1 1 1 1 1 0 0 1 = 11111001 = 371 = f9 250 = 1 1 1 1 1 0 1 0 = 11111010 = 372 = fa 251 = 1 1 1 1 1 0 1 1 = 11111011 = 373 = fb 252 = 1 1 1 1 1 1 0 0 = 11111100 = 374 = fc 253 = 1 1 1 1 1 1 0 1 = 11111101 = 375 = fd 254 = 1 1 1 1 1 1 1 0 = 11111110 = 376 = fe 255 = 1 1 1 1 1 1 1 1 = 11111111 = 377 = ff

Integer Darstellung

In Python gibt es zur Darstellung von Integer (also ganzen Zahlen) in den jeweiligen Zahlensystemen die Präfixe

  • 0b für das binäre Zahlensystem
  • 0o für das oktale Zahlensystem
  • 0x für das hexadezimal Zahlensystem

sowie die Umwandlungsfunktionen

  • bin() in das binäre Zahlensystem
  • oct() in das oktale Zahlensystem
  • hex() in das hexadezimale Zahlensystem
In [4]:
d = 45
In [5]:
b = bin(d)
b = 0b101101
In [6]:
o = oct(d)
o = 0o55
In [7]:
h = hex(d)
h = 0x2d
In [8]:
%%Mooc StringAssessment
Out[8]:

Binäre Darstellung einer Integer Zahl

In der folgenden Zuweisung wird die Variable a vorbesetzt:


    a = 245

Wie lautet dann die Binäre Darstellung ?



Bitmasken

Komprimierte Informationen in einem Byte

Ein Byte, d.h. acht Bit, entspricht einer Zahl zwischen 0 und 2**8-1 (255).

Ein Byte kann an seinen acht Bit-Positionen unterschiedliche Informationen tragen, z.B. ob der Strom zu einer Lichtquelle angeschaltet (1) oder ausgeschaltet (0) ist oder ob eine an dem Rechner angeschlossene Videokamera angeschaltet (1) oder ausgeschaltet (0) ist oder ob an entsprechenden Sensoren Strom anliegt (1) oder nicht (0).

Wenn jede Information in einer eigenen Variablen abgespeichert wird, muss hierfür auch entsprechend Memory-Speicherplatz bereit gestellt werden. Dies kann gerade bei Informationen, die nur aus 1 oder 0, bzw. an oder aus bestehen in eine einzige Variable zusammengefasst werden. Dazu muss die entsprechende Information immer an die gleiche Bit-Position des Byte geschrieben werden, dann kann diese Information über eine zweite Variable, die Maske aus der ersten Variablen mit dem Und-Operator herausgefiltert werden.

Beispiel

Wenn also immer an der 2. Stelle eines Byte der Status der Lichtquelle steht und an der 3. Stelle der Status der Videokamera:

In dem folgenden Byte (als dezimale Zahl 76)

In [9]:
info = 0b01001100

ist also an der 2. Stelle eine 1 und an der 3. Stelle eine 0.

Die Information über diese beiden interessierenden Stellen bekommt man nun über eine entsprechende Maske heraus, die über die entsprechende Variable gelegt wird, bzw. - mathematisch formuliert - über eine Maske die mit der entsprechenden Variablen über den Und-Operator verknüpft wird. Dann wird an allen Stellen eine 0 angezeigt ausser an den entsprechend interessierenden Stellen, hier jetzt der 2. und 3. Stelle.

Diese Maske lautet

In [10]:
maske = 0b01100000

d.h. es ist an allen Stellen eine 0 ausser an der 2. und 3. Stelle, wo eine 1 anliegt.

Wenn jetzt diese Maske mit der Variablen info über einen Und-Operator verknüpft wird, dann erhält man die beiden gesuchten Werte an der 2. und 3. Stelle aus dieser Variablen:

In [11]:
ergebnis = info & maske

Dies ergibt hier jetzt als Ergebnis 64

In [12]:
ergebnis
Out[12]:
64

bzw. binär

In [13]:
bin(ergebnis)
Out[13]:
'0b1000000'

da führende Nullen normalerweise bei der Ausgabe weggelassen werden, hier im folgenden Code erweitert auf 8 bits in der Ausgabe ergibt

In [14]:
print("'0b{:08b}'".format(ergebnis))
'0b01000000'

Also ist in unserem Beispiel die Lichtquelle angeschaltet und die Videokamera ausgeschaltet.

In [15]:
%%Mooc Video
Out[15]:

Float Darstellung

Fast alle Computer benutzen heutzutage die IEEE-754 - Floating Point Arithmetic. Darin wird festgelegt wie eine reelle Zahl als Näherung in einer Floating Point Number (Gleitkommazahl) in einem entsprechenden Bitmuster abgespeichert wird.

Die Gleitkommazahl r wird dabei mit der folgenden Formel

r = v m 2**e

dargestellt.

  • v ist das Vorzeichen (1 Bit)
  • m ist die Mantisse (23 Bits bei single, 52 Bits bei double) bezeichnet die Ziffernstellen der Gleitkommazahl
  • e ist der Exponent (8 Bits bei single, 16 Bits bei double) zur Basis 2

In Python wird keine Unterscheidung zwischen single und double durchgeführt, sondern nur mit double im Sinne des Standards IEEE754 gerechnet.

Das Minimum und das Maximum erhält man über den folgenden Code:

In [16]:
import sys
print(sys.float_info.min)
print(sys.float_info.max)
2.2250738585072014e-308
1.7976931348623157e+308

Weitere Literatur

In [17]:
%%Mooc WebReference

Wikipedia: IEEE 754

https://de.wikipedia.org/wiki/IEEE_754#.C3.9Cberblick

Hinweis: Beschreibung des IEEE Standards 754, der die Darstellungen für Gleitkommazahlen in Computern beschreibt

In [18]:
%%Mooc WebReference

Python Tutorial: Numbers

https://docs.python.org/3/tutorial/introduction.html#numbers

Hinweis: Grundlegende Eigenschaften von Zahlen in Python

In [19]:
%%Mooc WebReference

Python Library: Standard Types: Numeric Types - int, float, complex

https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex

Hinweis: Genaue Beschreibung der Eigenschaften von Zahlen in Python