Mit Schleifen arbeiten

Dank des Video-Tutorials von Diddy Development bleibe ich am Ball - er erklärt einfach sehr gut. Nun werden die verschiedenen Anweisungen kombiniert, z.B. die for-Schleife und die if-Anweisung.

Die Herausforderung lautet, das größte Element einer Liste ausgeben zu lassen. Ich gestehe, ich hätte es nicht geschafft.

Also hier kommt es, mit meinen Worten erklärt:

a = [3,6,89,15,5]

groessteZahl = 0

for element in a:
   if element > groessteZahl:
      groessteZahl = element

print (groessteZahl)

Ausgegeben wird die 89, sollte auch so sein.
Oh je - ich habe versucht, es erst mal allein hinzukriegen, keine Chance. Hier also die Erklärung:

Erst wird eine Liste (a) aus Zahlen definiert.
Die for-Schleife sorgt nun dafür, dass jedes Element der Liste der Reihe nach durchgegangen wird, angefangen mit dem ersten. Dann kommt die if-Schleife: Ist das erste Element größer als die zu Beginn definierte groesste Zahl (die hier auf 0 gesetzt wrurde), dann wird im nächsten Schritt die bisher größte Zahl (also die 0) durch das überprüfte Element ersetzt, in diesem Fall die 3. Dann wandert die for-Schleife zum nächsten Element, die if-Schleife vergleicht und ersetzt die 3 durch die 6. Im nächsten Durchgang die 6 durch die 89 - und dann ist Schluss, weil die beiden nächsten ja kleiner als 89 sind.
Alles klar?

Die Sache hat nur einen Haken: Was, wenn alle Elemente der Liste kleiner 0 sind, die Liste also aus lauter negativen Zahlen besteht? Dann wird die 0 ausgegeben - ist zwar nicht in der Liste, aber ja die größte Zahl, wie am Anfang definiert.

Besser wäre es also, die Schleifen würden jedes Element mit dem ersten vergleichen bzw. sich eines aus der Liste aussuchen.

Das geht so:

a = [-3,-6,-89,-15,-5]

groessteZahl = a[0]

for element in a:
   if element > groessteZahl:
      groessteZahl = element

print (groessteZahl)

Die Zahl in den eckigen Klammern nennt man wohl Index-Operator, sie gibt die Position des Elementes in der Liste an. Da man bei 0 anfängt zu zählen, ist es in diesem Fall das erste Element (die -3). Der Rest läuft ab wie oben: In diesem Fall werden alle Zahlen mit dem ersten Element verglichen. Man hätte auch a[4] nehmen können - funktioniert genauso, nur werden diesmal alle Elemente mit dem fünften verglichen. Es darf nur kein Index sein, der über der Anzahl der vorhandenen Elemente hinausgeht.

Wie gehabt - man muss es nur einmal verstanden haben. Womit ich nicht sagen will, dass es ab dann auch immer angewendet werden kann. Ist wie beim Vokabel-Lernen...

Achja, all das geht natürlich auch einfacher:

a = [-3,-6,-89,-15,-5]
print(max(a))

Womit wir auch die max-Anweisung kennen gelernt haben.

for - Schleifen

Noch ne Schleife (und ich habe natürlich immer noch keine wirkliche Vorstellung davon, was man damit mal anfängt). Aber egal.

Zuerst wird eine Liste erzeugt:

liste = [8,7,6,5,4]

Ich muss behalten: Listen setzt man in eckige Klammern!

for element in liste:
   print(element)

for und in gehören zusammen, der Rest ist von mir benannt. Bedeutet: Ob ist "liste" nun "liste" nenne oder "Apfel", ist egal. Statt "element" kann ich auch "Inhalt" nehmen. for ... in: (Doppelpunkt nicht vergessen) sorgt dafür, dass die Anweisung, die dann im Körper der Schleife kommt, für alles, was zwischen for und in gefunden wird, nacheinander ausgeführt wird. Alles klar? Mmmmmhhh....

Hier zur Anschauung:

Und weil ich wissen wollte, ob das mit dem Zeilenumbruch auch hier klappt, noch eine Ergänzung:

Klappt, das ist schön.

Noch ein schönes Beispiel:

# Die Länge von Zeichenketten ermitteln:
a = ['Club', 'Ferien', 'Weihnachten']
for x in a:
   print(x, len(x))

Hier nutze ich zum ersten Mal die Raute #
Damit kann man etwas in das Programm einfügen, dass von Python nicht interpretiert wird, also Kommentare ankündigen.

