Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Beide Seiten, vorherige Überarbeitung Vorherige Überarbeitung
Nächste Überarbeitung		 Vorherige Überarbeitung
gf_informatik:zahlensysteme:binary_collection [2025-04-28 10:19] – [Rückwärts] hofgf_informatik:zahlensysteme:binary_collection [2026-05-05 06:49] (aktuell) – [Strings verketten] hof
Zeile 1: Zeile 1:
-## Binärzahlen mit Python+## Binärzahlen in Python: Bausteine
  
 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. 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.
Zeile 8: Zeile 8:
  
 *Direkte* Schleife über alle Buchstaben eines Strings (einer Zeichenfolge): *Direkte* Schleife über alle Buchstaben eines Strings (einer Zeichenfolge):
-<code python> +<bottom-editor style="min-height: 6lh">b = '100110'
-b = '100110'+
 for digit in b: for digit in b:
-    print(digit) +    print(digit)</bottom-editor>
-</code>+
 #### Parallel über zwei Strings #### Parallel über zwei Strings
  
-Bei der _indirekten_ Schleife steht der Ausdruck hinter `in` für die Liste der Indices, ist also eine Liste von Ganzzahlen (`int`). Die Schleifenvariable heisst meistens `index` oder kurz `i`. Um auf das uns interessierende Element zuzugreifen, müssen wir einen Listenzugriff programmieren, z.B. `liste[index]`. Mit dem Index kann auch gerechnet werden, um zum Beispiel jedes zweite Element oder die Elemente in umgekehrter Richtung zu erhalten.+Bei der _indirekten_ `for`-Schleife steht der Ausdruck hinter `in` für die Liste der Indices, ist also eine Liste von Ganzzahlen (`int`). Die Schleifenvariable heisst meistens `index` oder kurz `i`. Um auf das uns interessierende Element zuzugreifen, müssen wir einen Listenzugriff programmieren, z.B. `liste[index]`. Mit dem Index kann auch gerechnet werden, um zum Beispiel jedes zweite Element oder die Elemente in umgekehrter Richtung zu erhalten.
  
-*Indirekte* Schleife über die Buchstaben in zwei gleichlangen Strings:+*Indirekte* `for`-Schleife über die Buchstaben in zwei gleichlangen Strings:
  
-<code python> +<bottom-editor>b1 = '10011010'
-b1 = '10011010'+
 b2 = '11110000' b2 = '11110000'
 for index in range(len(b1)): for index in range(len(b1)):
Zeile 26: Zeile 23:
     digit2 = b2[index]     digit2 = b2[index]
     print(digit1, digit2)     print(digit1, digit2)
-</code>+</bottom-editor>
  
 Oder mit `while`: Oder mit `while`:
  
-<code python> +<bottom-editor>b1 = '10011010'
-b1 = '10011010'+
 b2 = '11110000' b2 = '11110000'
 index = 0 index = 0
Zeile 39: Zeile 35:
     print(digit1, digit2)     print(digit1, digit2)
     index = index + 1     index = index + 1
-</code>+</bottom-editor>
  
