1. Übung

Beispiel 1.1

Aus der Theorie wissen wir, dass wir in der Informationsverarbeitung 2 Dinge brauchen:

  1. Daten, die wir als Eingangs-Daten verarbeiten und als Ausgangs-Daten als Ergebnis liefern

  2. Verfahren (auch Algorithmen genannt) zur Verarbeitung der Daten

Im ersten Beispiel wollen wir ein paar Datenelemente definieren und diese anschliessend auf der Konsole augeben:

 1# Zunächst weisen wir den Datenelementen Werte zu ...
 2a = 42                  # ein Integer-Datenwert
 3b = 3.14                # ein Float-Datenwert
 4c = True                # ein Boolescher Datenwert
 5d = 'Python ist toll!'  # ein String-Datenwert
 6
 7# ... und dann geben wir die Daten mit dem print()-Verfahren aus
 8print(a)
 9print(b)
10print(c)
11print(d)

Wir können den Code einfach mit dem Clipboard-Symbol, das rechts oben erscheint, wenn wir die Maus dorthin bewegen, kopieren und in die Entwicklungsumgebung einfügen. Anschließend speichern wir dann die Datei unter dem Namen 'example_1_1.py' ab und führen Sie diese in der Konsole aus (in gleicher Weise verfahren wir mit den weiteren Beispielen und Aufgaben):

$ python example_1_1.py

Mit diesem Aufruf übergeben wir unser Python-Programm an den Python-Interpreter. Dieser arbeitet die Programmanweisungen zeilenweise von oben nach unten ab. Wir sehen, dass die Werte, die wir den Datenelementen zugewiesen haben, zeilenweise ausgegeben werden. Damit haben wir gerade unser erstes Python-Programm geschrieben und ausgeführt!

Bislang haben wir allgemein von Datenelementen gesprochen. In der Programmierung werden Datenelemente in unterschiedlichen Rollen verwendet. In der Rolle, wie wir sie verwenden, bezeichnet man sie als Variablen. Dieser Ausdruck ist der Mathematik entlehnt, in der eine Variable einen Platzhalter für einen noch nicht bestimmten Wert bezeichnet. Entsprechend bezeichnet man einen Ausdruck wie 'print(x)' als eine Funktion ähnlich wie 'sinus(x)', 'log(x)' oder allgemein 'f(x)' Funktionen im Sinne der Mathematik darstellen. Wir werden den Umgang mit Variablen und Funktionen gleich noch weiter vertiefen.

Die Bezeichnungen der Variablen mit 'a', 'b', 'c' und 'd' ist reichlich knapp und beliebig. In der Regel sollte man Variablen aussagefähigere (und damit i.d.R. längere) Namen geben.

Wichtig

Variablen- und Funktionsbezeichnungen dürfen aus den Buchstaben 'A'-'Z' und 'a'-'z', den Ziffern '0'-'9' sowie Unterstrichen '_' bestehen. In Python gibt es darüberhinaus weitere Konventionen zur Benennung, die teilweise bindend sind, teilweise auch nur zur besseren Verständlichkeit des Codes üblich aber nicht verpflichtend sind. Diese Konventionen werden wir später kennenlernen.

Interessant an der Ausgabe ist noch, dass wir den Variablen Werte aus ganz unterschiedlichen Wertemengen zugewiesen haben. Diese Werte werden (ohne das uns dies im Detail interessieren muss) im Rechner in unterschiedlicherweise repräsentiert und verarbeitet. Es macht nämlich sehr wohl einen Unterschied, ob ich zwei ganzzahlige Integer-Werte addiere, zwei Fließkomma-Werte addiere und erst recht zwei Zeichenketten (Strings) addiere! Ebenfalls interessant ist, dass die verwendete 'print()'-Funktion ganz offensichtlich weiß, von welchem Datentyp die auszugebenden Werte sind und wie diese auszugeben sind.

Wichtig

Python erkennt bei der Zuweisung eines Wertes an eine Variable den Datentyp des Wertes und merkt sich diesen zusammen mit dem Wert selber unter dem Namen der Variablen. Bei Übergabe einer Variablen an die 'print()' kann diese dann ebenfalls einfach erkennen, welchen Datentyp der unter dem Namen der Variablen gespeicherte Wert hat und so die Ausgabe entsprechend steuern.

Wir wollen noch etwas bei unserem obigen Beispiel bleiben und die Ausgabe etwas modifizieren. Dazu ändern wir den Code etwas ab:

1# Zunächst weisen wir den Datenelementen Werte zu ...
2a = 42                  # ein Integer-Datenwert
3b = 3.14                # ein Float-Datenwert
4c = True                # ein Boolescher Datenwert
5d = 'Python ist toll!'  # ein String-Datenwert
6
7# ... und dann geben wir die Daten mit dem print()-Verfahren aus
8print(a,b,c,d)

Wir geben jetzt die 4 Variablen mit einem einzige Aufruf von 'print()' aus. Wenn wir unser Beispiel ausführen, sehen wir, dass nunmehr alle Werte in einer Zeile ausgegeben werden.

Wir können die Ausgabe aber durch Hinzufügen von erläuterndem Text noch etwas verständlicher machen, indem wir Zeile 8 wie folgt erweitern:

print('Ein Integer-Wert=',a,'Ein Float-Wert=',b,'Ein Boolescher Wert=:',c,'EinString-Wert=',d)

Und wenn wir doch lieber jeden Wert in einer separaten Zeile ausgeben möchten, müssen wir dazu nicht wieder 4 verschiedene Aufrufe von 'print()' einfügen, sondern fügen einfach nach jeder Ausgabe einen Zeilenvorschub '\n' (n=newline) ein.