Und was passiert jetzt? Python ermittelt für jedes Element (x) der Liste (a) die Länge des jeweiligen strings. Fein.

Aber jetzt wird es für einen Laien schon schwieriger.

liste = [7,6,5,4,3]
summe = 0
for element in liste:
   summe = summe + element
print(summe)

Was Python hier macht:

Für jedes Teil (hier element) der Liste wird die Anweisung summe = summe + element ausgeführt. Am Anfang ist die Summe 0, also wird das erste Element (7) dazu addiert. Damit ist ja Summe = 7. Das Gleiche passiert also mit dem zweiten Elemnt, der 6, dann mit dem dritten usw. Am Ende, wenn 3 dazu addiert wurde, endet die for-Schleife, die Liste ist durchgearbeitet.
Die letzte Anweisung sagt, dass nun summe ausgedruckt wird. Macht 25. Perfekt.

Ich habe mich zuerst vertan und den print-Befehl eingerückt. Was dann passiert, hab ich aber auch kapiert, hier mal zum Nachdenken:

Das erklär ich jetzt nicht mehr ;-)

while - Schleifen

Es wird komplexer, und ich gestehe, dass ich beim ersten Durchgang hier schon meine Schwierigkeiten hatte (ist mir egal, wenn jetzt jemand die Augen verdreht).

Erst mal wieder eine Zahl definieren:

zahl = 0

Und nun die neue Anweisung, die zu einer Schleife (loop) führt - die while-Anweisung.

while zahl < 5:
   print(zahl)

Doppelpunkt nicht vergessen und die nächste Zeile einrücken.
Wenn man das ausführen lässt, erscheint eine 0 nach der anderen, und es hört überhaupt nicht mehr auf. Ich habe meine erste "Bewegung" am Rechner erzeugt. Cool irgendwie.

Warum passiert das? Die while-Anweisung sagt dem Interpreter, dass er den folgenden print-Befehl so lange ausführen soll, bis die Bedingung erfüllt ist. Da das nie passieren wird (zahl bleibt ja 0), gibt es also Nullen ohne Ende.
Aber wie stoppt man das?

Natürlich wäre ich da nie drauf gekommen. Indem man dafür sorgt, dass die Bedingung irgendwann erfüllt wird.

Das ist clever und geht so:

while zahl < 5:
   print(zahl)
   zahl = zahl + 1

und potzblitz: Es erscheinen die Zahlen 0 1 2 3 4

Wieso? Weil Folgendes passiert: Python erkennt, dass zahl kleiner 5 ist und gibt die 0 aus. Dann führt es die nächste Anweisung in dem Schleifenrumpf aus (wichtig: die Zeile muss genauso eingerückt sein wie die davor), addiert also zur 0 die 1. Springt an den Anfang und erkennt: Immer noch < 5, also wird die 1 ausgegeben, usw, bis die 4 erreicht ist. Wenn zahl 5 wird, endet die Schleife.
Alles klar :-)

Wo ich schon mal dabei bin, schaue ich mir noch mehr Beispiele an und stolpere wieder.

Erst mal das hier:

a = 0
b = 1
while b < 10:
  print(b)
  a = b
  b = a+b

Was ich noch verstehe. Zuerst wird die erste Anweisung im Rumpf ausgeführt (also die 1 ausgegeben), dann die zweite (a wird gleich b gesetzt und damit zu 1) und dann die dritte - a und b werden addiert, dann geht die Schleife von vorn los. Und da 2 kleiner 10 ist, wird nun die 2 ausggegeben. So geht es weiter, bis das Ergebnis so aussieht:
1
2
4
8

Was ich dann auch noch lerne: Man kann auch zwei Variablen gleichzeitig definieren, das nennt man eine Mehrfachzuweisung (multiple assignment):

a, b = 0, 1
while b < 10:
  print(b)
  a = b
  b = a+b

Das Ergebnis ist das gleiche.

Aber das hier verstehe ich noch nicht:

a, b = 0, 1
while b < 10:
  print(b)
  a, b = b, a+b

Wieso sieht das Ergebnis jetzt anders aus? Weil, so wird mir erklärt, die rechte Seite vom = Zeichen zuerst ausgewertet wird. Also:
Nach der Ausgabe print(b) - also die 1 - schaut Python nach rechts, addiert 0 und 1, damit bleibt b erst mal 1, dann wird aus a erst b (also 1). Damit wird die 1 wieder ausgegeben. Beim nächsten Durchgang ist ja a = 1, also ergibt a+b=2, somit wird die 2 ausgegeben.
Kompliziert? Ist es, zumindest für mich. Aber logisch...