-Elegante Alternative mit [[https://docs.python.org/3/library/functions.html#zip|zip]] (nicht Prüfungsstoff): _Zip_ ist das englische Wort für Reissverschluss, wir nehmen also abwechslungsweise von jedem Argument ein Element... 🤐+Elegante Alternative mit [[https://docs.python.org/3/library/functions.html#zip|zip]] (nicht Prüfungsstoff): _Zip_ ist das englische Wort für Reissverschluss, wir nehmen also paarweise von jedem Argument ein Element... 🤐
  
  
-<code python> +<bottom-editor>b1 = '10011010'
-b1 = '10011010'+
 b2 = '11110000' b2 = '11110000'
 for digit1, digit2 in zip(b1, b2): for digit1, digit2 in zip(b1, b2):
     print(digit1, digit2)     print(digit1, digit2)
-</code> +</bottom-editor> 
- + 
 #### Rückwärts #### Rückwärts
  
 Erste Möglichkeit: Indirekte Schleife mit Umrechnung des Index: Erste Möglichkeit: Indirekte Schleife mit Umrechnung des Index:
  
-<code python> +<bottom-editor>b = '111000'
-b = '111000'+
 for index in range(len(b)): for index in range(len(b)):
     reversed_index = len(b) - 1 - index     reversed_index = len(b) - 1 - index
     digit = b[reversed_index]     digit = b[reversed_index]
     print(digit)     print(digit)
-</code>+</bottom-editor>
  
 Etwas kompakter: `range` mit einem Step-Argument: Etwas kompakter: `range` mit einem Step-Argument:
  
-<code python> +<bottom-editor>b = '111000'
-b = '111000'+
 # range(start, stop, step): Start with len - 1, stop at 0 (so before -1), increment is -1 # 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): for index in range(len(b) - 1, -1, -1):
     digit = b[index]     digit = b[index]
     print(digit)     print(digit)
-</code>+</bottom-editor>
  
 Oder mit `while`: Oder mit `while`:
  
  
-<code python> +<bottom-editor>b = '111000'
-b = '111000'+
 index = len(b) - 1  # Letzter gültiger Index index = len(b) - 1  # Letzter gültiger Index
 while index >= 0: while index >= 0:
Zeile 83: Zeile 76:
     print(digit)     print(digit)
     index = index - 1     index = index - 1
-</code>+</bottom-editor>
  
 Noch kompakter: Die Funktion [[https://docs.python.org/3/library/functions.html#reversed|reversed]] (kein Prüfungsstoff) kehrt jede Sequenz (Liste, String) um: Noch kompakter: Die Funktion [[https://docs.python.org/3/library/functions.html#reversed|reversed]] (kein Prüfungsstoff) kehrt jede Sequenz (Liste, String) um:
  
-<code python> +<bottom-editor>b = '111000'
-b = '111000'+
 for d in reversed(b): for d in reversed(b):
     print(d)     print(d)
-</code>+</bottom-editor>
  
 Noch kompakter (aber auch leserlich?), die Verwendung von [[https://stackoverflow.com/questions/509211/how-slicing-in-python-works/509295#509295|String Slicing]] (kein Prüfungsstoff): Noch kompakter (aber auch leserlich?), die Verwendung von [[https://stackoverflow.com/questions/509211/how-slicing-in-python-works/509295#509295|String Slicing]] (kein Prüfungsstoff):
  
-<code python> +<bottom-editor>b = '111000'
-b = '111000'+
 for d in b[::-1]: for d in b[::-1]:
     print(d)     print(d)
-</code>+</bottom-editor>
  
  
Zeile 107: Zeile 98:
 Am einfachsten mit `while`: Am einfachsten mit `while`:
  
-<code python> +<bottom-editor>b1 = '111000'
-b1 = '111000'+
 b2 = '101010' b2 = '101010'
 index = len(b1) - 1 index = len(b1) - 1
Zeile 117: Zeile 107:
     print(digit1, digit2)     print(digit1, digit2)
     index = index - 1     index = index - 1
-</code>+</bottom-editor>
  
 Eleganter mit `reversed` und `zip` (kein Prüfungsstoff): Eleganter mit `reversed` und `zip` (kein Prüfungsstoff):
  
-<code python> +<bottom-editor>b1 = '111000'
-b1 = '111000'+
 b2 = '101010' b2 = '101010'
  
 for d1, d2 in zip(reversed(b1), reversed(b2)): for d1, d2 in zip(reversed(b1), reversed(b2)):
     print(d1, d2)     print(d1, d2)
-</code>+</bottom-editor> 
 ++++ ++++
- 
  
 ### Division und Rest ### Division und Rest
Zeile 135: Zeile 124:
 Zwei Zahlen `a` und `b` - was gibt $\lfloor a/b\rfloor$ (Ganzzahldivision), und wieviel ist der Rest der Division? Zwei Zahlen `a` und `b` - was gibt $\lfloor a/b\rfloor$ (Ganzzahldivision), und wieviel ist der Rest der Division?
  
-<code python> +<bottom-editor>a = 42
-a = 42+
 b = 2 b = 2
 quotient = a // b quotient = a // b
 rest = a % b rest = a % b
-</code>+print(quotient, rest) 
 +</bottom-editor> 
 + 
 +#### Bit-Operationen (kein Prüfungsstoff) 
 +Statt der gewohnten Division haben Computer spezielle [[https://docs.python.org/3/reference/expressions.html#unary-arithmetic-and-bitwise-operations|Operationen auf Bit-Ebene]]: 
 +  * `<<` ist der _Shift-Left_-Operator, die Bitfolge der Zahl wird um eine Anzahl Bits nach links gerückt, also um die gewünschte Zweierpotenz multipliziert. Rechts wird mit Nullen aufgefüllt. 
 +  * `>>` ist der _Shift-Right_-Operator, die Bitfolge der Zahl wird um eine Anzahl Bits nach rechts gerückt, also durch die gewünschte Zweierpotenz dividiert. Es wird Ganzzahldivision verwendet, überschüssige Bits am rechten Rand gehen verloren. 
 + 
 +<bottom-editor> 
 +print(3 << 1)  # Resultat 6: 3 = 00000011, 00000011 << 1 = 00000110 = 6 
 +print(13 >> 2)  # Resultat 3: 13 = 00001101, 00001101 >> 2 = 000000011 = 3 
 +</bottom-editor> 
  
 ### Strings und Integers ### Strings und Integers
Zeile 150: Zeile 150:
 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: 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:
  
-<code python>+<bottom-editor>
 digit1 = '1' digit1 = '1'
 digit2 = '1' digit2 = '1'
  
-summe = digit1 + digit2   # Absicht: Summe soll die Zahl 2 sein +# Absicht: Summe soll die Zahl 2 sein 
-print(summe)              # Resultat: String-Verkettung zu '11'+summe = digit1 + digit2 
 +# Resultat: String-Verkettung zu '11' 
 +print(f'{digit1} + {digit2} = {summe}')
  
-print(int(digit1) + int(digit2))  # Abhilfe: Strings in Zahlen konvertieren +# Abhilfe: Strings in Zahlen konvertieren 
-</code>+summe = int(digit1) + int(digit2) 
 +print(f'{digit1} + {digit2} = {summe}') 
 +</bottom-editor>
  
 #### Zahlen #### Zahlen
Zeile 166: Zeile 170:
 Strings können in Zahlen umgewandelt werden, wenn der Inhalt des Strings einer Zahl entspricht: Strings können in Zahlen umgewandelt werden, wenn der Inhalt des Strings einer Zahl entspricht:
  
-<code python> +<bottom-editor>zahl = int('42')        # OK
-zahl = int('42')        # OK+
 zahl = int('3.14')      # FEHLER! zahl = int('3.14')      # FEHLER!
 zahl = float('3.14')    # OK zahl = float('3.14')    # OK
 zahl = float('foobar')  # FEHLER! zahl = float('foobar')  # FEHLER!
-</code>+</bottom-editor>
  
 Addieren, subtrahieren oder multiplizieren wir zwei Ganzzahlen, resultiert wiederum eine Ganzzahl. Bei der Division hingegen entsteht als Resultat ein `float`. Addieren, subtrahieren oder multiplizieren wir zwei Ganzzahlen, resultiert wiederum eine Ganzzahl. Bei der Division hingegen entsteht als Resultat ein `float`.
Zeile 177: Zeile 180:
 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: 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:
  
-<code python> +<bottom-editor>s1 = 'foo'
-s1 = 'foo'+
 s2 = 'bar' s2 = 'bar'
 print(s1 + s2)  # prints 'foobar' print(s1 + s2)  # prints 'foobar'
-</code>+</bottom-editor>
  
 Dasselbe ist auch praktisch, um Buchstaben in einer Schleife aneinanderzureihen: Dasselbe ist auch praktisch, um Buchstaben in einer Schleife aneinanderzureihen:
  
-<code python> +<bottom-editor>def flip_bits(b):
-def flip_bits(b):+
     result = ''                    # start with empty string     result = ''                    # start with empty string
     for digit in b:     for digit in b:
-        if digit = '1':            # if digit is a one...+        if digit == '1':            # if digit is a one...
             result = result + '0'  # ...append a zero             result = result + '0'  # ...append a zero
-        elif digit = '0':+        elif digit == '0':
             result = result + '1'  # otherwise append a one             result = result + '1'  # otherwise append a one
     return result     return result
-</code>+ 
 +print(flip_bits('11001')) 
 +</bottom-editor>
  
 **Achtung**: Der `+` Operator für Strings funktioniert nur, wenn beide Operanden Strings sind - falls eine Seite eine Zahl ist, führt das zum Programmabbruch: **Achtung**: Der `+` Operator für Strings funktioniert nur, wenn beide Operanden Strings sind - falls eine Seite eine Zahl ist, führt das zum Programmabbruch:
  
-<code python> +<bottom-editor>a = 101       # eine Zahl
-a = 101       # eine Zahl+
 b = '010'     # ein String b = '010'     # ein String
 c = a + b     # Fehler! c = a + b     # Fehler!
Zeile 208: Zeile 210:
 # String umwandeln in Zahl # String umwandeln in Zahl
 c = a + int(b)   # OK: + bedeutet Ganzzahl-Addition, c ist die Ganzzahl (int) 111 c = a + int(b)   # OK: + bedeutet Ganzzahl-Addition, c ist die Ganzzahl (int) 111
-</code>+</bottom-editor>
  
-**String mit Nullen auffüllen**+#### String mit Nullen auffüllen
  
 Ziel: einen Binärstring vorne mit Nullen auffüllen, damit mindestens `n` Stellen vorhanden sind: Ziel: einen Binärstring vorne mit Nullen auffüllen, damit mindestens `n` Stellen vorhanden sind:
Zeile 216: Zeile 218:
 Variante 1: Mit `while`: Variante 1: Mit `while`:
  
-<code python> +<bottom-editor>b = '1010'
-b = '1010'+
 n = 8 n = 8
 while len(b) < n: while len(b) < n:
     b = '0' + b     b = '0' + b
-</code>+print(b) 
 +</bottom-editor>
  
 Variante 2 (nicht Lernstoff): Strings multiplizieren Variante 2 (nicht Lernstoff): Strings multiplizieren
Zeile 227: Zeile 229:
 Strings können übrigens auch mit dem `*` Operator verknüpft werden - zum Beispiel um die Anzahl fehlender Nullen zu erstellen: Strings können übrigens auch mit dem `*` Operator verknüpft werden - zum Beispiel um die Anzahl fehlender Nullen zu erstellen:
  
-<code python> +<bottom-editor>b = '1010'
-b = '1010'+
 n = 8 n = 8
 count = n - len(b)    # count = 8 - 4 = 4 count = n - len(b)    # count = 8 - 4 = 4
 zeros = '0' * count   # zeros = '0000' zeros = '0' * count   # zeros = '0000'
 b = zeros + b b = zeros + b
-</code>+print(b) 
 +</bottom-editor>
  
  
 Variante 3 (nicht Lernstoff): Eleganter mit [[https://docs.python.org/2.7/library/stdtypes.html?highlight=zfill#str.zfill|zfill]]: Variante 3 (nicht Lernstoff): Eleganter mit [[https://docs.python.org/2.7/library/stdtypes.html?highlight=zfill#str.zfill|zfill]]:
-<code python> + 
-b = '1010'+<bottom-editor>b = '1010'
 n = 8 n = 8
-b = b.zfill(n) +print(b.zfill(n)) 
-</code>+</bottom-editor>
  
 ### Funktionen ### Funktionen
  • gf_informatik/zahlensysteme/binary_collection.1745835564.txt.gz
  • Zuletzt geändert: 2025-04-28 10:19
  • von hof