Programmieren II: Variablen, Schleifen, Funktionen

Du kannst bereits programmieren? Dann schau hier nach.

Neben Turtlegrafik kann man in TigerJython und Python auch noch andere Dinge machen, die Spass machen, wie z.B. Mathe.

Tipp: Möchtest du nur z.B. etwas berechnen, ohne dabei eine Turtle zu gebrauchen? Dann kannst du die zuvor immer benötigte Zeile Code from gturtle import * weg lassen.

In Variablen werden Werte gespeichert, die man im Laufe des Programms lesen oder verändern will. Variablen haben einen Namen und einen Wert. Der Name der Variable darf man frei wählen. Nicht erlaubt sind allerdings die Schüsselwörter (z.B. from, repeat, …) und Namen mit Sonderzeichen.

Variablen kannst du ganz einfach deklarieren: <Name der Variablen> = <Wert der Variablen>

Variablen haben jeweils einen Typ:

• Zahlen: Mit Zahlen kann man rechnen.
• Ein Text wird in der Informatik als String bezeichnet. In Python müssen Strings immer in Anführungs- und Schlusszeichen geschrieben werden. Zahlen sind keine Strings und benötigen deshalb keine Anführungs- und Schlusszeichen. Natürlich kann man mit Strings nicht rechnen.

Beispiele:

x = 7 # Zahl
 
a = "Hallo, ich bin ein String!" # String

Versuche, von nun an möglichst möglichst viel mit Variablen zu arbeiten!

Betrachte als Beispiel den folgenden Code:

x = 7
 
y = x*x
 
print(y)

Im ersten Schritte legen wir eine Variable mit Namen x fest und weisen ihr den Wert 7 zu. Danach quadrieren wir die Zahl und speichern diesen Wert in einer zweiten Variable mit Namen y. Nun geben wir in der Konsole den Wert der Variable y (also 49) aus. Die Konsole (auch Terminal) ist das Fenster unterhalb des Code-Fensters. Um etwas in der Konsole auszugeben, schreiben wir dies in die print(...) Funktion.

Führe diesen Code (selber schreiben, nicht copy-paste!) nun selbst aus. Weise der Variablen x nun einen anderen Wert zu. Damit wird dann auch der Wert der Variablen y verändert und dementsprechend sieht die Ausgabe im Terminal anders aus.

Einige wichtige mathematischen Operatoren sind:

Man kann auch den Benutzer auffordern, einen Input zu geben. Der eingegebene Wert kann dann in einer Variablen gespeichert werden:

x = input("Gib eine Zahl ein:")

Mit diesem Code wird der Benutzer aufgefordert, eine Zahl einzugeben. Sobald er dies gemacht hat, wird der eingetippte Wert in der Variablen x gespeichert. Diese kann danach z.B. dazu verwendet werden, um mit ihr etwas zu berechnen.

Beachte, dass man in die input()-Funktion eine Anweisung schreiben kann.

Betrachte nochmals den ersten Codeblock von diesem Kapitel. Dort wird eine Zahl in der Variablen x gespeichert. Danach weisen wir das Quadrat von x der Variablen y zu und geben diese aus. In der Konsole steht dann einfach 49. Wir hätten nun aber gerne, dass dort der Satz „Das Quadrat der Zahl 7 is 49“ ausgegeben wird. Dies erreichen wir mit der folgenden Zeile Code:

print("Das Quadrat der Zahl {0} is {1}".format(x,y))

In der print-Funktion schreiben wir in Anführungs- und Schlusszeichen den Satz, den wir gerne als Ausgabe hätten. Beachte, dass die beiden Zahlen nicht direkt in den String geschrieben werden. Stattdessen wollen wir, dass dort die Werte der Variablen x und y eingefügt werden. Dafür fügen wir an den richtigen Stellen die beiden Platzhalter {0} und {1} ein. An den String hängen wir dann den Befehl .format(x,y) an. Diese fügt für den ersten Platzhalter ({0}) den Wert der ersten Variablen (x) und für den zweiten Platzhalter ({1}) den Wert der zweiten Variablen (y) ein.

Von nun an arbeiten wir nur noch selten mit TurtleGraphics. Die Zeile from gturtle import * wird also nicht gebraucht und kann weggelassen werden.

