Zahlensysteme & Datentypen

Lernziele

Praktische Python Befehle

# Length
len("laenge von einem String oder Liste ...")
 
# Data types
str(42)
int("132")
float(13)
type(42)
bin(132)
 
# Strings
s = "ich bin ein String"
s[2:]
s[4:7]
s[:5]
s.replace('b','B')
li = s.split(' ')
s.strip("    hallo     ")
s.lstrip("    hallo     ")
s.rstrip("    hallo     ")
s = s.upper()
s = s.lower()
s.find("bin")
many_zeros_string = "0" * 100
 
## TIPP: In diesem Thema bietet es sich meist an, mit Strings anstelle Listen zu arbeiten. Sollte man aber das Bedürfnis nach Listen haben, hier die wichtigsten Befehle:
li = ['k','s','r']
len(li)
li.append('romanshorn')
li.pop(2)
li.remove('k')
print(li)

Aus dem Grundlagenfach weisst du bereits, was Zahlensysteme sind. Insbesondere kennst du das Binärsystem und kannst:

• Umrechnen: Dezimalsystem ↔ Binärsystem
• Darstellung negativer Zahlen
• Rechnen mit Binärzahlen: Addition, Multiplikation, Subtraktion
• mithilfe des Binärsystems Mitmenschen (die es verdient haben) eloquent beleidigen können
• Gegeben $x-$Bits für Darstellung → min./max. Zahl bestimmen, die damit dargestellt werden kann

Das Dossier Zahlensysteme aus dem Grundlagenfach findest du hier: Dossier Zahlensysteme (GFIF)

Beim Programmieren kennen wir viele verschiedene Datentypen wie:

• Integer (kurz: int): also ganze Zahlen $\ldots,-3,-2,-1,0,1,2,3,\ldots$
• Floats: Gleitkommazahlen, z.B. $3.14$
• Strings: Text, z.B. "Das EFIF ist super!"
• und viele weitere

Für einen Computer macht es einen grossen Unterschied, ob es sich bei einer Variablen um einen Integer oder einen Float handelt, da diese im Hintergrund ganz anders gespeichert werden. Zum Beispiel ist für ein Computer 4 (int) nicht das Gleiche wie 4.0 (float), auch wenn die beiden Zahlen mathematisch identisch sind.

In Python muss man sich nicht wirklich um Datentypen kümmern, was sowohl eine der grössten Stärken wie auch Schwächen von Python ist. Zum Beispiel kann man in Python eine Variable ganz einfach direkt festlegen:

i = 42
f = 3.14
s = "Das EFIF ist super!"

Python erkennt dann automatisch, um was für einen Datentypen es sich handelt. Überzeuge dich selbst mit print(type(...)), dass es sich hier um die folgenden Datentypen handelt:

print(type(i)) # Output: <type 'int'>
print(type(f)) # Output: <type 'float'>
print(type(s)) # Output: <type 'str'>

In Python kann man eine Variable auch problemlos in einen anderen Typen umwandeln:

i = 42 # zuerst int
i = "Ich bin jetzt ein String, holt mich hier raus!" # jetzt ploetzlich String

Aus diesem Grund spricht man in Python von dynamischer Typisierung.

In vielen anderen Programmiersprachen wie C#, C++ oder Java geniesst man diese Freiheiten nicht. Man spricht dann von statischer Typisierung und typsichere Sprachen. In solchen müssen Variablen explizit deklariert, d.h. es muss angegeben werden, für welchen Datentypen man diese Variable verwenden möchte. Einmal festgelegt, kann der Datentyp nicht mehr verändert werden. Möchte man zum Beispiel einem Integer einen Float zuweisen, so erhält man eine Fehlermeldung:

Zum Beispiel in C++ (was wir für Arduino brauchen werden):

int i; // separate Deklaration ...
i = 42; // und Wertzuweisung
 
float f = 3.14; // Deklaration und Wertzuweisung in einer Zeile

Von nun an wollen wir uns nur noch mit typsicheren Programmiersprachen beschäftigen.

Deklariert man eine Integer-Variable int x;, so wird im Arbeitsspeicher für die Variable x der Speicherplatz reserviert, der einem Integer zusteht. Weise ich der Variable nun einen zu grossen Wert zu, so kann dieser nicht gespeichert werden. In dem Fall muss man auf einen Datentypen ausweichen, dem mehr Speicherplatz zur Verfügung steht.