Noch eine Kleinigkeit: Im Moment werden ja alle Zahlen untereinander ausgegeben. Das lässt sich verhindern, indem man die Anweisung end verwendet.

In die Anführungszeichen gibt man den string ein, der statt des Zeilenumbruchs zwischen die Zeichen soll. Bei "" kommen die ausgegeben Werte direkt hintereinander, bei " " mit einem Leerzeichen.
Einfach.

if, else und elif

Nun fängt es ein wenig an sich wie Programmieren anzufühlen. Ich kann dem Programm "Vorschriften" machen. Nämlich etwas zu tun, wenn eine bestimmte Bedingung erfüllt ist. Und etwas anderes zu tun, wenn eine andere Bedingung erfüllt ist.

Los geht es.

Erst einmal definiere ich eine Zahl:

Zahl = 7

Nun geht es mit einem neuen Befehl los, der if-Anweisung.

if Zahl < 5:
    print("Diese Zahl ist kleiner als 5")

Einfach, oder? Was gibt das Programm aus? Nix natürlich, weil die Zahl 7 ja nicht kleiner als 5 ist.
Aber die Anweisung ist klar: Das Programm prüft, ob die Variable "Zahl" der Bedingung entspricht. Wichtig ist der Doppelpunkt. Und dass der print-Befehl eingerückt wird. Ansonsten kommt eine Fehlermeldung. Nach Bedingungen wird immer eingerückt.

Und schon kommt die nächste Anweisung, nämlich "else".

if Zahl < 5:
    print("Diese Zahl ist kleiner als 5")
else:
   print("Diese Zahl ist größer oder gleich 5")

Und schon klappt es: Der zweite string wird ausgegeben. Versprochen. Was python macht: Es prüft zuerst die erste Bedingung, die if-Anweisung. Da diese nicht zutrifft, geht es zu nächsten über, zur else-Anweisung. Wenn das eine nicht zutrifft, dann mach eben das andere. Also immer, wenn die Bedingung vorher nicht zutrifft, wird else ausgeführt.

Und weil es so schön ist, hier gleich noch eine Anweisung: "elif" (das heißt in anderen Programmiersprachen "else if")

if Zahl < 5:
   print("Die Zahl ist kleiner als 5")
elif Zahl < 10:
   print("Die Zahl ist kleiner 10 und größer 5")
else:
   print("Die Zahl ist größer oder gleich 10")

Klar, was hier passiert? Python prüft Anweisung if, die passt nicht. elif aber trifft zu, als kommt der zweite Satz. Ersetze ich nun die Zahl 7 durch 12, dann kommt Python schließlich bei else an und gibt den dritten Satz aus.
Nach else ist Schluss (weil das immer ausgeführt wird, wenn alles andere nicht zutriftt), aber elif kann man so oft wie man will einbauen, also z.B. so:

if Zahl < 5:
   print("Die Zahl ist kleiner als 5")
elif Zahl < 10:
   print("Die Zahl ist kleiner 10 und größer 5")
elif Zahl < 16:
   print("DIe Zahl ist kleiner 16 und größer 10")
else:
   print("Die Zahl ist größer oder gleich 16")

Ändere ich Zahl in 15, kommt der dritte Satz, ändere ich Zahl in 16, kommt der vierte Satz.

  

Keine Sorge, so locker, wie ich das hier hingeschrieben habe, war das beim Erarbeiten nicht, habe ziemlich herumgespielt. Aber immerhin...

input und type

Jetzt wird es tatsächlich etwas interessanter. Einfach nur irgendwelche Befehle ausführen lassen, ohne zu verstehen, wozu das mal gut sein soll, macht auf Dauer nicht glücklich. Aber jetzt lerne ich grade, wie man ein Programm schreibt, mit dem man anschließend etwas machen kann.

Also zuerst wird mal wieder eine Variable definiert:

Eingabe1 = input("Geben Sie die erste Zahl ein: ")

input sorgt dafür, dass das Programm nach dem string stehenbleibt und auf eine Eingabe wartet.

Eingabe1 = input("Geben Sie die erste Zahl ein: ")
Eingabe2 = input("Geben Sie die zweite Zahl ein: ")