1) Frage den Benutzer nach einer Zahl. Diese soll in der Variablen x gespeichert werden. Gib dann der Reihe nach aus:

• Das Quadrat der Zahl
• Die Wurzel der Zahl
• Das 10-fache der Zahl

2) Formatiere nun die Ausgabe, so dass jeweils steht:

• „Das Quadrat der Zahl 4 is 16“
• „Die Wurzel der Zahl 4 ist 2“
• „Das 10-fache der Zahl 4 ist 40“

Achtung: Natürlich soll dies nur gelten, falls der Input 4 ist. Falls eine andere Zahl eingegeben wird, soll die Ausgabe entsprechend anders sein.

Nun wollen wir wieder mit unserer Turtle arbeiten. Der Benutzer soll aufgefordert werden, eine Zahl einzugeben. Danach soll die Turtle ein Quadrat ablaufen. Die Seitenlänge des Quadrates soll genau dieser eingegebenen Zahl entsprechen.

Mache eine Kopie einer deiner bereits gelösten Aufgaben aus den Aufgaben A und B und speichere diese unter dem Namen aufgabe_D3.py. Suche einen möglichst langen und komplizierten Code aus. Füge nun überall wo es möglich ist, Variablen ein. Anstelle, dass du also immer fritz.left(90) schreibst, definiere eine Variable winkel = 90 und schreibe nachher immer fritz.left(winkel).

Kopiere deinen Code aus Aufgabe D2 und erweitere den Code. Anstelle eines Quadrates soll das Turtle nun ein Rechteck ablaufen. Dazu soll der Benutzer zuerst folgende Werte eingeben (alle mit einem seperatern input-Statement):

• x-Koordinate des Startpunkts
• y-Koordinate des Startpunkts
• Breite des Rechtecks
• Höhe des Rechtecks

Beim Programmieren kommt man oft in die Situation, wo man Entscheidungen treffen muss. Zum Beispiel soll, je nach dem was der Benutzer eintippt, ein anderer Code ausgeführt werden.

Am einfachsten ist der sogenannte if-Befehl: Damit kann man überprüfen ob (also if) eine gewisse Bedingung erfüllt ist oder nicht. Dieser Befehl hat die Form

if BEDINGUNG:
    # Codeblock, falls BEDINGUNG erfüllt ist

Es wird eine Bedingung überprüft. Falls diese erfüllt ist (und nur dann!), wird der darauffolgende Codeblock ausgeführt. Beachte:

• Nach der Bedingung muss ein Doppelpunkt stehen.
• Der nachfolgende Codeblock muss eingerückt (mit Tab) sein, wie bei der repeat- oder for-Schleife.

Bedingungen können zum Beispiel sein:

Wichtig: Beachte das Doppelgleichzeichen ==. Eine Bedingung mit nur einem Gleichzeichen wie z.B. x = 4 funktioniert nicht!

Oft hat man die Situation, in der man zwischen zwei Situationen unterscheiden möchte:

• Eine Bedingung wird erfüllt.
• Eine Bedingung wird nicht erfüllt.

Dies erreicht man mit einem if-else-Befehl (else: ansonsten):

if BEDINGUNG:
    # Code, falls BEDINGUNG erfüllt ist
else:
    # Code, falls BEDINGUNG nicht erfüllt ist

Es gibt auch die Situation, in der man verschiedene Bedingungen überprüfen möchte. Je nachdem, welche Bedingung erfüllt wird, wird ein anderer Codeblock ausgeführt. Ein solcher if-elif-else-Befehl hat die Form:

if BEDINGUNG1:
    # Code, falls BEDINGUNG1 erfüllt ist.
elif BEDINGUNG2:
    # Code, falls BEDINGUNG2 erfüllt ist, aber nicht BEDINGUNG1.
else:
    # Code, falls keine der Bedingungen erfüllt ist.

Bemerkungen:

• Man kann beliebig viele elif-Befehle hintereinanter haben.
• Falls die Bedingung bei if erfüllt ist, werden alle elifs gar nicht mehr überprüft!
• Gleiches gilt für elifs: Sobald die Bedingung von einem elif erfüllt wird, werden alle elifs weiter unten ignoriert.

