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 [2026-04-08 17:56] – hofgf_informatik:zahlensysteme:binary_collection [2026-05-05 06:49] (aktuell) – [Strings verketten] hof
Zeile 1: Zeile 1:
 ## Binärzahlen in Python: Bausteine ## Binärzahlen in Python: Bausteine
-<html><script type="module" src="https://bottom.ch/editor/stable/bottom-editor.js"></script></html> 
  
 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 9: Zeile 8:
  
 *Direkte* Schleife über alle Buchstaben eines Strings (einer Zeichenfolge): *Direkte* Schleife über alle Buchstaben eines Strings (einer Zeichenfolge):
-<html><bottom-editor style="min-height: 6lh">b = '100110'+<bottom-editor style="min-height: 6lh">b = '100110'
 for digit in b: for digit in b:
-    print(digit)</bottom-editor></html>+    print(digit)</bottom-editor>
 #### 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:
  
-<html><bottom-editor>b1 = '10011010'+<bottom-editor>b1 = '10011010'
 b2 = '11110000' b2 = '11110000'
 for index in range(len(b1)): for index in range(len(b1)):
Zeile 24: Zeile 23:
     digit2 = b2[index]     digit2 = b2[index]
     print(digit1, digit2)     print(digit1, digit2)
-</bottom-editor></html>+</bottom-editor>
  
 Oder mit `while`: Oder mit `while`:
  
-<html><bottom-editor>b1 = '10011010'+<bottom-editor>b1 = '10011010'
 b2 = '11110000' b2 = '11110000'
 index = 0 index = 0
Zeile 36: Zeile 35:
     print(digit1, digit2)     print(digit1, digit2)
     index = index + 1     index = index + 1
-</bottom-editor></html>+</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 paarweise 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... 🤐
  
  
-<html><bottom-editor>b1 = '10011010'+<bottom-editor>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)
-</bottom-editor></html>+</bottom-editor>
  
  
Zeile 52: Zeile 51:
 Erste Möglichkeit: Indirekte Schleife mit Umrechnung des Index: Erste Möglichkeit: Indirekte Schleife mit Umrechnung des Index:
  
-<html><bottom-editor>b = '111000'+<bottom-editor>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)
-</bottom-editor></html>+</bottom-editor>
  
 Etwas kompakter: `range` mit einem Step-Argument: Etwas kompakter: `range` mit einem Step-Argument:
  
-<html><bottom-editor>b = '111000'+<bottom-editor>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)
-</bottom-editor></html>+</bottom-editor>
  
 Oder mit `while`: Oder mit `while`:
  
  
-<html><bottom-editor>b = '111000'+<bottom-editor>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 77: Zeile 76:
     print(digit)     print(digit)
     index = index - 1     index = index - 1
-</bottom-editor></html>+</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:
  
-<html><bottom-editor>b = '111000'+<bottom-editor>b = '111000'
 for d in reversed(b): for d in reversed(b):
     print(d)     print(d)
-</bottom-editor></html>+</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):
  
-<html><bottom-editor>b = '111000'+<bottom-editor>b = '111000'
 for d in b[::-1]: for d in b[::-1]:
     print(d)     print(d)
-</bottom-editor></html>+</bottom-editor>
  
  
Zeile 99: Zeile 98:
 Am einfachsten mit `while`: Am einfachsten mit `while`:
  
-<html><bottom-editor>b1 = '111000'+<bottom-editor>b1 = '111000'
 b2 = '101010' b2 = '101010'
 index = len(b1) - 1 index = len(b1) - 1
Zeile 108: Zeile 107:
     print(digit1, digit2)     print(digit1, digit2)
     index = index - 1     index = index - 1
-</bottom-editor></html>+</bottom-editor>
  
 Eleganter mit `reversed` und `zip` (kein Prüfungsstoff): Eleganter mit `reversed` und `zip` (kein Prüfungsstoff):
  
-<html><bottom-editor>b1 = '111000'+<bottom-editor>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)
-</bottom-editor></html>+</bottom-editor>
  
 ++++ ++++
Zeile 125: 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?
  
-<html><bottom-editor>a = 42+<bottom-editor>a = 42
 b = 2 b = 2
 quotient = a // b quotient = a // b
 rest = a % b rest = a % b
 print(quotient, rest) print(quotient, rest)