Hier habe ich in der SHELL die erste Zahl eingegeben, auf Enter gedrückt und das Programm läuft weiter, es fordert die zweite Zahl.

Nun müsste ich ja mit diesen Zahlen rechnen können, und prompt führt mich mein Tutor auf eine falsche Fährte:

Summe = Eingabe1 + Eingabe2
print(Summe)

Das funktioniert nicht, ausgegeben werden die beiden Zahlen einfach nebeneinander. Sie werden aneinandergereiht, und ich lerne einen neuen Begriff. Man nennt das konkatinieren. Warum? Weil ich zwei strings addiert habe.

Was ist also zu tun? Ich muss dem Programm irgendwie mitteilen, dass ich vom Datentyp string zum Datentyp integer (int) wechseln möchte.

Eingabe1 = int(input("Geben Sie die erste Zahl ein: "))
Eingabe2 = int(input("Geben Sie die zweite Zahl ein: "))

Und schon funktioniert es. Yeah!

Hier passt übrigens ein Befehl ganz gut, der mir zwischendurch schon erklärt wurde: type

Damit kann man sich den Datentyp anzeigen lassen, also

print(type(Eingabe1) zum Beispiel. Dann wird mir im ersten Fall der type class 'str' und im zweiten Fall class 'int' ausgegeben.

Kann man bestimmt noch oft gebrauchen.

Listen 2

Noch etwas zu Listen - man kann diese ändern. Das geht bei Zeichenketten (strings) nicht. Bedeutet: Eine einmal definierte Liste ist also veränderbar, wie man das an diesem Beispiel sehen kann.

x[3] = x[3] + 23
print(x)

Wie man sieht, ist das vierte Element der Liste nun nicht mehr 100, sondern 123. Cool.

Man kann auch Slices nutzen, um Elemente zu ersetzen oder einzufügen:

Aber ich lerne heute noch mehr, z.B. die eingebaute Funktion len - die von length kommt und die Länge eines strings oder einer Liste ausgibt:

print(len(x))

ergibt für diese Liste x = ["Eier", "Ball", 67, 100, 1234]  den Wert 5

Listen

Nun kommt noch ein Datentyp, der vermutlich wirklich häufiger zum Einsatz kommt  (aber das ist alles nur Mutmaßung, ich habe nach wie vor keine Ahnung, was man mit all diesen Datentypen macht).

Es geht um die Liste. Diese wird in eckigen Klammern eingegeben, jeder Wert wird durch Kommata getrennt.

x = [3, 67, 100, 1234]
print(x)

Ausgegeben wird die Liste: [3, 67, 100, 1234]
Man kann auch strings in die Liste packen, z.B. so:

x = ["Eier", "Ball", 67, 100, 1234]
print(x)

Hier das Ergebnis:



Nun sind mit Listen alle möglichen Spielereien, sprich: Kombinationen möglich, ich spiele also mal herum:

print(x[1])

Nun müsste eigentlich Ball ausgegeben werden - funktioniert. Warum? Weil die Zahl in der eckigen Klammer das Zeichen in der Liste ausgibt, das an zweiter Stelle steht (wohlgemerkt: Man fängt mit 0 an zu rechnen).

print(x[2:])

Damit müstte 67, 100, 1234 ausgegeben werden, weil ja alles ab dem dritten Zeichen angezeigt wird. Passt.

print(x[:3] + 3/2)
Nun müsste Folgendes auftauchen: Eier, Ball, 67, 1.5

Denkste, ich hab einen Fehler gemacht, weil ich wohl nur Listen miteinander verknüpfen kann. Es kommt eine Fehlermeldung.

Also neu:
print(x[:3] + [3/2])

Was passiert? Das hier: ['Eier', 'Ball', 67, 1.5]

Geht doch ;-)

Und noch eins:

print(3*x[:2] + ['Wow!'])

Damit sollten die ersten beiden Worte der Liste dreimal auftauchen plus Wow!

Und siehe da:

Ich mache viele Fehler, aber es werden weniger ;-)

Boolean

Wieder was Neues gelernt - es geht um einen weiteren Datentyp, der nur zwei Werte annehmen kann, nämlich wahr oder falsch. Den nennt man Boolean. Ein boolescher Wert stellt einen also Wahrheitswert dar, er besagt, ob ein Sachverhalt wahr ist oder nicht. Wozu ich das später brauche, weiß ich noch nicht, aber außer strings, integer und float kenne ich also nun noch einen Datentyp.

