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:programmieren_iii [2024-12-30 08:44] – hofgf_informatik:programmieren_iii [2025-02-10 14:02] (aktuell) – hof
Zeile 7: Zeile 7:
 Bisher haben wir in Variablen einzelne Werte gespeichert. Kann man auch *mehrere Werte* in einer Variablen speichern? Ja! Mit Listen! Bisher haben wir in Variablen einzelne Werte gespeichert. Kann man auch *mehrere Werte* in einer Variablen speichern? Ja! Mit Listen!
  
-Eine Liste erstellt man wie folgt:+Eine Liste wird erstellt, indem die Elemente in `[` eckigen Klammern `]` (_en_: brackets) eingeschlossen werden: 
 <code python> <code python>
 alphabet = ['a','b','c','d','e'] alphabet = ['a','b','c','d','e']
Zeile 14: Zeile 15:
 Die Liste im Beispiel oben hat die fünf **Elemente** `'a'`, `'b'`, `'c'`, `'d'` und `'e'`. Jedes dieser Elemente hat einen bestimmten **Index**, seine **Position** in der Liste: Die Liste im Beispiel oben hat die fünf **Elemente** `'a'`, `'b'`, `'c'`, `'d'` und `'e'`. Jedes dieser Elemente hat einen bestimmten **Index**, seine **Position** in der Liste:
  
-^ Position Index ^ 0 ^ 1 ^ 2 ^ 3 ^ 4 ^ +^ Position / Index ^  `0` ^  `1` ^  `2` ^  `3` ^  `4` ^ 
-|Element| 'a' | 'b' | 'c' | 'd' | 'e' |+|Element| `'a'` | `'b'` | `'c'` | `'d'` | `'e'` | 
 Beachte, dass das erste Element den **Index 0** hat! Beachte, dass das erste Element den **Index 0** hat!
  
-Über den Index kann man auf ein **Element zugreifen**. Dazu schreibt man zuerst den Namen der Liste und dann den Index in eckigen Klammern:+==== Selektion und Modifikation ==== 
 + 
 +Über den Index kann man auf ein **Element zugreifen**, das Element wird _ausgewählt_ oder **selektiert**. Dazu schreibt man zuerst den Namen der Liste und dann den Index in eckigen Klammern:
 <code python> <code python>
 print(alphabet[2]) # gibt 'c' aus print(alphabet[2]) # gibt 'c' aus
  
-alphabet[3] = 'z' # ändert Element an Position 3 (also 'd') zu 'z' +alphabet[3] = 'z'  # ändert Element an Position 3 (also 'd') zu 'z' 
-print(alphabet) # Ausgabe: ['a','b','c','z','e']+print(alphabet)    # Ausgabe: ['a','b','c','z','e']
 </code> </code>
  
Zeile 30: Zeile 34:
 alphabet.append('f')   # Fügt Element hinten an, Liste nachher: ['a','b','c','z','e','f'] alphabet.append('f')   # Fügt Element hinten an, Liste nachher: ['a','b','c','z','e','f']
 alphabet.insert(1,'q') # Fügt Element 'q' an Position 1 ein, Liste nachher: ['a','q','b','c','z','e','f'] alphabet.insert(1,'q') # Fügt Element 'q' an Position 1 ein, Liste nachher: ['a','q','b','c','z','e','f']
-alphabet.pop(3) # Entfernt Element an Position 3, Liste nachher: ['a','q','b','z','e','f'] +alphabet.pop(3)        # Entfernt Element an Position 3, Liste nachher: ['a','q','b','z','e','f'] 
-alphabet.pop()  # Entfernt letztes Element, Liste nachher: ['a','q','b','z','e']+alphabet.pop()         # Entfernt letztes Element, Liste nachher: ['a','q','b','z','e']
 </code> </code>
  