-</bottom-editor></html>+</bottom-editor> 
 #### Bit-Operationen (kein Prüfungsstoff) #### 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]]: Statt der gewohnten Division haben Computer spezielle [[https://docs.python.org/3/reference/expressions.html#unary-arithmetic-and-bitwise-operations|Operationen auf Bit-Ebene]]:
Zeile 136: Zeile 136:
   * `>>` 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.   * `>>` 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.
  
-<html><bottom-editor>+<bottom-editor>
 print(3 << 1)  # Resultat 6: 3 = 00000011, 00000011 << 1 = 00000110 = 6 print(3 << 1)  # Resultat 6: 3 = 00000011, 00000011 << 1 = 00000110 = 6
 print(13 >> 2)  # Resultat 3: 13 = 00001101, 00001101 >> 2 = 000000011 = 3 print(13 >> 2)  # Resultat 3: 13 = 00001101, 00001101 >> 2 = 000000011 = 3
-</bottom-editor></html>+</bottom-editor>
  
  
Zeile 146: Zeile 146:
 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  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. (String) dargestellt werden, und aus einem String wieder zurückverwandelt werden.
- 
 #### Zeichenketten (Strings) #### Zeichenketten (Strings)
  
 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:
  
-<html><bottom-editor>digit1 = '1'+<bottom-editor> 
 +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 
-</bottom-editor></html>+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:
  
-<html><bottom-editor>zahl = int('42')        # OK+<bottom-editor>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!
-</bottom-editor></html>+</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 176: 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:
  
-<html><bottom-editor>s1 = 'foo'+<bottom-editor>s1 = 'foo'
 s2 = 'bar' s2 = 'bar'
 print(s1 + s2)  # prints 'foobar' print(s1 + s2)  # prints 'foobar'
-</bottom-editor></html>+</bottom-editor>
  
 Dasselbe ist auch praktisch, um Buchstaben in einer Schleife aneinanderzureihen: Dasselbe ist auch praktisch, um Buchstaben in einer Schleife aneinanderzureihen:
  
-<html><bottom-editor>def flip_bits(b):+<bottom-editor>def flip_bits(b):
     result = ''                    # start with empty string     result = ''                    # start with empty string
     for digit in b:     for digit in b:
Zeile 191: Zeile 195:
             result = result + '1'  # otherwise append a one             result = result + '1'  # otherwise append a one
     return result     return result
-</bottom-editor></html>+ 
 +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:
  
-<html><bottom-editor>a = 101       # eine Zahl+<bottom-editor>a = 101       # eine Zahl
 b = '010'     # ein String b = '010'     # ein String
 c = a + b     # Fehler! c = a + b     # Fehler!
Zeile 204: 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
-</bottom-editor></html>+</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 212: Zeile 218:
 Variante 1: Mit `while`: Variante 1: Mit `while`:
  
-<html><bottom-editor>b = '1010'+<bottom-editor>b = '1010'
 n = 8 n = 8
 while len(b) < n: while len(b) < n:
     b = '0' + b     b = '0' + b
 print(b) print(b)
-</bottom-editor></html>+</bottom-editor>
  
 Variante 2 (nicht Lernstoff): Strings multiplizieren Variante 2 (nicht Lernstoff): Strings multiplizieren
Zeile 223: 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:
  
-<html><bottom-editor>b = '1010'+<bottom-editor>b = '1010'
 n = 8 n = 8
 count = n - len(b)    # count = 8 - 4 = 4 count = n - len(b)    # count = 8 - 4 = 4
Zeile 229: Zeile 235:
 b = zeros + b b = zeros + b
 print(b) print(b)
-</bottom-editor></html>+</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]]:
  
-<html><bottom-editor>b = '1010'+<bottom-editor>b = '1010'
 n = 8 n = 8
 print(b.zfill(n)) print(b.zfill(n))
-</bottom-editor></html>+</bottom-editor>
  
 ### Funktionen ### Funktionen
  • gf_informatik/zahlensysteme/binary_collection.1775671000.txt.gz
  • Zuletzt geändert: 2026-04-08 17:56
  • von hof