Inhaltsverzeichnis

Zahlensysteme

Du zählst und rechnest gewöhnlich im Dezimalsystem (Zehnersystem): Du kennst die zehn Ziffern 0 bis 9 – und du weisst, dass bei mehrstelligen Zahlen jede zusätzliche Stelle von rechts nach links zehn mal mehr wert ist.

Hier betrachten wir andere Zahlensysteme, insbesondere das Binärsystem und das Hexadezimalsystem.

Lernziele (hidden):

1. Einführung, verschiedene Zahlensysteme

Neben dem Zehnersystem könnten wir auch in Stellenwertsystemen mit anderer Basis zählen und rechnen – zum Beispiel im Oktalsystem mit Basis 8 oder im Vigesimalsystem mit der Basis 20. Das Binärsytem und das Hexadezimalsystem sind in der Informatik von besonderer Bedeutung:

Wir arbeiten vorwiegend mit dem Dossier Zahlensysteme.

Auftrag 1 – Einführung ins Dossier Zahlensysteme

  1. Lies Kapitel 1 im Dossier und beantworte die Fragen zum Zählen mit den Fingern:
    1. Wie weit zählst du gewöhnlich mit Fingern?
    2. Wie weit kannst du im Binärsystem mit den Fingern einer Hand oder zweier Hände zählen?

Auftrag 2 – Verschiedene Zahlensysteme

  1. Lies Kapitel 2 im Dossier und löse Aufgabe A1. Vergleiche anschliessend mit der Lösung am Ende des Dissiers.
  2. Zusatzaufgabe: Wie gross ist die Zahl 2347 im uns bekannten Dezimalsystem?

Tipps für die Zusatzaufgabe:

2. Binärsystem

Auftrag 3 – Binärzahlen lesen und umwandeln

  1. Lies Kapitel 3 im Dossier und löse Aufgaben B1 und B2.
  2. Löse Aufgabe B3 im Dossier auf https://webtigerpython.ethz.ch/:
    1. Definiere eine Funktion binary_to_decimal(b), die den Binärstring b in eine Dezimalzahl wandelt und diese zurückgibt. Beachte hierfür folgende Hinweise in den grünen Boxen. Notiere zuerst mit Kommentaren, wie du die Funktion aufbauen willst.
    2. Teste deine Funktion.

Binärzahlen als Strings

  • Für diese Übungen stellen wir Binärzahlen als String (als Text) dar: Der Binärstring „101“ entspricht der Dezimalzahl 5.
  • Einen String können wir mit einer Schleife (while oder for) Buchstabe für Buchstabe durchgehen.
  • Mit [eckigen Klammern] kannst auf einzelne Positionen im String zugreifen: Für text = „Hallo Welt“ gibt text[4] das Zeichen „o“.

Binärzahlen in Dezimalzahlen umrechnen

  • Die Wertigkeit jeder Stelle in einer Binärzahl ist 2Stelle:
  • Die Stelle ganz rechts ist die nullte Stelle, die links davon ist Stelle 1, dann 2 etc.
  • Beispiel 1: Für die dreistellige Binärzahl 111 rechnen wir 22 + 21 + 20 = 4 + 2 + 1 = 7.
  • Beispiel 2: Für die vierstellige Binärzahl 1001 rechnen wir 23 + 20 = 8 + 1 = 9.

Weitere Hinweise

  • Wenn du mit einer Schleife einen String durchgehst, beginnst du gewöhnlich bei der Stelle ganz links. Dann hat die erste Stelle im Binärstring „10110“ die Wertigkeit 24, also 16. Die nächste Stelle hat die Wertigkeit 8, dann 4 etc. Der Binärstring „10110“ entspricht also der Dezimalzahl 22 (16 + 4 + 2).
  • Die Funktion int wandelt ein Zeichen in die entsprechende Zahl, z. B. int('1') = 1.

Auftrag 4 – Bits und Bytes

  1. Löse Aufgabe B4 im Dossier.

Auftrag 5 – Dezimalzahlen in Binärzahlen umwandeln

  1. Lies Seite 8 im Dossier und löse die Aufgabe B5.
  2. Löse die Aufgabe B6: Schreibe eine Funktion decimal_to_binary(d), die die Dezimalzahl d in einen Binärstring umrechnet und diesen zurückgibt.