Wir wollen ein Programm schreiben, in dem der Benutzer eine Zahl eintippen soll. Der Code soll dann entscheiden, ob die Zahl positiv oder negativ ist und eine entsprechende Message ausgeben:

x = input("Tippe eine Zahl ein:")
 
if x >= 0:
    print("Die Zahl {0} ist positiv.".format(x))
else:
    print("Die Zahl {0} ist negativ.".format(x))

Tippe dieses Beispiel ab (nicht einfach copy paste!) und führe es aus. Versuche dann, jede Zeile genau zu verstehen:

Schauen wir uns dies etwas genauer an: if x >= 0 überprüft, ob die Zahl grösser gleich 0 ist. Falls ja wird der darauffolgende print-Befehl ausgeführt, in dem mitgeteilt wird, dass die Zahl positiv ist. Falls die Bedingung if x >= 0 nicht erfüllt ist, muss die Zahl also negativ sein. Deshalb wird in diesem Fall der print-Befehl nach dem else ausgeführt.

Nimm den Code aus dem Beispiel als Startpunkt. In diesem wird eine Zahl eingeben wird und dann entschieden, ob die Zahl positiv oder negativ ist. Erweitere den Code nun so, dass zwischen den folgenden drei Fällen unterschieden wird:

• x ist positiv
• x ist genau gleich 0
• x ist negativ

Tipp: Hier benötigst du einen if-elif-else-Befehl.

Schreibe ein Programm, in dem der Benutzer eine Figur wünschen kann, die der Turtle dann abläuft. Diese sollen sein:

• Quadrat
• Kreis

Der Benutzer soll dazu aufgefordert werden, eine Figur einzutippen (also z.B. „Quadrat“). Dann soll der Turtle diese Figur ablaufen. Achte darauf, dass der Benutzer den Input genau so schreiben muss, wie es in der Bedingung steht! Gib dem Benutzer als Hilfe die zur Auswahl stehenden Figuren vor. Falls etwas falsches eingetippt wird, soll der Benutzer freundlich darauf hingewiesen werden, dass seine Eingabe nicht zulässig ist.

*Optional: Füge weitere Figuren hinzu.

Schreibe ein kleines Mathe-Quiz-Spiel. Der Benutzer soll eine Additionsrechnung erhalten, die er lösen soll. Nachdem er das Resultat eingegeben hat, soll er die Rückmeldung erhalten, ob das Resultat korrekt war oder nicht.

Erweitere nun dein Mathe-Quiz. In diesem soll die Aufgabe per Zufall generiert werden. Nutze den Zufallsgenerator von Python, um die beiden Zahlen, die addiert werden sollen, zufällig zu wählen.

Dazu musst du das random-Modul einbinden.

import random # schreibe dies ganz oben in deinem Code
...
x = random.randint(0,10) # wählt zufällig eine Zahl aus den Zahlen 0,1,2,3,...,9,10 aus
...

Die for-Schleife ist praktisch, wenn man genau weiss, wie oft etwas durchgeführt werden soll. In der Aufgabe E3 hast du ein Mathe-Quiz mit 10 Runden programmiert. Dort hat es Sinn gemacht, eine for-Schleife (for i in range(10)) zu verwenden. Dies ist aber nicht immer der Fall. Zum Beispiel könnte man ein Spiel programmieren, in dem man nur solange weiterspielen darf, bis man einen Fehler macht. Es entscheidet sich also erst im Spiel, wie viele Runden man spielt - vielleicht sind es 30, vielleicht aber auch nur eine.

Dies können wir mit einer while-Schleife (dt. während) umsetzen. Diese hat folgende Form:

...
while BEDINGUNG:
    ... # Dieser Codeblock wird solange ausgefuehrt,
    ... # wie die BEDINGUNG True (also erfuellt) ist
 
... # Dieser Code wird ausgefuehrt
... # sobald die BEDINGUNG nicht mehr erfuellt ist

Die Bedingungen schreibt man gleich wie für for-Schleifen, also ==, >, >=, ...

Beispiel: Im folgenden Programm wird man aufgefordert, eine positive Zahl einzugeben. Man kann solange weiterspielen, bis man etwas eingibt, was keine positive Zahl ist, also z.B. eine negative Zahl oder Text.

x = input("Gib eine positive Zahl ein:")
 