Zeile 40: Zeile 44:
  
 ==== Iteration ==== ==== Iteration ====
 +
 Oft möchte man durch alle Elemente einer Liste **durchgehen** und etwas mit diesen machen, z.B. sie in die Konsole printen: Oft möchte man durch alle Elemente einer Liste **durchgehen** und etwas mit diesen machen, z.B. sie in die Konsole printen:
 <code python> <code python>
 alphabet = ['a','b','c','d','e'] alphabet = ['a','b','c','d','e']
-i = 0 # Startindex, 0, weil wir zuerst das vorderste Element (hier 'a') auslesen möchten +i = 0                     # Startindex, 0, weil wir zuerst das vorderste Element (hier 'a') auslesen möchten 
-while i < len(alphabet): # Bedingung while-Schleife +while i < len(alphabet):  # Bedingung while-Schleife 
-    print(alphabet[i]) # lese Element aus Liste aus, alphabet[i], und printe dieses +    print(alphabet[i])    # lese Element aus Liste aus, alphabet[i], und printe dieses 
-    i = i + 1 # erhöhe Index+    i = i + 1             # erhöhe Index
 </code> </code>
 In der Bedingung `i < len(alphabet)` ermitteln wir mit len(alphabet) die Länge der Liste. Wichtig ist auch, dass der Index `i` *kleiner* (und nicht kleiner gleich) ist als diese Länge, da sonst versucht wird, auf Element zuzugreifen, welches nicht existiert. In der Bedingung `i < len(alphabet)` ermitteln wir mit len(alphabet) die Länge der Liste. Wichtig ist auch, dass der Index `i` *kleiner* (und nicht kleiner gleich) ist als diese Länge, da sonst versucht wird, auf Element zuzugreifen, welches nicht existiert.
Zeile 93: Zeile 98:
  
 Betrachte die Liste: Betrachte die Liste:
 +
 <code python> <code python>
 likeable_football_clubs = ["bvb", "liverpool", "st. gallen", "bayern", "freiburg", "breitenrain"] likeable_football_clubs = ["bvb", "liverpool", "st. gallen", "bayern", "freiburg", "breitenrain"]
Zeile 102: Zeile 108:
 <nodisp 1> <nodisp 1>
 ++++Lösung:| ++++Lösung:|
-<code python> 
 <code python> <code python>
 likeable_football_clubs = ["bvb", "liverpool", "st. gallen", "bayern", "freiburg", "breitenrain"] likeable_football_clubs = ["bvb", "liverpool", "st. gallen", "bayern", "freiburg", "breitenrain"]
Zeile 291: Zeile 296:
 * Modifiziere nun deinen Code so, dass der Abstand zwischen den Linien (a) enger oder (b) grösser wird. * Modifiziere nun deinen Code so, dass der Abstand zwischen den Linien (a) enger oder (b) grösser wird.
  
-In den bisherigen for-Schleifen wurde der Parameter in jedem Durchlauf um 1 erhöht. Möchten wir, dass grössere Schritte gemacht werden, können wir wie folgt vorgehen:+=== Startwert === 
 + 
 +Statt immer bei null zu starten, kann der Startwert auch angegeben werden: 
 +<code python> 
 +for m in range(10,20): 
 +    print(m) 
 +</code> 
 + 
 +Mit zwei Parametern interpretiert `range` den ersten als Start- und den zweiten als (exklusiven) Endwert. 
 + 
 +=== Schrittweite === 
 +In den bisherigen for-Schleifen wurde der Parameter in jedem Durchlauf um 1 erhöht. Möchten wir, dass grössere Schritte gemacht werden, können wir _drei_ Parameter verwenden:
 <code python> <code python>
 for m in range(0,101,10): for m in range(0,101,10):
Zeile 297: Zeile 313:
 </code> </code>
  
