In VSCode können Sie mehrere Zeilen auf einmal bearbeiten! Klicken Sie dazu an eine beliebige Stelle im Code und halten Sie dann die Alt-Taste gedrückt, während Sie an weiteren Stellen klicken.
Alternativ können Sie (an den meisten Geräten) Ctrl + Alt + ArrowUp/ArrowDown drücken, um mehrere Cursors genau untereinander zu setzen.
Oder Sie klicken die erste Stelle an, drücken dann Alt + Shift und klicken gleichzeitig an eine zweite Stelle; die Cursors werden jetzt untereinander überall zwischen der ersten und der zweiten Position platziert.
Auch die Command Palette kann zusätzliche Cursors setzen. Drücken Sie Ctrl + Shift + P und tippen Sie add cursor ein, um dann eine der verfügbaren Optionen auszuwählen.
Probieren Sie es aus: Kopieren Sie den folgenden Text in den Editor und ergänzen Sie mit einem Multicursor in allen Zeilen die vollständige Jahreszahl ("2018" statt "'18").
09.10.'18
16.10.'18
23.10.'18
30.10.'18
06.11.'18
13.11.'18
20.11.'18
27.11.'18
04.12.'18
11.12.'18for: Schleifen für Sequenzen¶Um auf die Elemente in einer Liste nacheinander zuzugreifen, schreiben wir eine Schleife (loop). Alle Befehle, die in der Schleife stehen, werden schrittweise immer wieder für jedes einzelne Element der Liste ausgeführt. Nach dem letzten Element wird die Schleife verlassen und die Befehle unterhalb der Schleife werden ausgeführt.
# Liste definieren und Inhalt in einer Variable speichern
zahlen_bis_zehn = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print("Start") # Das Wort "Start" ausgeben
for zahl in zahlen_bis_zehn: # Diese Zeile leitet die Schleife ein.
print("Aktuelle Zahl:") # Erster Befehl in der Schleife
print(zahl) # Zweiter Befehl in der Schleife
# Befehle ab hier gehören nicht mehr zur Schleife.
print("Ende") # Das Wort "Ende" ausgeben
Das Konstrukt, das wir oben verwendet haben, heißt for-Schleife. Diese Schleifen entsprechen immer dem folgenden Muster:
for <element> in <collection>:
<befehl1>
<befehl2> # (optional)
<befehl3> # (optional)
<...>
Die Zeile, die mit for beginnt und mit : endet, heißt Kopf der Schleife. Die Zeilen, die darunter stehen und weiter eingerückt sind als der Kopf, heißen Körper. Befehle, die im Körper einer Schleife stehen, müssen immer gleich weit eingerückt sein (typischerweise 4 Leerzeichen pro Einrückungsebene).
Auf Englisch heißt Einrückung indentation (als Verb: to indent).
Befehle, die die gleiche Einrückung haben wie der Kopf der Schleife, werden außerhalb der Schleife ausgeführt, also nur einmal und nur vor/nach der Ausführung der Schleife.
Es ist dabei egal, ob die collection (beispielsweise eine Liste) als Variable übergeben wird oder als konkreter Wert. Sie können das Beispiel von oben also folgendermaßen umschreiben, ohne die Funktionalität des Programms zu verändern:
# Das Wort "Start" ausgeben
print("Start")
for zahl in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]: # Diese Zeile leitet die Schleife ein.
print("Aktuelle Zahl:") # Erster Befehl in der Schleife
print(zahl) # Zweiter Befehl in der Schleife
# Das Wort "Ende" ausgeben
print("Ende")
Das element bekommt von Ihnen einen Namen, den Sie im Kopf der Schleife angeben. Im Beispiel oben lautet der Name zahl. Das jeweils aktuelle Element ist dann im Körper der Schleife unter diesem Variablennamen abrufbar. Deshalb wird im ersten Schleifendurchlauf die Zahl 1 ausgegeben, im zweiten die Zahl 2 usw.
Nachdem die Schleife beendet ist, behält die Variable den letzten zugewiesenen Wert.
Tipp: Da der Name des Elements sich pro Schleifendurchlauf auf genau ein Element bezieht, wählen wir typischerweise einen Namen im Singular (wie "zahl"). Der Name der Variable, in der die Liste gespeichert ist, steht hingegen im Plural (wie "zahlen_bis_zehn"). Wenn Sie sich an diese Konvention halten, ist Ihr Code gut lesbar, weil Kollektionen (wie Listen) und individuelle Elemente auf den ersten Blick unterschieden werden können.
Fortlaufende Listen von Zahlen kann Python übrigens für uns erzeugen, ohne dass wir jede Zahl aufschreiben müssen. Das ist nützlich, wenn wir eine lange Liste brauchen (z.B. Zahlen bis 100) oder die Anzahl der Schleifendurchläufe durch andere Werte im Programm bestimmt werden soll.
Eine weitere Benennungskonvention ist, dass wir in Schleifen wie der hier folgenden das aktuelle Element mit dem Buchstaben i bezeichnen.
for i in range(10):
print(i)
# range([min], max) erzeugt eine Kollektion, die alle Ganzzahlen
# zwischen min (inklusive; falls nicht angegeben, 0) und max (exklusive) enthält.
for i in range(2,5):
print(i)
Wir haben jetzt also auf den aktuellen Wert in Variablen zugegriffen, um anzuzeigen, welchen Wert die Variable gerade hat. Für jeden Datentyp gibt es bestimmte Operationen, die zu neuen Werten führen. Einige Beispiele:
print(1 + 4)
print("Erst das Wasser, " + "dann die Säure!")
print([1, 2, 3] + [4, 5, 6])
Probleme gibt es, wenn wir versuchen, Werte verschiedener Typen miteinander zu verknüpfen:
print(333 + ": bei Issos Keilerei")
Es gibt mehrere Möglichkeiten, die gewünschte Ausgabe (Zeichenkette mit den angegebenen Zahlen am Anfang) zu erreichen. Wir verwenden hier im Kurs vorerst die folgende Methode:
print(str(333) + ": bei Issos Keilerei")
Auch die anderen oben aufgelisteten Datentypen können mit dem Befehl str() explizit in Strings umgewandelt werden.
Eine Operation, die wir auf zwei Werte anwenden können, ist ==. Damit wird geprüft, ob die beiden Elemente, die verglichen werden, den gleichen Wert haben. Das Ergebnis ist vom Typ bool.
print(4 == 4) # genau der gleiche Wert
print("words" == "Words") # Groß- und Kleinschreibung wird unterschieden
print(1 == "1") # verschiedene Datentypen
Genau das Gegenteil macht der Operator !=, der prüft, ob zwei Werte ungleich sind. Außerdem gibt es die Operatoren >, <, >= (größer oder gleich) und <= (kleiner oder gleich).
print(4 != 4) # genau der gleiche Wert
print("words" != "Words") # Großschreibung ist wichtig
print(1 != "1") # verschiedene Datentypen
print(3 > 3)
print(4 <= 4)
Werte vom Typ bool können miteinander verknüpft werden, und zwar mit den Operatoren and, or, not.
Ctrl + Enter ausführen, um zu prüfen, ob Sie richtig lagen.print(True and not False)
print(False or True)
print(True and True and True and True and False or True)
# Ihre String-Vergleichstests
if, elif, else¶Wahrheitswerte und Vergleiche sind ein wichtiger Bestandteil unseres Werkzeugkastens, da sie uns helfen, Programmabläufe zu steuern. Wenn bestimmte Bedingungen erfüllt sind, soll eine Reihe von Befehlen ausgeführt werden; wenn andere Bedingungen erfüllt sind, sollen andere Befehle ausgeführt werden. Die Syntax für diese Steuerung sieht wie folgt aus:
heizung_an = False
temperaturen = [24, 23, 19, 20, 17, 24, 14]
for temperatur in temperaturen:
if temperatur <= 19: # bei Temperaturen unter 19°C...
heizung_an = True # ... schalten wir die Heizung an
elif 19 < temperatur < 21: # bei Temperaturen zwischen 19°C und 21°C...
heizung_an = True # ... schalten wir die Heizung an
else: # in jedem anderen Fall...
heizung_an = False # ... schalten wir die Heizung aus
print("Temperatur: " + str(temperatur))
print("Heizung an: " + str(heizung_an))
Mit if, elif und else können wir prüfen, ob die angegebenen Bedingungen erfüllt sind. Ein if-Block hat die folgende Struktur:
if <bedingung>:
<befehl1>
<befehl2 usw.> # optional
elif <bedingung2>: # optional
<befehl3>
<befehl4 usw.> # optional
else: # optional
<befehl5>
<befehl6 usw.> # optional
Wenn Sie nur den if-Block verwenden und die beiden anderen weglassen, wird bei Nichterfüllung der Bedingung einfach der ganze Block übersprungen.
Wenn Sie if in Kombination mit elif verwenden, wird bei Nichterfüllung der ersten Bedingung als nächstes die zweite Bedingung geprüft. Sie können beliebig viele elif-Blöcke aneinanderreihen. Achtung: Sobald ein if- oder elif-Block ausgeführt wurde, werden die Bedingungen der verbleibenden elif-Blöcke nicht mehr geprüft und die Befehle dort übersprungen.
Wenn Sie else verwenden, werden bei Nichterfüllung der Bedingungen in den Blöcken davor stattdessen die Befehle im else-Block ausgeführt.
True und False ausgegeben werden, sondern stattdessen "Heizung an" oder "Heizung aus", je nachdem, welchen Wert die Variable heizung_an gerade hat.# Ihre Lösung (1.)
# Ihre Lösung (2.)
Da wir computerlinguistische Programme schreiben wollen, sind Zahlen, Zeichenketten und Listen die Datentypen, die wir ständig verwenden. Vor allem mit Strings wollen wir viel arbeiten.
Python stellt uns eine Reihe von Operationen zur Verfügung, die wir auf Strings anwenden können. Wir sprechen von Methoden.
Um eine Methode auf einen einzelnen String anzuwenden, schreiben wir beispielsweise:
"Hallo Welt".split()
Am Anfang steht der Originalstring (oder eine Variable, deren Inhalt ein String ist). Nach dem Punkt folgt der Name der Operation, die wir ausführen wollen. Das ist in diesem Fall split. Die öffnenden und schließenden Klammern sind dazu da, weitere Vorgaben für die Operation zu machen. Diese zusätzlichen Bedingungen in den Klammern werden Parameter genannt.
Hier also die allgemeine Form für solche Stringoperationen:
<string>.<operation>(<parameter1>, <parameter2 usw.>)
Jede Operation hat einen Rückgabetyp. Zum Beispiel ist die Rückgabe (das Ergebnis) von "Hallo Welt".split() eine Liste der Strings, die sich ergeben, wenn man den ursprünglichen String an allen Leerzeichen aufteilt:
# Ausgabe: Typ von "Hallo Welt"
print(type("Hallo Welt"))
# Ausgabe: Ergebnis der Aufteilung von "Hallo Welt"
print("Hallo Welt".split())
# Ausgabe: Typ, den das Ergebnis der Aufteilung von "Hallo Welt" hat
print(type("Hallo Welt".split()))
Die optionalen Parameter für die Methode split() heißen sep und maxsplit. Damit können wir angeben, an welchem Substring der ursprüngliche String aufgeteilt werden soll und wie viele Teilungen erfolgen sollen. Wir könnten zum Beispiel einen String, der ein Datum enthält, an allen Punkten aufteilen:
print("16.10.2018".split(sep="."))
Oder wir wollen den folgenden String am ersten "-" aufteilen, die anderen Vorkommen dieses Zeichens aber intakt lassen:
print("2018-10-16".split(sep="-", maxsplit=1))
Die Parameter einer Methode haben eine vorgegebene Reihenfolge. In diesem Fall wird immer sep als erster Parameter erwartet, maxsplit als zweiter. Wir können den Namen der Parameter in diesem Fall weglassen, wenn wir die Parameter in der richtigen Reihenfolge einfügen:
print("2018-10-16".split("-", 1))
Das geht allerdings nur, solange kein Parameter ausgelassen wird. Für split ist der Parameter sep optional, aber eventuell möchten wir trotzdem einen Wert für maxsplit angeben. Dann müssen wir den Namen des Parameters angeben.
So verwenden wir split, wenn wir am Standardseparator (dem Leerzeichen) splitten wollen, aber nur eine bestimmte Anzahl von Elementen brauchen:
print("All that glitters is gold, only shooting stars break the mold".split(maxsplit = 5))
Nach dem ersten benannten Parameter müssen auch die folgenden Parameter benannt werden. Sonst schlägt der Befehl fehl, so wie hier:
print("Hallo Welt".split(sep="l", 2))
Übrigens spricht nichts dagegen, längere Substrings als Wert für sep zu verwenden. Denken Sie nur daran, dass die Substrings in der Liste, die wir als Ergebnis bekommen, nicht mehr enthalten sind:
print("Ich kenne die Weise, ich kenne den Text, ich kenn auch die Herren Verfasser".split(sep="enn"))
Fassen wir zusammen:
print("Hallo Welt".split()) # n Teilungen am Standardseparator
print("----------")
print("Hallo Welt".split("W")) # Teilung am angegebenen Separator
print("Hallo Welt".split(sep="W")) # Teilung am angegebenen Separator
print("----------")
print("Hallo Welt".split(sep="l", maxsplit=2)) # 2 Teilungen am angegebenen Separator
print("Hallo Welt".split("l", 2)) # 2 Teilungen am angegebenen Separator
print("Hallo Welt".split("l", maxsplit=2)) # 2 Teilungen am angegebenen Separator
print("----------")
print("Hallo Welt".split(maxsplit=1)) # 1 Teilung am Standardseparator
Nachdem wir gesehen haben, wie man Strings mit Funktionen verarbeiten kann, hier einige wichtige Operationen, die wir auf Strings anwenden können. Beachten Sie, dass die Funktionen unterschiedliche Rückgabetypen haben.
| Operation | Rückgabe |
|---|---|
s.split([sep, n]) |
Liste aller Teilstrings von s, die durch den Separator voneinander getrennt sind. Wenn weder sep noch n angegeben werden, wird der String an jedem Leerzeichen geteilt. Mit sep kann man spezifizieren, an welchen Teilstrings der String zerteilt werden soll, und mit n, wieviele Zerteilungen erfolgen sollen. |
s.lower() |
String: Kopie von s, in der alle Buchstaben kleingeschrieben sind |
s.upper() |
String: Kopie von s, in der alle Buchstaben großgeschrieben sind |
s.islower() |
Bool: True, wenn alle Buchstaben in s kleingeschrieben sind; sonst False |
s.isupper() |
Bool: True, wenn alle Buchstaben in s großgeschrieben sind; sonst False |
sub in s |
Bool: True, wenn der Teilstring sub in s enthalten ist; sonst False. Groß- und Kleinschreibung wird unterschieden. |
len(s) |
Integer: Anzahl der Zeichen, die in s enthalten sind. |
s.count(sub) |
Integer: Anzahl, wie oft der Teilstring sub in s enthalten ist |
s.startswith(sub) |
Bool: True, wenn der Teilstring sub am Anfang von s steht; sonst False |
s.endswith(sub) |
Bool: True, wenn der Teilstring sub am Ende von s steht; sonst False |
s.find(sub) |
Integer: Position des ersten Vorkommens von sub in s; falls sub nicht enthalten ist, wird -1 zurückgegeben |
s.strip([chars]) |
String: Kopie von s ohne alle Vorkommen der angegebenen chars an Beginn und Ende des Strings. Wird chars nicht angegeben, werden alle führenden und abschließenden Whitespaces von s entfernt. |
s.replace(old, new) |
String: Kopie von s, in der alle Vorkommen des Teilstrings old durch den String new ersetzt wurden. |
rsplit() als Pendant zu split(). Prüfen Sie, für welche Funktionen das gilt. Können Sie experimentell herausfinden, was die Bedeutung dieser r-Varianten ist? Tipp: Die Funktion strip() hat auch eine l-Variante, lstrip().# Ihre Tests
Da wir Anführungszeichen "" zur Markierung von Strings verwenden, können wir innerhalb von Strings zunächst keine Anführungszeichen schreiben. Es gibt einige Möglichkeiten, damit umzugehen.
Erstens erfüllen in Python die einfachen Anführungszeichen '' die gleiche Funktion wie die doppelten Anführungszeichen "". Ein String wird immer mit der Art von Anführungszeichen beendet, mit der er begonnen wurde. Das bedeutet, dass die jeweils andere Form von Anführungszeichen im String wie ein normales Zeichen behandelt wird.
print('"The time has come," the Walrus said, "to talk of many things"')
Zweitens ist es in Python möglich, mehrzeilige Strings zu erzeugen, indem wir an Anfang und Ende der Zeichenkette nicht nur ein Anführungszeichen setzen, sondern drei. Einzelne Anführungszeichen innerhalb dieses Strings sind dann unproblematisch.
total_langer_string = """
"The time has come," the Walrus said,
"to talk of many things"
"""
print(total_langer_string)
Drittens können Anführungszeichen durch einen Backslash (Alt Gr + ß) escapet werden. Damit erkennt der Interpreter, dass das Zeichen direkt nach dem Backslash nicht als Anführungszeichen im Sinne von Programmcode behandelt werden soll, sondern nur als ein Zeichen innerhalb der Zeichenkette.
print("\"The time has come,\" the Walrus said, \"to talk of many things\"")
Der Backslash hat noch mehr Funktionen. Wir können ihn verwenden, um innerhalb von Strings Zeilenumbrüche ('\n') und Tabs ('\t') zu markieren:
print("If this be error and upon me proved,\nI never writ, nor no man ever loved.")
print("ottos mops \t kotzt")
Das Zeichen '\n' entspricht übrigens auch solchen Zeilenumbrüchen, die wir ganz normal getippt haben. Der folgende String enthält vier Zeilen (beachten Sie das dreifache Anführungszeichen an Start und Ende des Strings). Um ihn an jedem Zeilenumbruch zu zerteilen, rufen wir split() mit dem Separator "\n" auf:
print("""Am Grunde der Moldau wandern die Steine
Es liegen drei Kaiser begraben in Prag.
Das Große bleibt groß nicht und klein nicht das Kleine.
Die Nacht hat zwölf Stunden, dann kommt schon der Tag.
""".split("\n"))
Weil der Backslash diese Sonderfunktion erfüllt, muss er übrigens auch selbst escapet werden, wenn man ihn als bloßes Zeichen in einem String verwenden möchte. Wir schreiben dazu \\.
print("D:\\Studium\\01-WiSe2018\\Python")
Sowohl Strings als auch Listen sind Sequenzen, die aus einzelnen Elementen bestehen. Erinnern Sie sich an die for-Schleife vorhin, bei der wir jedes einzelne Element einer Liste verarbeitet haben. Auch durch Strings können wir mit so einer Schleife iterieren:
for c in "superlanger String mit mehreren Wörtern":
print(c)
Um ohne Schleife auf ein einzelnes Element der Sequenz zuzugreifen, können wir die Position in der Sequenz ansteuern. Dazu beginnen wir links beim ersten Element mit 0 und zählen nach rechts weiter. Den Index, den wir verwenden wollen, schreiben wir in eckige Klammern nach der Sequenz.
Wenn man vom Ende der Sequenz zählen möchte, verwendet man negative Zahlen: seq[-1] ist der letzte Index einer Sequenz, seq[-2] der vorletzte usw. Jedes Element der Sequenz kann also mit einem positiven Index oder mit einem negativen Index ausgewählt werden.
print("ABCDE"[0])
print("ABCDE"[-1])
print("ABCDE"[3])
print("ABCDE"[-2])
Noch nützlicher ist das Slicing, wobei wir Teilsequenzen aus der ursprünglichen Sequenz extrahieren können. Wir geben dazu den Startindex und den Endindex an, in der Form seq[start:end].
print("ABCDE"[0:1])
print("ABCDE"[0:0]) # leer
print("ABCDE"[-1:-3]) # leer
print("ABCDE"[-3:-1])
Der Startindex ist dabei Teil der extrahierten Sequenz, während der Endindex außerhalb der Teilsequenz liegt. Beachten Sie auch, dass Sie beim Verwenden negativer Indizes genau wie bei positiven Indizes die kleinere Zahl zuerst angeben müssen (siehe Beispiel oben).
Wenn die Teilsequenz am Anfang der ursprünglichen Sequenz beginnen oder am Ende der Sequenz enden soll, können Sie diesen Index einfach weglassen.
print("ABCDE"[:3])
print("ABCDE"[2:])
print("ABCDE"[:])
meine_liste = [1,2,3,4,5]
mein_string = "12345"
# Ihre Tests
Zahlen und Strings sind in Python immutable (unveränderlich). Das bedeutet, dass bei den Methoden z.B. für Strings als Ergebnis immer eine Kopie des Strings erzeugt wird. Der ursprüngliche String bleibt immer so, wie er definiert wurde. Wir können aber den Wert einer Variable manuell überschreiben, damit der String, der in der Variable gespeichert ist, sich ändert:
my_string = "Wer jetzt kein Haus hat, baut sich keines mehr"
print(my_string)
my_string.split() # split() zerteilt den String, aber das Ergebnis wird nicht ausgegeben oder gespeichert
print(my_string)
my_string = my_string.split() # Ergebnis der Operation in die Variable speichern - ACHTUNG: der Datentyp ändert sich
print(my_string)
Im Gegensatz dazu können Listen verändert werden, ohne dass man extra eine Kopie erstellen muss. Achtung: Diese Operationen haben daher keinen Rückgabewert. Wir dürfen also nicht den Wert der Variable überschreiben!
my_list = [1,2,3]
print(my_list)
my_list.append(4) # das Element 4 an die Liste anhängen
print(my_list)
my_list = my_list.append(5)
print(my_list)
Die folgende Tabelle enthält einige Operationen für Listen, die für uns wichtig sind.
| Operation | Auswirkung |
|---|---|
l.append(element) |
Das element wird ans Ende der Liste angehängt. |
l1.extend(l2) |
Ergänzt die Liste l1 um alle Elemente von l2 in der originalen Reihenfolge. |
l.insert(i, element) |
An der Position i in der Liste wird das element eingefügt. |
l.remove(element) |
Entfernt das erste Vorkommen von element aus der Liste (schlägt fehl, falls das Element nicht in der Liste enthalten ist). |
l.reverse() |
Dreht die Liste um. |
l.sort() |
Sortiert die Liste. Schlägt fehl, wenn Sortierung nicht möglich ist (z.B. wenn unterschiedliche Datentypen in der Liste enthalten sind). |
l.pop() |
Entfernt das letzte Element der Liste. Außerdem Rückgabe des letzten Elements. Schlägt fehl, wenn die Liste leer ist. |
l.pop(i) |
Entfernt das Element an Position i aus der Liste und gibt es zurück; schlägt fehl, falls die Position i in der Liste nicht existiert. |
element in l |
Rückgabe: Bool - True, wenn das element in der Liste enthalten ist; sonst False. |
min(l), max(l) |
Rückgabe des kleinsten bzw. größten Elements in der Liste. |
len(l) |
Rückgabe der Anzahl von Elementen in der Liste. |
l.count(element) |
Rückgabe: Integer - Anzahl der Vorkommen von element in der Liste. |
l.index(element) |
Rückgabe: Integer - Position des ersten Vorkommens von element in der Liste. Schlägt fehl, wenn das Element nicht in der Liste vorkommt. |
Zum Schluss noch eine Operation, die als Stringoperation definiert ist, die wir aber meist in Kombination mit Listen verwenden: join(). So wird join verwendet:
einzelne_woerter = ["Eis", "Schokolade", "Chips", "Kuchen"]
verbindungs_string = " +++ "
print(verbindungs_string.join(einzelne_woerter))
+ und +=¶Manchmal wollen wir eine Variable am Anfang eines Programms erzeugen und sie dann nach und nach verändern. Dafür können wir beispielsweise schreiben:
anzahl_elemente = 0
for zahl in range(10):
anzahl_elemente = anzahl_elemente + 1
Für diese Art von Anweisung, bei der die gleiche Variable einmal links und einmal rechts vom Zuweisungsoperator (=) steht, gibt es auch eine Kurzschreibweise:
anzahl_elemente = 0
for zahl in range(10):
anzahl_elemente += 1
Beide Anweisungen machen faktisch das gleiche. Sie können sich entscheiden, welche Schreibweise Ihnen besser gefällt.
Der Inhalt einer Variable kann sich im Laufe eines Programms verändern, zum Beispiel wenn wir wie in Übung 02-01 die Satzzeichen aus einem String entfernen. In solchen Fällen brauchen wir nicht für jede Zeile einen neuen Variablennamen. Tatsächlich kann eine Variable auch in einer einzigen Zeile verändert werden, wenn wir folgendes schreiben:
mein_string = "Nennt mich Ismael."
print(mein_string)
print("------")
mein_string = mein_string + " Als ich vor einigen Jahren – wie lange es genau her ist, tut wenig zur Sache – so gut wie nichts in der Tasche hatte und von einem weiteren Aufenthalt auf dem Lande nichts mehr wissen wollte, kam ich auf den Gedanken, ein wenig zur See zu fahren, um die Welt des Meeres kennenzulernen."
print(mein_string)
Sie haben heute gelernt,
for Befehle in Schleifen zu verpacken, die pro Element einer Sequenz einmal ausgeführt werdenif, elif, else Befehle nur unter bestimmten Bedingungen auszuführenIn der Übung am 27.10.2018 werden Sie den Umgang mit grundlegenden Datentypen üben und mit if-Blöcken und for-Schleifen die Abläufe in Ihrem Programm steuern.