Wir werden bald mit Arduinos, genauer Arduino Unos, arbeiten. Für diese stehen uns drei Datentypen für das speichern von ganzen Zahlen zur Verfügung:

• int: 16 Bit (negative und positive Zahlen)
• unsigned int: 16 Bit (nur positive Zahlen: $0,1,2,\ldots$)
• long: 32 Bit

Hilfreiches Online-Tool: https://zahlensysteme-rechner.de

Das Rechnen mit ganzen Zahlen am Computer ist relativ problemfrei. So kann man davon ausgehen, dass der Computer einem immer exakte Resultate liefert - zumindest so lange man nicht den Bereich verlässt, der vom Datentyp (Z.B. int oder long) abgedeckt wird. Zum Beispiel kann man mit einem 32-Bit-Datentyp für ganze Zahlen (z.B. long auf Arduino Uno) sämtliche ganzen Zahlen beschreiben, die es im Bereich $-2147483648$ bis $2147483647$ gibt.

Bei Gleitkommazahlen, also Zahlen mit Nachkommastellen, sieht es da anders aus. Beispielsweise gibt es nur schon im Intervall zwischen $0$ und $1$ unendlich viele rationale und reelle Zahlen! Dies führt dazu, dass Werte meist gerundet werden müssen und damit nicht exakt dargestellt werden können. Rechnet man dann mit diesen gerundeten Werten weiter, so können sich diese Ungenauigkeiten verstärken.

Daraus resultiert folgende Programmierweisheit: Wenn immer möglich, sollte man mit Integers (int/long/uint/…) erledigen. Gleitkommazahlen (float/double) sollte man nur verwenden, wenn es nicht anders geht!

Um zu verstehen, wie Gleitkommazahlen in Computern gespeichert werden, lohnt es sich, sich die wissenschaftliche Schreibweise, in Erinnerung zu rufen. Diese Schreibweise solltest du aus dem Mathematikunterricht kennen. In dieser Schreibweise hat eine Zahl immer die folgende Form: $$\pm a \times 10^b$$

• Die Stelle ganz links beinhaltet das Vorzeichen und entscheidet deshalb darüber, ob die Zahl positiv oder negativ ist.
• Die Zahl $a$ vor der Potenz wird Mantisse genannt und erfüllt die Bedingung $1\leq a < 10$. Sie ist also eine Gleitkommazahl, wobei genau eine Ziffer ausser $0$ vor dem Dezimalpunkt steht.
• Die Zahl $b$ wird Exponent genannt. Grosse Zahlen haben einen positiven, kleine einen negativen Exponenten. Du kannst dir vorstellen, dass der Exponent das Komma verschiebt.

Zum Beispiel sieht die wissenschaftliche Schweibweise der Zahl $-72024$ wie folgt aus: $$-7.2024 \cdot 10^4$$ Gut an der wissenschaftlichen Schreibweise ist, dass sie eine Zahl eindeutig beschreibt. Besonders nützlich ist sie für sehr kleine und grosse Zahlen.

Eine Gleitkomma-Dezimalzahl kann man wie folgt darstellen: $$\color{blue}{42}.\color{blue}{13}_\color{magenta}{10}= \color{blue}{4} \cdot \color{magenta}{10}^\color{green}{1} + \color{blue}{2} \cdot \color{magenta}{10}^\color{green}{0} + \color{blue}{1} \cdot \color{magenta}{10}^\color{green}{-1} + \color{blue}{3} \cdot \color{magenta}{10}^\color{green}{-2}$$

Gleichermassen kann eine Gleitkomma-Binärzahl dargestellt werden: $$\color{blue}{101}.\color{blue}{11}_\color{magenta}{2}= \color{blue}{1} \cdot \color{magenta}{2}^\color{green}{2} + \color{blue}{0} \cdot \color{magenta}{2}^\color{green}{1} + \color{blue}{1} \cdot \color{magenta}{2}^\color{green}{0} + \color{blue}{1} \cdot \color{magenta}{2}^\color{green}{-1} + \color{blue}{1} \cdot \color{magenta}{2}^\color{green}{-2} $$