-Der Parameter `m` hat im ersten Durchlauf den Wert `0`. In jedem weiteren Durchlauf wird er um `10` erhöht, bis zum maximalen Wert `100`. Ersetzen wir die Zahl `101` durch `110`, so ist das Resultat genau das gleiche. Erst mit `111` ist die grösste ausgegebene Zahl `110`.+Der Parameter `m` hat im ersten Durchlauf den Wert `0`. In jedem weiteren Durchlauf wird er um `10` erhöht, solange er kleiner ist als der Endwert `101`. Ersetzen wir die Zahl `101` durch `110`, so ist das Resultat genau das gleiche. Erst mit `111` ist die grösste ausgegebene Zahl `110`.
  
 #### Positionen einer Liste aufzählen #### Positionen einer Liste aufzählen
Zeile 322: Zeile 338:
 === Aufgabe I2 === === Aufgabe I2 ===
  
-Verwende eine *for-Schleife* und die `rightArc`-Funktion um eine Spirale zu erzeugen, ähnlich wie diejenige im Bild. +Verwende eine *for-Schleife* und die `circle`-Funktion um eine Spirale zu erzeugen, ähnlich wie diejenige im Bild. 
  
 {{ :gf_informatik_1m_20_21:spirale.png?200 |}} {{ :gf_informatik_1m_20_21:spirale.png?200 |}}
Zeile 336: Zeile 352:
 <code python> <code python>
 for i in range(4,12): for i in range(4,12):
- print(i)+    print(i)
 </code> </code>
  
-<nodisp 2>+<nodisp 1>
 ++++Lösung:| ++++Lösung:|
 <code python> <code python>
Zeile 358: Zeile 374:
 </code> </code>
  
-<nodisp 2>+<nodisp 1> 
 ++++Lösung| ++++Lösung|
 <code python> <code python>
Zeile 378: Zeile 395:
  
 === Aufgabe I6 === === Aufgabe I6 ===
-Finde den Index (die Position) von `"Bebraham"` in der folgenden Liste: +Finde den Index (die Position) von `"Bebraham"` in der folgenden Liste. Nutze eine `for ... in range` Schleife, bei der die `range` über die Länge der Liste geht, wie [[#positionen_einer_liste_aufzaehlen|hier]] erklärt.
  
 `['Cebraham', 'Debraham', 'Bebraham', 'Abraham']` `['Cebraham', 'Debraham', 'Bebraham', 'Abraham']`
  
-<nodisp 2>+<nodisp 1>
 ++++Lösung| ++++Lösung|
 <code python> <code python>
Zeile 401: Zeile 418:
 Der Aufruf ohne Argument soll weiterhin die Siebnerreihe addieren. Der Aufruf ohne Argument soll weiterhin die Siebnerreihe addieren.
  
-<nodisp 2>+<nodisp 1>
 ++++Lösung| ++++Lösung|
 <code python> <code python>
Zeile 417: Zeile 434:
 </nodisp> </nodisp>
  
 +=== Aufgabe I8 ===
 +**Teil 1**: Schreibe eine Funktion `reverse(liste)`, die eine neue Liste erstellt und die Elemente von `liste` in umgekehrter Reihenfolge darin abspeichert und die umgekehrte Liste zurückgibt. Die eingebauten Funktionen `reverse` und `reversed` dürfen nicht benützt werden - verwende stattdessen eine [[#schrittweite|negative Schrittweite]] für `range`.
  
 +<nodisp 1>
 +++++Lösung|
 +<code python>
 +def reverse(liste):
 +    result = []
 +    # range erzeugt eine Zahlenfolge n, n-1, ... 3, 2, 1, 0:
 +    #       Beginne mit dem letzten Index (len(liste) - 1)
 +    #       Der letzte Index ist 0, das exklusive Ende damit -1
 +    #       Die Schrittweite ist -1 (wir zählen ja rückwärts)
 +    for index in range(len(liste) - 1, -1, -1):
 +        result.append(liste[index])
 +    return result
 +
 +names = ['Cebraham', 'Debraham', 'Bebraham', 'Abraham']
 +print(reverse(names))</code>
 +++++
 +</nodisp>
  • gf_informatik/programmieren_iii.1735548251.txt.gz
  • Zuletzt geändert: 2024-12-30 08:44
  • von hof