while x > 0:
    x = input("Gib eine positive Zahl ein:")
 
print("Game Over! Du hast etwas eingegeben, was keine positive Zahl ist.")

Tippe diesen Code ab, führe ihn aus und stelle sicher, dass du jede Zeile verstehst.

Falls wir einen Codeblock so oft ausführen wollen, bis der Benutzer abbricht, können wir eine Endlosschleife erzeugen. Wir schreiben dazu eine while-Schleife mit einer Bedingung, die immer erfüllt ist. Eine Möglichkeit wäre 7==7, einfacher ist es aber, einfach True zu schreiben:

...
while True:
    ... # Dieser Code wird solange ausgeführt, bis der Benutzer abbricht
 
... # Dieser Code wird NIE erreicht

Eine Möglichkeit gibt es aber, aus eine Schleife wie der oberen (while True: ...) auszubrechen: Wird der Befehl break aufgerufen, wird die Schleife umgehend abgebrochen und der Code unterhalb wird ausgeführt.

Schreibe ein Programm, in dem man eine zweistellige Zahl eingeben soll. Dies soll man solange machen können, bis man diese Bedingung einmal nicht mehr erfüllt.

Beachte, dass du dazu zwei Bedingungen (Bedingung 1: grösser gleich 10, Bedingung 2: kleiner als 100) verknüpfen muss. Dies kann man einfach mit dem Keyword and erreichen. Dies funktioniert für Verzweigungen und while-Schleifen:

if BEDINGUNG1 and BEDINGUNG2:
    ...
 
while BEDINGUNG1 and BEDINGUNG2:
    ...    

Erweitere nun dein Spiel aus F3 wie folgt:

Erweitere nun dein Spiel wie folgt: Es sollen mehrere Runden gespielt werden, wobei in jeder Runde eine Zufallsaufgabe generiert wird (wie in Schritt 2). Es soll mitgezählt werden, wie viele Aufgaben richtig gelöst wurden. Nach jeder Frage wird der Spielstand ausgegeben, der Spieler soll eine entsprechende Rückmeldung erhalten, z.B.: Du hast 7 von 10 Aufgaben richtig gelöst.

Gleich wie Aufgabe F3. Es sollen aber neben der Addition auch Subtraktionen und Multiplikationen vorkommen. Die Division sollte weggelassen werden, da es dort schnell Aufgaben gibt, die man kaum lösen kann. Welche der drei Operationen an der Reihe ist, soll ebenfalls der Zufall entscheiden.

Tipp: Verwende eine Endlosschleife.

Mache eine Kopie von deinem Mathe-Quiz aus der letzten Aufgabe. Wähle eine der beiden Varianten:

Man soll solange spielen können, bis man einen Fehler macht. Bei einem Fehler ist Game Over.

Man soll solange spielen können, bis man drei Fehler gemacht hat. Dann ist Game Over.

Komplexe Programme können mit Hilfe von Funktionen in kleinere, leichter zu programmierende Teilprogramme zerlegt werden. Solche Teilprogramme können zudem mehrmals verwendet werden.

Eine Funktion ist immer wie folgt aufgebaut:

def name_der_funktion(PARAMETER): # Parameter sind optional
    # CODE DER FUNKTION
    return RETURN_WERT # ist optional

• Das Schlüsselwort def leitet immer die Definition einer Funktion ein.
• Darauf folgt der Funktionsname. Typischerweise schreibt man diesen mit ausschliesslich Kleinbuchstaben und Underlines _
• Direkt anschliessend werden runde Klammern geschrieben. Diese enthalten die Parameter. Das sind Werte, die an die Funktion übergeben werden. Funktionen können auch ohne Parameter definiert werden, die Klammern sind dann halt einfach leer.
• Nach einem Doppelpunkt …
• kommt der Funktionskörper, welcher den eigentlichen Code der Funktion beinhaltet. Dieser Code muss eingerückt sein.

Nachdem du eine Funktion definiert hast, kannst du sie ganz einfach aufrufen. Dazu mehr in den Beispielen unten.

Übrigens hast du schon viele Funktionen kennengelernt - ohne dass du es wahrscheinlich gemerkt hast. Zum Beispiel ist die Funktion forward() für Turtles eine Funktion, die ein Turtle vorwärts laufen lässt. Diese Funktion wurde vorprogrammiert. Nun wollen wir schauen, wie wir unsere eigenen Funktionen definieren können.