Um eine Binärzahl mit Nachkommastellen im Speicher eines Computers zu speichern, bringt man diese zuerst in die wissenschaftliche Schreibweise. Im Speicher werden dann Vorzeichen, Mantisse und Exponent einzeln gespeichert. Dabei ist ein Bit für das Vorzeichen und jeweils eine feste Anzahl Bits für Mantisse und Exponent festgelegt. Aus dieser Information kann dann die Zahl rekonstruiert werden.

Die wissenschaftliche Schreibweise für Binärzahlen funktioniert analog zu der für Dezimalzahlen. Beachte, dass in der Mantisse die Ziffer vor dem Punkt eine Eins sein muss. Die einzige Ausnahme ist die Zahl $0_2$. Beim Speichern einer Zahl mit Nachkommastellen wird deshalb diese erste $1$ weggelassen - so spart man sich ein Bit! Man sagt, dass die Mantisse normalisiert wird:

In Exponenten möchte man negative Zahlen verhindern. Man addiert zum Exponenten deshalb einen sogenannten Bias. Dieser Bias-behaftete Exponent nimmt dann im Normalfall Werte zwischen $1$ und $2^x-2$ an, wobei $x$ die Anzahl Bits für den Exponenten ist. Damit kann man Exponenten zwischen $-(2^{x-1}-2)$ und $+2^{x-1}-1$ darstellen. Die beiden Sonderfälle, wo der Bias-behaftete Exponent $0$ und $2^x$ ist, werden in der Tabelle erklärt:

Diese Zahlendarstellung wird Gleitkommadarstellung genannt, da die Position des Kommas je nach Zahl variiert. Diese Darstellung erlaubt, im Gegensatz zu Darstellungen mit einem festen Platz für das Komma, dass man sowohl sehr grosse wie auch sehr kleine Zahlen mit hoher Genauigkeit speichern kann. Die hier beschriebene Darstellung wird durch die Norm Norm IEEE 754 festgelegt.

Aufgabe: Ziel ist es, die Zahl $101.01_2$ als 16-Bit Gleitkommazahl darzustellen. Dabei sind folgende Anzahl Bits reserviert für:

1. Notiere die Zahl zuerst in der wissenschaftlichen Schreibweise für Binärzahlen.
   
   
2. Bestimme (jeweils als Binärzahl): Vorzeichen, Exponent, Mantisse
   
   
3. Welche Werte sollen der minimale und maximale Exponent haben können? Bestimme den passenden Bias, den man zum Exponenten hinzuaddiert.
   
   
4. Normalisiere nun die Mantisse und addiere den Bias zum Exponenten. Notiere: Vorzeichen, Exponent mit Bias, Mantisse.
   
   
5. Notiere nun die fertige Gleitkommazahl, so wie sie im Computer gespeichert wird.
   
   
6. Wie sehen die Sonderfälle (siehe Tabelle oben) für eine 16-Bit Gleitkommazahl aus?
   
   

Lösung

1. $$101.01_2 = \color{red}{1.0101}_2 \cdot 2^{\color{green}{2}_{10}} = \color{red}{1.0101}_2 \cdot 2^{\color{green}{10}_2}$$
   
   
2. Vorzeichen: $+$, also $0_2$
   Exponent: $10_2$
   Mantisse: $1.0101_2$
   
   
3. Da $5$ Bit für Exponenten: Mit 5 Bit gibt $2^5 = 32$ Möglichkeiten, tiefster und höchster Exponent sind reserviert für Sonderfälle (siehe Tabelle), es bleiben also $2^5 - 2 = 30$ Möglichkeiten. Regulärer Exponent geht damit von $-14 \leftrightarrow +15$. Bias muss also $+15 = 01111_2$ sein und nicht $14_{10}$, da der Bias-behaftete Exponent der kleinsten normalen Zahl $00001_2$ ist und nicht $00000_2$, da dieser Exponent die Zahl $0$ (oder eine denormalisierte Zahl) darstellt.
   1. minimaler Exponent: $-(2^{5-1}-2) = -14$
   2. maximaler Exponent: $2^{5-1}-1 = 15$
   3. Bias: $B = 15_{10} = 01111_2$
4. Vorzeichen: $0_2$
   Exponent mit Bias: $10_2 + 01111_2 = 10001_2$
   Mantisse: $0101000000_2$