Auftrag 6 – Binäre Addition

  1. Löse die Aufgabe B7 auf Seite 11.
  2. Löse die Aufgabe B8 Schreibe eine Funktion binary_add(a, b), die zwei gleich lange Binästrings a und b addiert und die Summe als Binärstring zurückgibt.
    1. Die Addition soll nach demselben Verfahren verfolgen, das du in der schriftlichen Addtion anwendest. Eine Umwandlung in Dezimalzahlen ist nicht erlaubt.
    2. Beachte die Tipps im Dossier und folgenden Hinweise: Wir können Aufgabe mithilfe der Operatoren Modulo und Ganzzahldivision lösen. Kopiere den Code unten und notiere erst mit #Kommentaren hinter jede Zeile, welche beiden Zahlen ausgegeben werden. Führe dann aus.
    3. Deine Funktion muss (unter anderem) a und b Bit für Bit mit dem (bestehenden) Rest zusammenrechnen, um erstens die Summe für das aktuelle Bit und zweitens den Rest für das nächste Bit zu erhalten.
    4. Notiere erst mit Kommentaren, wie du die Funktion aufbauen willst.
  3. Wenn deine Funktion funktioniert: Erweitere sie so, dass auch zwei unterschieldich lange Binärstrings miteinander addiert werden können. 