In diesem Unterkapitel schauen wir Funktionen ohne Rückgabewert an, also Funktionen ohne das return-Statement am Ende.

Beispiel: Du möchtest das gleiche Quadrat mehrfach zeichnen. Dies kannst du wie folgt machen:

from gturtle import *
 
fritz = Turtle()
fritz.hideTurtle()
 
# Quadrat 1
fritz.setPos(-130,0)
repeat 4:
    fritz.forward(100)
    fritz.left(90)
 
# Quadrat 2
fritz.setPos(0,0)
repeat 4:
    fritz.forward(100)
    fritz.left(90)

Es fällt auf, das hier zweimal der identische Code vorkommt:

repeat 4:
    fritz.forward(100)
    fritz.left(90)

Dies ist nicht sehr elegant. Wenn man nun das gleiche Quadrat 10-mal zeichnen möchte, wird es noch viel schlimmer! Es lohnt sich deshalb hier, eine Funktion quadrat zu definieren und diese dann mehrfach aufzurufen:

from gturtle import *
 
fritz = Turtle()
fritz.hideTurtle()
 
def quadrat():
    repeat 4:
        fritz.forward(100)
        fritz.left(90)
 
# Quadrat 1
fritz.setPos(-130,0)
quadrat()
 
# Quadrat 2
fritz.setPos(0,0)
quadrat()

Beachte, dass man jeweils zuerst die Position der Turtle festlegen muss, bevor man die Funktion aufrufen kann. Noch eleganter ist es, wenn man das Setzen der Position in die Funktion hinein nimmt. Die Koordinaten muss man dann der Funktion als Argument übergeben. Mit zwei weiteren Argumenten geben wir die Grösse des Quadrates und die Farbe an:

from gturtle import *
 
fritz = Turtle()
fritz.hideTurtle()
 
def quadrat(x,y):
    fritz.setPos(x,y)
    repeat 4:
        fritz.forward(100)
        fritz.left(90)
 
# Quadrat 1
quadrat(-130,0)
 
# Quadrat 2
quadrat(0,0)

Man kann der Funktion auch noch weitere Argumente übergeben, zum Beispiel um die Grösse des Quadrats und dessen Farbe anzugeben:

from gturtle import *
 
fritz = Turtle()
fritz.hideTurtle()
 
def quadrat(x,y,seite,farbe):
    fritz.setPos(x,y)
    fritz.setPenColor(farbe)
    repeat 4:
        fritz.forward(seite)
        fritz.left(90)
 
# Quadrat 1
quadrat(-130,0,70,"red")
 
# Quadrat 2
quadrat(0,0,100,"magenta")

Funktionen bieten sich auch an, wenn man mehrfach die gleiche Rechnung, einfach mit verschiedenen Werten, ausführen möchte. Allerdings möchte man dann, dass die Funktion einem das Resultat als Rückgabewert zurück gibt.

Beispiel: Wir wollen eine Funktion definieren, die uns das Volumen eines Quaders zurück gibt. Falls der Quader die Seitenlängen $a,b$ und $c$ hat, so ist sein Volumen $$V = a \cdot b \cdot c$$ Die zugehörige Funktion ist dann:

quader.py

def quader(a,b,c):
    resultat = a*b*c
    return resultat
 
print(quader(4,3,2))

Auf der letzten Zeile wird das Volumen für einen Quader mit Seitenlängen $4, 3$ und $2$ berechnet und dann in der Konsole ausgegeben.

Definiere folgende Funktionen:

• quadrat(breite,farbe,x,y)
• dreieck(breite,farbe,x,y)
• kreis(radius,farbe,x,y)

Ruft man z.B. die Funktion dreieck(300,red,-200,50) auf, soll ein rotes Dreieck mit Startpunkt (-200,50) gezeichnet werden.

Zeichne mit diesen Funktionen ein Bild. Jede der drei Formen soll mindestens 3x vorkommen. Variiere die Farbe und Grösse der Formen.