5. $$0\,10001\,0101000000$$
6. Tabelle, wobei $x=5$ (da $5$ Bits für Exponenten):

   Exponent	Mantisse	Beschreibung
   $E = 0$	$M = 0$	Zahl $0$
   $E = 0$	$M > 0$	denormalisierte Zahl (für extrem kleine Zahlen)
   $31 > E > 0$ d.h. $30 \geq E \geq 1$	$M \geq 0$	normalisierte Zahl (Normalfall)
   $E = 31$	$M = 0$	Unendlich
   $E = 31$	$M > 0$	keine Zahl / Not A Number (NAN)

def binary_string_to_float(bin_str,len_exp=5,len_mant=10):
    # SIGN
    sign = '0'
    if bin_str[0] == '-': sign = '1'
 
    # SPECIAL CASE: ZERO
    if '1' not in bin_str: return [sign,'0'*len_exp,'0'*len_mant]
 
    # TODO: other special cases (too small, too big, nan)
 
    # if int convert into float
    if not '.' in bin_str: bin_str += '.'
 
    # EXPONENT, MANTISSA
    bin_str = bin_str.lstrip('-').lstrip('0') # remove unnecessary stuff
    bias = (2**len_exp - 2)//2
    mantissa = bin_str
 
    # determine exponent
    i_one = bin_str.find('1') # index of first '1' from left
    i_point = bin_str.find('.') # index of decimal point
    exponent = i_point - i_one
    if exponent > 0: exponent -= 1
 
    # remove point from mantissa
    if '.' in bin_str: mantissa = bin_str[0:i_point] + bin_str[i_point+1::]
 
    # add bias to exponent
    exp_w_bias = bin(exponent+bias)[2:]
    exp_w_bias = '0' * (len_exp - len(exp_w_bias)) + exp_w_bias
    if len(exp_w_bias) > len_exp:
        return [sign,'1'*len_exp,'0'*len_mant]
 
    # normalize mantissa
    mantissa = mantissa.lstrip('0')
    mantissa_normalized = mantissa[1::] # remove first '1' (i.e. normalize)
    # ensure mantissa has correct length
    if len(mantissa_normalized) > len_mant:
        mantissa_normalized = mantissa_normalized[0:len_mant]
    else:
        mantissa_normalized += '0' * (len_mant - len(mantissa_normalized))
 
    # TODO: round mantissa correctly
 
    return [sign,exp_w_bias,mantissa_normalized]

Aus dem Grundlagenfach kennen wir den Restwertalgorithmus, mit dem wir ganze Dezimalzahlen (z.B. $132$) ins Binärsystem umrechnen: Wir dividieren immer durch $2$ und fügen dem Rest der Binärzahl hinzu. Wie sieht es aber aus, wenn wir die eine Dezimalzahl mit Nachkommastellen ins Binärsystem umrechnen wollen? Zum Beispiel gilt: $$0.5_{10} = \left(\frac12\right)_{10} = 0.1_2$$ $$0.25_{10} = \left(\frac14\right)_{10} = 0.01_2$$ $$0.125_{10} = \left(\frac18\right)_{10} = 0.001_2$$ Der Algorithmus zur Umrechnung von dezimalen Nachkommastellen ins Binärsystem geht ganz ähnlich wie oben beschrieben, nur multiplizieren wir immer mit $2$. Die Stelle vor dem Komma wird der Binärzahl angehängt, der Rest geht in die nächste Runde bis irgendwann der Rest $0$ erreicht wird. Dann bricht man ab. Viele Zahlen produzieren aber sich wiederholende binäre Nachkommastellen.

Beispiel: $0.375$ ins Binärsystem umwandeln: $$0.375 \cdot 2 = \color{blue}{0}.75$$ $$0.75 \cdot 2 = \color{blue}{1}.5$$ $$0.5 \cdot 2 = \color{blue}{1}.\color{red}{0}$$ Es gilt also: $$0.375_{10} = 0.\color{blue}{011}_2$$

Für Zahlen wie $42.375$ gehen wir wie folgt vor: Wir wandeln den Teil vor und den Teil nach dem Komma separat um und fügen sie dann zusammen:

• $42_{10} = 101010_2$
• $0.375_{10} = 0.011_2$

Es gilt also $$42.375_{10} = 101010.011_2$$