Das Dossier enthält mehrere Programmieraufgaben, um Binärzahlen mit Python-Code zu manipulieren. Hier findest du Übungen, Hinweise und Ideen, wie die Umsetzung der Algorithmen in Python gelingen könnte.

Direkte Schleife über alle Buchstaben eines Strings (einer Zeichenfolge):

b = '100110'
for digit in b:
    print(digit)

Indirekte Schleife über die Buchstaben in zwei gleichlangen Strings:

b1 = '10011010'
b2 = '11110000'
for index in range(len(b1)):
    digit1 = b1[index]
    digit2 = b2[index]
    print(digit1, digit2)

Elegante Alternative mit zip:

b1 = '10011010'
b2 = '11110000'
for digit1, digit2 in zip(b1, b2):
    print(digit1, digit2)

Erste Möglichkeit: Indirekte Schleife mit Umrechnung des Index:

b = '111000'
for index in range(len(b)):
    reversed_index = len(b) - 1 - index
    digit = b[reversed_index]
    print(digit)

Etwas kompakter: range mit einem Step-Argument:

b = '111000'
# range(start, stop, step): Start with len - 1, stop at 0 (so before -1), increment is -1
for index in range(len(b) - 1, -1, -1):
    digit = b[index]
    print(digit)

Noch kompakter: Die Funktion reversed kehrt jede Sequenz (Liste, String) um:

b = '111000'
for d in reversed(b):
    print(d)

Noch kompakter (aber auch leserlich?), die Verwendung von String Slicing:

b = '111000'
for d in b[::-1]:
    print(d)

Lösung

b1 = '111000'
b2 = '101010'
 
for d1, d2 in zip(reversed(b1), reversed(b2)):
    print(d1, d2)

Zwei Zahlen a und b - was gibt $\lfloor a/b\rfloor$ (Ganzzahldivision), und wieviel ist der Rest der Division?

a = 42
b = 2
quotient = a // b
rest = a % b

Jeder Ausdruck in Python hat einen Type. Der Type bestimmt, welche Operationen damit ausgeführt werden können: Mit Zahlen können wir rechnen, mit Zeichenketten nicht. Alle Types können auch als Zeichenkette (String) dargestellt werden, und aus einem String wieder zurückverwandelt werden.

Ein string ist eine Folge von Buchstaben. Die Folge kann auch leer sein (''). Strings sind immutable, können also nicht verändert werden. Alle anderen Types müssen sich als String darstellen lassen, indem die Funktion str() aufgerufen wird. Strings unterstützen den + Operator, um zwei Strings zu verketten. Dies kann verwirrend sein, wenn die Absicht ist, Zahlen zu addieren und stattdessen Strings verkettet werden:

digit1 = '1'
digit2 = '1'
 
summe = digit1 + digit2   # Absicht: Summe soll die Zahl 2 sein
print(summe)              # Resultat: Summe ist der String '11'
 
print(int(digit1) + int(digit2))  # Abhilfe: String in Zahl konvertieren

Zahlen können entweder Ganzahlen (int - Integer) oder Fliesskommazahlen (float - Floating Point Number) sein.

Strings können in Zahlen umgewandelt werden, wenn der Inhalt des Strings einer Zahl entspricht:

zahl = int('42')        # OK
zahl = int('3.14')      # FEHLER!
zahl = float('3.14')    # OK
zahl = float('foobar')  # FEHLER!

Addieren, subtrahieren oder multiplizieren wir zwei Ganzzahlen, resultiert wiederum eine Ganzzahl. Bei der Division hingegen entsteht als Resultat ein float.

Strings sind immutable, anders als bei Listen können wir nicht einfach einen Buchstaben ersetzen in einem String. Aber wir können mit dem + Operator zwei Strings verketten, um einen neuen String zu erhalten:

s1 = 'foo'
s2 = 'bar'
print(s1 + s2)  # prints 'foobar'

Dasselbe ist auch praktisch, um Buchstaben in einer Schleife aneinanderzureihen:

def flip_bits(b):
    result = ''                    # start with empty string
    for digit in b:
        if digit = '1':            # if digit is a one...
            result = result + '0'  # ...append a zero
        elif digit = '0':
            result = result + '1'  # otherwise append a one
    return result

Achtung: Der + Operator für Strings funktioniert nur, wenn beide Operanden Strings sind - falls eine Seite eine Zahl ist, führt das zum Programmabbruch:

a = 101       # eine Zahl
b = '010'     # ein String
c = a + b  # Fehler!
 
# Zahl umwandeln in String
c = str(a) + b   # OK: + bedeutet String-Verkettung, c ist der String '101010'
 
# String umwandeln in Zahl
c = a + int(b)   # OK: + bedeutet Ganzzahl-Addition, c ist die Ganzzahl (int) 111

String mit Nullen auffüllen

Ziel: einen Binärstring vorne mit Nullen auffüllen, damit mindestens n Stellen vorhanden sind:

Variante 1: Mit while:

b = '1010'
n = 8
while len(b) < n:
    b = '0' + b

Variante 2: Strings multiplizieren

Strings können übrigens auch mit dem * Operator verknüpft werden - zum Beispiel um die Anzahl fehlender Nullen zu erstellen:

b = '1010'
n = 8
count = n - len(b)    # count = 8 - 4 = 4
zeros = '0' * count   # zeros = '0000'
b = zeros + b

Variante 3: Eleganter mit zfill:

b = '1010'
n = 8
b = b.zfill(n)

• return ist vorhanden?
• return ist an der richtigen Stelle / Einrückung?
• Alle Berechnungsgrundlagen werden als Argumente übergeben?