Den gibt man so aus:

wahrfalsch = True
print(wahrfalsch)

Dann erscheint True. Das ist ein fester Begriff und er muss mit einem Großbuchstaben beginnen, ebenso sein Gegenwert, False.

Das ist mal ein kurzes Kapitel - wie gesagt, ich ahne, dass das mal wichtig wird, aber im Moment erschließt sich mir der Nutzen des Datentyps noch nicht.

Datenyp Zahl

Bisher habe ich also Strings kennengelernt, aber es gibt noch andere Datentypen. Zum Beispiel  Zahlen.

Es geht los mit dem Definieren einer Variablen - und schon wieder ein neuer Begriff: Initialisieren. Das bedeutet nichts anderes als einer Variablen einen Wert zuordnen.

Zum Beispiel so:
Zahl = 5

Also: Strings werden durch die Anführungszeichen erkannt, bei Zahlen fehlen diese.

Es gibt zwei Arten von Zahlen: Ganze Zahlen, auch integer genannt, und Komma-Zahlen, auch float genannt. Diese müssen allerdings wie im Englischen immer mit einem Punkt geschrieben werden:
Kommazahl = 5.3583492

integer und float sind wie strings Datentypen, auch wohl class genannt.

Wenn man sich diese nun ausgeben lassen will, geschieht das wieder mit dem print-Befehl gemacht:

print(Zahl)
print(Kommazahl)

Hat geklappt, wer sagt's denn.

Mit den Zahlen kann man nun rechnen und Python als Taschenrechner benutzen.

Dazu braucht man + für addieren, - für subtrahieren, * für multiplizieren und / für dividieren.

So etwas nennt man wohl Operator, davon gibt es einige, ich füge sie hier mal ein, wer weiß, wann ich sie gebrauchen kann:

Operator	Bedeutung
()	Gruppierung
x[], x.attribute	Listenzugriff, Objekteigenschaft
**	Potenz
+ und -	Positives beziehungsweise negatives Vorzeichen einer Zahl
*, /, //, %	Multiplikation, Division, Ganzzahl-Division, Rest (Modulo)
<=, <, >, >=	Wertevergleich (kleiner als oder gleich, kleiner als, größer als oder gleich, größer als)
==, !=	Wertevergleich (ist gleich, ist nicht gleich)
=, +=, -=, *=, /=, %=, **=	Wertezuweisung
is, is not,	Identitätsvergleich
in, not in	Test auf Mengenzugehörigkeit
and, or, not	Logische Operatoren

Da ich jetzt weiß, dass man erst mal eine Variable definieren muss, lege ich los:

Summe = 2 + 9
print(Summe)

Funktioniert, versprochen.
Ebenso das hier:

Produkt = 4*75
print(Produkt)

Davon mache ich jetzt mal keinen Screenshot, das ist selbsterklärend. Aber vielleicht hiervon:

Ergebnis = (3*8)/7
print(Ergebnis)

Weil man hier erkennt, dass der Taschenrechner wirklich funktioniert und auch Kommazahlen auswirft.
Möchte man das bei einer Division nicht, dann geht das auch, und zwar so:

GanzZahl = 18//7
print(GanzZahl)

dann erscheint die 2  - weil die 7 zweimal in die 18 passt (es wird also nicht aufgerundet)

Apropos auf- und abrunden:
Man kann Python auch mitteilen, dass er die Kommastellen begrenzen soll, und zwar mit round. Allerdings wird hier auch immer nur abgerundet.

Ich hab mal ein Beispiel gebastelt, das mich viel Zeit gekostet hat.

Aber nun ist es klar: round(Zahl, 2) lautet die Formel, wenn man auf zwei Kommastellen verkürzen will. Was mich u.a. Zeit gekostet hat: Wenn ich das ausgeben will mit print, muss ich um das Ganze noch mal Klammern setzen. Was für ein Anfängerfehler. Genug für diesmal...

Strings 3

Bei den folgenden Erkenntnissen weiß ich wirklich nicht, wozu sie einmal gut sein werden, aber ich vermute, ich werde sie brauchen. Es geht immer noch um Zeichenketten, diesmal um die Kunst sie zu verknüpfen.
Was ganz einfach ist - mit einem +
Beispiel:

Wort = 'Hilf' + 'mir'
print(Wort)

Dann wird Hilfmir ausgegeben. Super, funktioniert.

Man kann die Zeichenketten auch multiplizieren.