print(3%2, 3//2)
print(2%2, 2//2)
print(1%2, 1//2)
print(0%2, 0//2)

Auftrag 7 – Binäre Addition ohne Software (optional)

Du weisst, dass Computer und andere digitale Geräte Rechenmaschinen sind: Sie können unfassbar schnell rechnen. Aber wie? Die Einsen und Nullen speichert der Computer in Form elektrischer Ladungen – vereinfacht betrachtet: Ist in einer Speicherzelle eine Ladung, so bedeutet das eine Eins, sonst eine Null. Nehmen wir 8 Speicherzellen zusammen, so können wir darin eine 8-Bit-Binärzahl speichern. Angenommen, wir haben 8 Speicherzellen für Zahl A und weitere 8 Speicherzellen für Zahl B: Eine digitale Addiermaschine muss nun die Speicherzellen der Zahlen A und B so miteinander verbinden, dass sich daraus die Summe von A und B ergibt.

  1. Lies Teil 3 im Skript Vom Transistor zur CPU: Du musst nicht alles verstehen: Betrachte den Transitor einfach als Schalter, der elektrisch aktiviert wird. Wichtig ist, dass du die Logikgatter (engl. Logic gates) AND, OR, und XOR verstehst. Aus diesen Bausteinen werden nicht nur Rechenschaltungen, sondern auch andere essentielle Bestandteile eines Computers wie Speicher, Zähler, Register etc. gebaut. Bei Unklarheiten LP fragen.
  2. Lies nun das Kapitel Binäre Addition im Teil 7 des Skripts.
    1. Dieses Video erklärt den Aufbau von digitalen Addierschaltungen Schritt für Schritt.
    2. Testfrage: Angenommen, ein Logikgatter ist aus durchschnittlich 10 Transistoren aufgebaut: Wie viele Transistoren sind nötig, um zwei 8-Bit-Zahlen zu addieren?
  3. Baue selbst eine kleine Schaltung mit fertigen 4-Bit-Additions-Bausteinen auf und probiere sie aus:
    1. Löse erst Aufgabe 1 in Einfache Schhaltungen auf dem Breadboard aufbauen : Damit du lernst, wie man Schaltungen auf dem Breadboard aufbaut.
    2. Studiere das Datenblatt des 4-Bit-Voll-Addierer-Chips 74LS283
      1. VCC verbindest du mit dem Pluspol der Spannungsquelle (5V), GND mit dem Minuspol.
      2. GND Eingänge auf Schalter.
      3. Die Eingänge A und B verbindest du erstens über 10kΩ-Pullup-Widerstände mit 5V, zweitens über Schalter mit GND.
      4. Die Ausgänge Σ verbindest du über 150Ω-Widerstände mit den Anoden von LEDs, deren Kathoden dann auf GND gehen.
      5. Frage die LP nach dem Material.

3. Hexadezimalsystem

Wert Dezimal Wert Binär Hex-Nennwert Merkhilfe
0 0000 0
1 0001 1
… … …
9 1001 9
10 1010 A
11 1011 B
12 1100 C Cwölf
13 1101 D Dreizehn
14 1110 E
15 1111 F Fünfzehn

Auftrag 8 – Umwandlungen Hex, Dez, Bin

  1. Löse Aufgabe C1 im Dossier.
    1. Gehe gleich vor, wie bei der Umwandlung von Binär zu Dezimal. Nur ist die Basis nun 16. Die Stelle ganz rechts hat die Wertigkeit 160, die links davon 161, dann 162 etc. Die Nennwerte entsprechen der Tabelle oben.
    2. Bei der Umwandlung von Dezimal zu Hex kannst du wieder den Restwert-Algorithmus anwenden – angepasst für das Hexadezimalsystem
  2. Lies Seite 23 im Dossier und folgende Überlegung: Wie du in der Tabelle oben siehst, füllen vier Binär-Stellen genau eine Hex-Stelle aus:
    1. Für die Umwandlung von Binär nach Hex musst du einfach jeweils vier Binär-Stellen (von rechts) zusammennehmen und die entsprechende Hex-Ziffer notieren.
    2. Für die Umwandlung von Hex nach Binär machst du das Gegenteil: Für jede Hexziffer vier Binärstellen hinschreiben.
  3. Löse Aufgabe C2 im Dossier.

Auftrag 9 – RGB-Hexcodes

Alle Farben können durch Mischen der Grundfarben Rot, Grün, und Blau erzeugt werden.

  1. Experimentieren in Word
  2. Evtl. Hinweise auf unterschiedliche Anwendungen (CSS, Word, AI, PS etc.)
  3. Bild erstellen mit HexCodes

Auftrag 10 – Turtle RGB-Regler (optional)

4. Zustazaufgaben

Siehe Dossier Kapitel 5, Aufgaben D1 bis D3

5. Lösungen zu den Programmieraufgaben

Aufgabe B3

Code-Variante mit While-Schleife, die Bitstring von links nach rechts durchgeht. 

def binary_to_decimal(b):
    decimal = 0
    stellenwert = 2**(len(b)-1) # Wert des höchtwertigen Bits berechnen
    i = 0
    while i < len(b):
        if b[i] == '1':
            decimal = decimal + stellenwert
        stellenwert = stellenwert // 2 # Stellenwert halbieren für nächste Stelle
        i = i + 1
    return decimal
 
print(binary_to_decimal('100011'))


Kürzere Variante: Anstelle der if-Verzweigung können wir jeweils mit dem aktuellen Bit (0 oder 1) mutliplizieren – das Zeichen ('0' oder '1') muss hierzu mit der Funktion int in die entsprechende Zahl gewandelt werden: 

def binary_to_decimal(b):
    decimal = 0
    stellenwert = 2**(len(b)-1) # Wert des höchtwertigen Bits berechnen
    i = 0
    while i < len(b):
        decimal = decimal + int(b[i]) * stellenwert
        stellenwert = stellenwert // 2 # Stellenwert halbieren für nächste Stelle
        i = i + 1
    return decimal
 
print(binary_to_decimal('100011'))


Noch kürzere Variante: Anstatt den Stellenwert zu Beginn zu berechnen, können wir ihn in jedem Durchgang neu berechnen: Dabei rechnen wir: 2 hoch (Länge der Binärzahlzahl minus aktuelle Stelle minus 1): Also für das dritte Bit der Binärzahl 10101 rechnen wir 2 hoch (5-3-1), also 2 hoch 2 gleich 4: Das ist richtig, diese Stelle hat den Stellenwert 4. 

def binary_to_decimal(b):
    decimal = 0
    i = 0
    while i < len(b):
        decimal = decimal + int(b[i]) * 2**(len(b)-i-1)
        i = i + 1
    return decimal
 
print(binary_to_decimal('100011'))

Aufgabe B6

def decimal_to_binary(d):
    bstring = ""
    while d > 0:
        bstring = str(d % 2) + bstring # neue Ziffer vorne am String anfügen 
        d = d // 2
    return bstring
 
print(decimal_to_binary(27))

Aufgabe B8

Version ohne Anpassung ungleicher Längen: 

def binary_add(a, b):
    resultat = ""
    i = len(a) - 1
    rest = 0
 
    while i >= 0:
        abit, bbit = int(a[i]), int(b[i])
        summe = (abit + bbit + rest) % 2 
        rest = (abit + bbit + rest) // 2
        resultat = str(summe) + resultat
        i = i - 1
 
    if rest != 0:
        resultat = str(rest) + resultat
 
    return resultat
 
print(binary_add('111', '011')) # 7 + 3 
print(binary_add('001', '101')) # 1 + 5

Version mit Anpassung ungleicher Längen: 

def binary_add(a, b):
    # Binärstrings gleich lang machen:
    maxlen = max(len(a), len(b))
    a = a.zfill(maxlen)
    b = b.zfill(maxlen)
 
    resultat = ""
    i = maxlen - 1
    rest = 0
 
    while i >= 0:
        abit, bbit = int(a[i]), int(b[i])
        summe = (abit + bbit + rest) % 2 
        rest = (abit + bbit + rest) // 2
        resultat = str(summe) + resultat
        i = i - 1
 
    if rest != 0:
        resultat = str(rest) + resultat
 
    return resultat
 
print(binary_add('111', '11')) # 7 + 3 
print(binary_add('1', '101')) # 1 + 5