Kennt man in einem rechtwinkligen Dreieck die beiden Katheten, so kann man mit dem Satz von Pythagoras die Hypothenuse bestimmen. Definiere eine Funktion mit Namen pythagoras. Als Argumente soll man die beiden Katheten eines rechtwinkligen Dreiecks eingeben. Die Funktion berechnet dann die Hypothenuse und gibt diese mit return zurück.

Tipp: Die Wurzel einer Zahl ziehst du mit sqrt(x), dazu musst du aber zuerst das math-Modul importieren: import math.

Kontrolle: Für die Katheten 3 und 4 ist die Hypothenuse 5. Die Codezeile print(pythagoras(3,4)) soll dann also 5.0 ausgeben.

Das Volumen einer Kugel mit Radius $R$ ist: $$V = \frac{4\pi}{3}\cdot R^3$$ Definiere eine Funktion kugel, der man als Argument den Radius übergibt und die dann das Volumen zurückgibt. Die Kreiszahl Pi ($\pi$) kannst du mit math.pi aufrufen, dazu muss aber auch wieder zuerst das math-Modul importiert werden (import math).

Definiere eine Funktion wuerfel, welche einen Würfel simuliert, d.h. eine Zufallszahl zwischen 1 und 6 mit return zurückgibt.

Die Fakultät ist eine Funktion, welche jeder ganzen natürlichen Zahl das Produkt aller natürlichen Zahlen (ohne Null) kleiner und gleich dieser Zahl zuordnet. Sie wird mit einem Ausrufezeichen geschrieben. Als Beispiel: $5!=1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 =120$.

Schreibe eine Funktion fakultaet, welcher als Argument eine ganze Zahl übergeben wird und welche dir dann die Fakultät dieser Zahl zurückgibt.

Challenge: Kannst du die Fakultät ganz ohne Schleife berechnen? Dann hast du das Prinzip der Rekursion (Selbst-Aufruf) entdeckt!