Gibt man also als nächten Befehl Folgendes ein:

print(Wort*3)

dann erscheint HilfmirHilfmirHilfmir

Witzig...

Weiter geht es mit dem Indizieren von Zeichenketten. Schluck - was heißt das jetzt schon wieder? So ganz kapiere ich es nicht, weiß aber jetzt, wie es funktioniert.

Also:
Ein Wort oder besser ein String besteht aus einer Anzahl von Zeichen, die von links nach rechts gezählt werden, wobei in den Programmiersprachen es immer mit 0 losgeht.

Nehme ich als das oben definierte Wort (Hilfmir) und gebe Folgendes ein:
print(Wort[4]) -
dann müsste mir die SHELL das m ausgeben - weil es eben mit 0 für das H losgeht.

 

Klappt :-)

Mit eckigen Klammern, so habe ich schon gelesen, werden Listen umschlossen, da hoffe ich, bald mehr zu erfahren.

Vorher aber noch zwei Infos:

Mit Wort[1:3] werden die Zeichen 1 bis 3 ausgegeben.

Und Mit Wort[:4] alle Zeichen bis zum vierten, mit Wort[5:] alle Zeichen ab dem fünften.

Das nennt man Slicing. Wieder was gelernt. Aber irgendwie stimmt da was nicht - wieso werden bei [1:3] nur zwei Zeichen ausgegeben? Dazu muss man sich wohl das hier merken:

Die Indizes sitzen praktisch zwischen den Zeichen - ausgegeben wird also alles zwischen 1 und 3.

Nun denn - zuletzt noch die Kombination aus dem Gelernten. Was passiert, wenn man Folgendes eingibt:
print(Wort[:4] + "dir selbst")

Genau - das ergibt Hilf dir selbst. Passt!

 

Strings 2

Es hat mich gepackt und trotzdem frage ich mich zwischendurch, was ich da tue. Ich kann also jetzt einem Computer sagen, dass er einen Text anzeigen soll - das konnte ich schon vorher. Aber mal abwarten, ich will nicht ungeduldig werden ;-)

Es geht noch etwas weiter mit den strings. Ich hatte offenbar noch nicht verstanden, was ein Backslash am Ende einer Zeile bedeutet. Er maskiert den Absatz, denn in dem Moment, in dem ich in einer Zeichenkette die Return-Taste betätige, wird der String unterbrochen - genau das verhindert der Backslash.

Ein \n hingegen bedeutet, dass ein Zeilenumbruch ausgegeben wird, der nächste \ schaltet den Umbruch im Code aus.

Schreibe ich also:

Text = "Das ist ein langer Text, der an dieser Stelle \n
in die nächste Zeile wechseln soll "

geht das schief. Es muss so aussehen:

Text = "Das ist ein langer Text, der an dieser Stelle \n\
in die nächste Zeile wechseln soll"

Yeah...

Nun glaube ich das auch mit dem raw-String zu verstehen. Mit einem r vor dem string wird der Text so wie im Code dargestellt - incl. z.B. des Backslash:

Text = r"Das ist ein langer Text, der an dieser Stelle \
in die nächste Zeile wechseln soll"
print(Text)

Strings

Ein String ist also ein ganz bestimmte Datentyp. Besser gesagt: Eine Zeichenkette. Das ist eine neue Erkenntnis: Ein Wort ist ja nichts anderes als eine Kette von Zeichen. Ich suche ein wenig im Internet herum und finde weitere Tutorials, zum Beispiel dieses hier. Und dort erfahre ich so einiges über Zeichenketten. Ich experimentiere damit herum und verzweifle schnell wieder, weil die Macher wohl etwas voraussetzen, über das ich nicht verfüge. Hier meine Versuche:

Ich lerne, dass man ein Zeichen "maskieren" kann, und zwar mit dem Backslash. Den findet man auf meiner Apple-Tastatur nicht so leicht (Shift-alt-7), aber er funktioniert nicht. Ich recherchiere im Internet und finde, dass andere das gleiche Problem haben. Der Python-Editor kann das nicht :-(
Ich kopiere mir den Backslash \ also und füge ihn vor dem einfachen Anführungszeichen ein. Damit wird offenbar bewirkt, dass er nicht als das Ende des strings interpretiert und mit ausgegeben wird.
Wieder was gelernt.

Weiter geht es, die nächsten Versuche:

Statt das einfache Anführungszeichen zu maskieren, kann ich den ganzen string auch in doppelte Anführungszeichen setzen, das funktioniert das einfache im Text wie ein normales Zeichen. Wunderbar.
Umgekehrt klappt das genauso: Den string in einfache Anführungszeichen, das doppelte im Text wird ausgegeben. Und wenn ich alles in doppelte Anführungszeichen setze, muss ich die doppelten im Text maskieren. (Übrigens: In dem Tutorial sind einige Fehler, die mich dann auch wieder verzweifeln lassen - aber vermutlich lernt man auch dadurch.

Dann machen wir mal gleich weiter mit den tollen Zeichenketten. Wie erzeugt man einen Zeilenumbruch?

Indem man an dieser Stelle mit \n\ abschließt, dadurch wird eine neue Zeile erzwungen.
Ein einfacher \ hingegen sagt nur, dass die nächste Zeile direkt angehängt werden soll.
Zwei weitere Dinge lehrt mich dieses Beispiel: Hier wird eine Variable definiert, nämlich mit hallo = "..." Dann muss ich am Ende nur print(hallo) eingeben, um diese Variable auszugeben.
Zweite Erkenntnis: Leerzeichen am Anfang einer Zeile haben eine Bedeutung - bei strings offenbar die, dass sie mit ausgegeben werden.

Und als letztes für heute (mir brummt der Schädel): Man kann auch Python mitteilen, das es den string genauso ausgeben soll, wie man ihn eingegeben hat - indem man die Anführungszeichen verdreifacht:

Ganz witzig, habe ich erst gar nicht verstanden: Die erste und die letzte Zeile erscheint als Leerzeile (es wird ja alles so ausgegeben, wie eingetippt). Wenn man keine Leerzeilen am Anfang und Ende haben möchte, muss man diese aus maskieren:

So, wirklich genug für heute. Bis bald.

Der Anfang

Ich bin 60 Jahre alt. Ein gutes Alter, um Programmieren zu lernen? Vermutlich nicht, denn die Anfänge sind schon unglaublich mühsam. Zumindest, wenn man nicht die geringste Ahnung hat.

Warum tue ich mir das an? Aus Neugier vielleicht. Stimmt nicht ganz. Ich bin seit Jahren im Internet aktiv mit einer eigenen Seite. Dadurch habe ich einige Grundkenntnisse in HTML. Aber wirklich nur die absoluten Grundkenntnisse, das Erstellen einer Tabelle überfordert mich bereits. Seit Jahren rede ich davon, dass es mich reizen würde, Programmieren zu lernen. Aber beim Reden blieb es. Bis jetzt.

Beim Besuch einer großen Buchhandlung stöberte ich wie schon häufiger in der Abteilung "Informatik" in den Programmierbüchern für Anfänger. Und wie immer stand ich bereits auf den ersten Seiten der Bücher auf dem Schlauch. Die meisten verwendeten auf den ersten Seiten Begriffe, die mir fremd waren. Womit klar war, dass Programmieren lernen nicht weniger bedeutet als eine neue Sprache zu lernen. Aber wie soll ich eine solche lernen, wenn die Erklärungen schon in der Sprache verfasst sind, die ich (noch) nicht verstehe?

Ein Buch, das mir in die Hände fiel, handelte von Python. Das soll eine Sprache sein, die auch für Anfänger leicht zu lernen ist. Ob's stimmt?
Zu Hause gab ich den Namen bei Google ein und fand auf Youtube ein Tutorial (übrigens ziemlich gut gemacht, sonst hätte ich wohl schnell wieder aufgegeben), das tatsächlich bei Null anfing. Zumindest fast. Es fällt auf, dass Programmierer, die anderen erklären, wie man Programmieren lernt, gar nicht mehr selbst merken, dass sie in der Sprache reden, die sie vorgeben vermitteln zu wollen.

Tapfer startete ich mit den ersten Lektionen. Wobei ich zunächst erfuhr, dass man Python herunterladen muss (zum jetzigen Zeitpunkt die Version 3.6.4.) Was das bedeutet? Wusste ich schon nicht, aber machte ich tapfer.
Was dann alles auf meinem Rechner installiert wird, ist mir immer noch nicht ganz klar, vielleicht erschließt sich mir das später. 

Man erhält zu Python eine IDE - das steht für Integrated Development Environment - mit Namen IDLE, und wenn man dieses Programm öffnet (soviel Computerkenntnisse habe ich dann doch, dass ich Programme herunterladen und öffnen kann), dann tun sich ein Fenster auf - die SHELL. Schon wieder ein Fachbegriff, hier mal eine erste Abbildung, wie sowas aussieht:

Erste Verwirrung - was bedeutet die Warnung? Offenbar nichts, was für mich von Belang ist, also weiter.

Die Shell sieht aus wie ein einfaches Textprogramm, aber das Besondere an diesem Programm ist, dass es den Code (den ich ja lernen will) nach dem Eintippen sofort umsetzt (oder in der Fachsprache: interpretiert). Deshalb scheint man hierzu auch "Interpreter" zu sagen.

In diese Shell kann man also Befehle, sprich: Computercode eingeben. Die SHELL versteht ganz einfache Befehle, zum Beispiel 3 + 5. Eingeben und auf ENTER drücken - das Ergebnis erscheint. Ich bin noch nicht sonderlich beeindruckt, aber immerhin: Man kann mit Python rechnen. Ahne ich schon, dass Programmieren viel mit Mathematik zu tun hat?

Wozu braucht man so eine SHELL? Offenbar kann ich damit ja kein Programm schreiben, speichern und dann ausführen lassen? Es ist offenbar eine Art "Teststrecke". Ich geben einen Code ein und schaue, ob er funktioniert.
Ich lerne hier gleich auch noch einen Begriff (den ich im tiefsten Innern aus der Mathematik meiner Schullaufbahn kenne): Variable. Variablen kann man definieren, z.B. so:
a = 7  Mit dem Gleichheitszeichen sage ich meinem Computer, was a bedeutet.
Und wenn ich dann in die nächste Zeile der SHELL das hier eingebe:
15 - a und auf ENTER drücke, wird mir die 8 angezeigt.

Auch noch nicht wahnsinnig spannend, aber vielleicht mal an dieser Stelle eine kurze Erklärung, warum ich all das hier aufschreibe. Ich tu's in erster Linie für mich selbst. Weil ich fürchte, dass ich ganz viel ganz schnell vergessen werde und auf diese Weise nachvollziehen kann, was ich schon "weiß".
Und wer weiß - vielleicht gibt es ja irgendwo noch einen völlig Unbedarften wie mich, der auch den Versuch starten möchte. Dann hätte ich die Hoffnung, dass meine absolut laienhaften Erläuterungen den Einstieg erleichtern. Mal schauen, wie weit ich komme.

Nun denn, wie und womit schreibe ich jetzt mein erstes eigenes Programm? Dazu hat IDLE ein eigenes Werkzeug, das wie ein schlichtes Textprogramm daherkommt - mit dem Unterschied, dass die hier erzeugten Dateien mit der Endung .py abgespeichert werden - eben Python-Dateien.

Ich klicke also auf "File" und dann auf "New File", der Editor öffnet sich und darin kann ich nun loslegen. Vorher lege ich mir irgendwo auf einem Rechner einen neuen Ordner an, in dem ich alle meine schönen neuen Programme ablegen kann (und nenne ihn einfach mal "Python").

Das erste Programm nenne ich Test und speichere es leer ab. Ach ja, so sieht der Editor aus (hier noch sehr leer):

Es geht also los - ich fange an zu programmieren und lerne eine erste Funktion kennen, die print-Funktion. Bedeutet nichts anderes als dem Intepreter mitzuteilen, dass er einen Befehl ausführen soll.

Zum Beispiel diesen hier: print("Hallo Ihr da draußen")

Und ich erfahre, dass print klein geschrieben werden muss, der Text, der ausgeführt werden soll, in Klammern gehört und vor allem: In Anführungszeichen. Egal, ob doppelte ("Text") oder einfache ('Text').

Und nun? Nun muss ich die Datei speichern und ausführen, und das mache ich, indem ich auf "Run" und dann auf "Run Module" klicke. Ich starte also mein erstes Modul.

Was passiert? In der SHELL wird tatsächlich der Satz "Hallo Ihr da draußen" angezeigt. Ohne die Anführungszeichen. Was ich in dem Moment noch nicht weiß, aber bald lerne: Ich habe einen string programmiert, so nennt man den Datentyp, der in Anführungszeichen in den Klammern steht.
Juhu - ein Fachbegriff, ich komme voran.

Achja, noch was: Ich kann also einem Programm sagen, das anzuzeigen, was ich vorher eingetippt habe - nicht wirklich bahnbrechend, ABER: Das soll erst der Anfang sein, ich brauche Geduld.