print('Ein Integer-Wert=',a,'\nEin Float-Wert=',b,'\nEin Boolescher Wert=:',c,\nEin String-Wert=',d)

Die Kombination '\n' bezeichnet man als sog. 'Esacpe-Sequenz'. Diese werden durch einen '\' eingeleitet, welcher der 'print()'-Funktion signalisiert, dass das nachfolgende 'n' nicht als Zeichen auszugeben ist, sondern eine Anweisung zur Formatierung der Ausgabe darstellen soll. Neben 'n' gibt es weitere Esacpe-Sequenzen, die wir bei Gelegenheit kennenlernen werden.

Beispiel 1.2

Natürlich können wir mit den unseren in Variablen gespeicherten Daten auch Operationen durchführen ("Rechnen"):

 1#-----------------
 2# Addition eines festen Wertes zur Integer-Variablen a
 3a = 42
 4a = a + 73
 5print('a =', a)
 6#-----------------
 7# Addition der Float-Variablen a und b und Zuweisung an c
 8a = 3.1415
 9b = 1.2345
10c = a + b
11print('c =', c)
12#-----------------
13# Addition einer Float- und einer Integer-Variablen und Zuweisung an c
14a = 3.0
15b = 2
16c = a + b
17print('c =', c)
18#-----------------

Bemerkenswert ist hier bei der dritten Rechnung der Datentyp des Ergebnis. Bei der Addition von 3.0 und 2 kommt eine glatte 5 als Ergebnis heraus, der Ergebniswert hätte also ohne Probleme in einer Integer-Variablen gespeichert werden können. Standardmäßig speichert Python das Ergebnis einer Rechnung aber im allgemeineren der beteiligten Datentypen und das ist in diesem Fall der Float-Wert.

In diesem Fall können wir anhand der Print-Ausgabe in der Form '5.0' einfach schließen, dass es sich um eine Float-Variable handelt. Python stellt aber auch einen Befehl bereit, mit dem wir den Datentyp einer Variablen direkt feststellen können:

# Addition einer Float- und einer Integer-Variablen und Zuweisung an c
a = 3.0
b = 2
c = a + b
print('c =', c)
print(type(a), type(b), type(c))

Wenn wir erzwingen möchten, dass das Ergebnis einer Operation einen bestimmten Datentyp hat, gehen wir so vor:

#-----------------
# Addition einer Float- und einer Integer-Variablen und Zuweisung an c als Integer-Wert
a = 3.0
b = 2
c = int(a + b)
print('c =', c)
print(type(a), type(b), type(c))
#-----------------
# Addition zweier Integer-Variablen und Zuweisung an c als Float-Wert
a = 42
b = 73
c = float(a + b)
print('c =', c)
print(type(a), type(b), type(c))
#-----------------

Wie mag es aber bei Operationen mit den Boolescher Werten oder String-Werten aussehen?

 1#-----------------
 2a = True
 3b = False
 4c = a + b
 5print('c=', c)
 6#-----------------
 7a = True
 8b = False
 9c = True
10d = a + b + c
11print('d =', d)
12#-----------------

Wie wir sehen, werden die Operationen von Python (ohne einen Fehler zu melden) durchgeführt, es ergeben sich aber keine Booleschen Werte als Ergebnis. Dies ist insofern konsequent als Operationen wie '+', '-', '*' und '/' für Wahrheitswerte nicht definiert sind. Python geht in diesem Fall 'pragmatisch' vor und wandelt den Wert 'True' in den numerischen Wert '1' und 'False' in '0' um und führt dann die Operationen durch. Das Ergebnis ist dann natürlich auch ein Integer-Wert und wird nicht in einen Booleschen Wert zurückumgewandelt.

Um logische Operationen durchzuführen gibt es Operationen wie 'and', 'or' oder 'not':

 1#-----------------
 2a = True
 3b = False
 4c = a and b
 5print('c =', c)
 6#-----------------
 7a = False
 8b = False
 9c = True
10d = a or b or not c
11print('d =', d)

Auch hinsichtlich der Verarbeitung von Zeichenketten (Strings) geht Python pragmatisch vor und definiert die (eigentlich mathematischen) Operationen auch für Strings, die intuitiv sinnvoll erscheinen:

1s1 = 'Ich'
2s2 = 'bin'
3s3 = 'hier'
4
5s_result_1 = s1 + ' ' + s2 + ' ' + s3
6print('String-Addition: ', s_result_1)
7
8s_result_2 = s1 - s2
9print('String-Subtraktion:', s_result_2)

Bei der Aufruf der nicht definierten String-Subtraktion sehen wir auch, was Python in diesen Fällen macht. Es zeigt uns eine Fehlermeldung und bricht das Programm ab. Im eigentlichen Sinn passiert im Hintergrund noch mehr, denn Python löst bei nicht definierten Operationen (z.B. auch bei einer Division durch 0) eine sog. 'exception' aus. Diese 'exception' könnten wir programmtechnisch abfangen, was wir hier nicht gemacht haben, sondern erst später kennenlernen werden.

Aufgabe 1.1

Zur Abwechslung gibt es jetzt eine erste kleine Aufgabe für Sie. In dem folgenden kleinen Code-Block werden verschiedene Varianten des Divisionsoperators verwendet. Im ersten Abschnitt werden diese auf Integer-Werte, im zweiten Abschnitt auf Float-Werte angewendet.

 1#-----------------
 2a = 10
 3b = 3
 4print('a/b=', a/b)
 5print('a//b=', a//b)
 6print('a%b=', a%b)
 7#-----------------
 8a = 11
 9b = 3.3
10print('a/b =', a/b)
11print('a//b =', a//b)
12print('a%b =', a%b)
13#-----------------

To Do

Finden Sie heraus, welche Bedeutung die verschiedenen Varianten haben, d.h. welche mathematischen Operationen diese realiseren!