In einer Zusatzaufgabe von früher (https://sca.ksr.ch/doku.php?id=gf_informatik_1m_20_21:python_zusatzaufgaben#euklidischer_algorithmus) hast du den euklidischen Algorithmus benutzt, um den ggT von zwei Zahlen zu berechnen.

Schreibe eine Funktion ggt und kgv welche als Argument zwei Zahlen nimmt, und daraus den grössten gemeinsamen Teiler, bzw. das kleinste gemeinsame Vielfache berechnet.

Wenn du das gemacht hast, machst du daraus eine einzelne Funktion, welche als Argument zusätzlich einen String mit ggt, bzw. kgv entgegennimmt und dann entweder den ggT bzw. das kgV ausgibt.

In Aufgabe F2 wird der Benutzer gefragt, was für eine Grafik angezeigt werden soll. Erweitere deinen Code, so dass der Benutzer folgendes machen kann:

• Auswahl der Farbe
• Festlegen der Grösse
• Festlegen der Stiftbreite
• Weitere Formen

Tipp: Möchte man die Formen farbig ausfüllen, so lohnt es sich, die 2. Methode mit fillToPoint zu verwenden.

In einer Aufgabe oben hast du eine Funktion wuerfel definiert. Simuliere nun mit TurtleGraphics einen Würfel.

Bisher haben wir Resultate entweder mit print() direkt in der Konsole ausgegeben oder als einzelne Zahlen in Variablen gespeichert. Oft macht es Sinn, Werte in Listen zu speichern. Dies geht ganz einfach:

Eine Liste erstellt man wie folgt:

L = [2,4,6,8]

Eine Liste besteht aus Elementen, die Position eines Elements wird Index genannt. Die Elemente einer Liste kann man über ihren Index auslesen. Das erste Element hat den Index 0, das zweite den Index 1 usw. print(L[2]) gibt also 6 in der Konsole aus. Ganz ähnlich kannst du auch einen Wert ändern: L[2] = 7.

Elemente hinten hinzufügen kann man mit append:

L = [2,4,6,8]
L.append(10)

Nach dem append-Befehl sieht die Liste wie folgt aus: [2, 4, 6, 8, 10]. Mit print(L) kannst du dich selbst davon überzeugen. Weitere wichtige Befehle sind

L.insert(2,5) # fügt an Index-Position 2 den Wert 5 ein
L.pop(4) # Entfernt das Element mit Index 4
len(L) # Gibt an, wieviele Elemente sich in der Liste befinden. Diesen Wert kann man z.B. printen oder in einer Variablen speichern

Es ist ganz einfach, alle Elemente einer Liste durchzugehen:

for e in L:
    print(e)

Diese Aufgabe besteht aus vielen kleinen Teilaufgaben, in denen die Grundlagen der Listen geübt werden.

1. Erstelle die Liste A = [0,1,2,3,4,5,6]. Füge der Liste hinten den Wert 7 hinzu. Entferne dann weiter das erste Element 0. Printe die bearbeitete Liste in die Konsole und vergewissere dich, dass sie wie folgt ausschaut: [1, 2, 3, 4, 5, 6, 7].
2. Erstelle eine leere Liste B = []. Nun sollen alle Werte von 0 bis 99 darin gespeichert werden. Erstelle dazu eine for-Schleife, die durch alle Werte von 0 bis 99 zählt. In jedem Durchlauf der for-Schleife soll das nächste Element hinzugefügt werden.
3. Kopiere die folgende Liste ins TigerJython: C = [68, 71, 53, 34, 66, 55, 80, 93, 24, 49, 68, 73, 9, 8, 93, 22, 44, 11, 82]. Bestimme dann mithilfe von deinem Wissen über Listen, aus wievielen Elementen diese Liste besteht. Selbst zählen zählt nicht!
4. Kopiere die Liste [0,2,4,6,8,10,12,16,18,20] ins TigerJython. In ihr fehlt die Zahl 14! Füge diese am richtigen Ort ein.
5. Kopiere die Liste [0,2,3,6,8,10,13,14,16,19,20] ins TigerJython. In ihr sind drei Zahlen falsch! Ändere diese, in dem du direkt die Werte anpasst. Du darfst also weder pop noch insert verwenden. Wähle also zum Beispiel das Element mit Index 2 aus und ändere seinen Wert.
6. Die folgende Liste sollte eigentlich ausschlisslich aus Zahlen der 5er-Reihe bis und mit 50 bestehen: E = [5,10,12,15,20,27,30,31,35,36,40,50]. Kopiere diese Liste ins TigerJython und bearbeite sie so, dass sie stimmt: Entferne falsche Elemente und füge fehlende Elemente ein. Arbeite also ausschliesslich mit pop und insert.

Definiere eine Funktion zero_list(n). Dieser wird als Argument eine Zahl übergeben. In der Funktion wird dann eine Liste erstellt, die n-mal die Zahl 0 enthält. Diese Liste wird dann zurückgegeben. Mit dem Befehl print(zero_list(7)) soll man dann also den Output [0, 0, 0, 0, 0, 0, 0] erhalten.

Betrachte die Liste [68, 71, 53, 34, 66, 55, 80, 93, 24, 49, 68, 73, 9, 8, 93, 22, 44, 11, 82]

1. Berechne die Summe aller Elemente in der Liste in einer for-Schleife.
2. Berechne die Summe aller ungerader Elemente (also das erste, dritte,…) in der Liste.

Natürlich sollen sämtliche Schritte voll automatisiert ablaufen. Tauscht man die Liste mit einer anderen Liste, so soll der Code auch funktionieren.

Implementiere einige Funktionen, welche einem helfen sollen, Listen zu analysieren:

• Funktion liste_anzahl(L,x): Nimmt eine Liste L und eine Zahl oder ein String x entgegen. Die Funktion bestimmt dann, wie oft das Element x in L vorkommt und gibt diese Anzahl zurück.
• Funktion liste_max(L): Bestimmt das grösste Element einer List (welche aus Zahlen besteht) und gibt dieses zurück.
• Funktion liste_min(L): Ähnlich wie liste_max(L), gibt aber das kleinste Element zurück.

Für die Liste A = [3,1,5,4,9,4,8,3,1,2,4,9] und die Aufrufe

print(liste_anzahl(A,3))
print(liste_max(A))
print(liste_min(A))

ist der Output

2
9
1

Programmiere eine Funktion liste_haeufigste(L): Gibt eine Liste zurück, die alle Elemente enthält, die am häufigsten vorkommen. Neben dieser Liste wird auch eine Zahl ausgegeben, die angibt, wie oft diese Elemente in der Liste vorkommen.