Grundlagen Eingabe, Rechnen und Ausgabe in Python

Die Eingabe von Zahlen und Zeichenfolgen über die Tastatur, das Rechnen mit Zahlen (Verarbeiten) und die Ausgabe in die Shell verkörpern die wahrscheinlich grundlegendste Interaktionsform mit dem User in Python. Programmierstruktur: Sequenz

Table of Contents

Dieser Blog wird vom IAIP gratis zur Verfügung gestellt und ist einer aus einer Reihe von Einführungsblogs zum Thema «Programmieren mit Python».

Der Blog bildet Bestandteil des Kurses «Einführung in Python Teil 1». Dieser Kurs führt dich durch die einzelnen Blogs, enthält Zusatzmaterialien, viele Aufgaben mit Lösungen und Quizze zur Lernkontrolle. Der Kurs hat eine Kursgebühr von CHF 50.- Mit dem Einschreiben zum Kurs machst du es möglich, dass solche Blogs auch zukünftig noch gratis zur Verfügung gestellt werden können.

Ausgabe mit der print() Funktion

Die bekannte Abkürzung EDV bedeutet «elektronische Datenverarbeitung» und beschreibt treffend, was Computer genau machen. Sie verarbeiten Daten. Bevor sie aber Daten verarbeiten, müssen sie diese zuerst einmal empfangen. Und anschliessend an die Verarbeitung geben sie idealerweise das Resultat dieser Verarbeitung an ihre Umwelt bzw. den Nutzer zurück.

Im Folgenden beschäftigen wir uns mit der Eingabe der Daten über die Tastatur (Eingabegerät), den Grundrechenarten als einfache Form der Verarbeitung, und der Ausgabe auf dem Bildschirm (Ausgabegerät). Zur Interaktion mit dem Benutzer während der Programmausführung nutzen wir das Python Shell.

Ausgabe von Zeichenketten

Betrachten wir als erstes den nachfolgenden Programmcode (Quelltext):

# Ausgabe von Text
print("Hallo")
print("Mein Name ist Egon. Ich bin dein Computer")
print('Dieses Programm hat Mustermann geschrieben.')
print('Mustermann ist', 'ein ganz netter Kerl.')

Betrachten wir als erstes den nachfolgenden Programmcode (Quelltext):

halloWelt1

Die Funktion print()  gibt den Wert des Ausdrucks aus, der ihr übergeben wird. Oder einfacher formuliert: sie zeigt an, was zwischen den Klammern steht. Im obigen Beispiel haben wir jeweils einen Text (Wort, mehrere Wörter, Satz) übergeben. In der Fachsprache spricht man von einer Zeichenkette.

Zeichenketten stehen entweder zwischen einfachen oder zwischen doppelten Anführungs- & Schlusszeichen. Man kann nehmen, was einem besser zusagt. Grundsätzlich darf man, so wie im Beispielcode oben gezeigt, auch innerhalb eines Programms beide Möglichkeiten verwenden, solange man zur Eingrenzung einer einzelnen Zeichenkette jeweils das eine oder andere nutzt.

Die Anführungs- & Schlusszeichen selber sind nicht Teil der Zeichenkette, d.h. die Zeichenketten werden anschliessend von der print() Funktion ohne die Eingrenzungszeichen ausgegeben.

Eine Besonderheit der Python print() Funktion ist, dass sich gleichzeitig mehrere Ausdrücke übergeben lassen. Hierzu trennt man die einzelnen Ausdrücke (hier: Zeichenfolgen) einfach durch Kommas. In der Ausgabe wird dann zwischen den ausgewerteten Argumenten automatisch ein Leerzeichen eingefügt. Die vierte print() Anweisung im abgebildeten Code enthält beispielsweise die 2 Ausdrücke «Mustermann ist» und «ein ganz netter Kerl.», wobei bei der Ausgabe die zwei Zeichenfolgen einfach aneinandergehängt werden. 

Ausgabe von Zahlen

Man kann mit der print() Funktion natürlich auch andere Ausdrücke wie Zeichenketten ausgeben. Dazu gehören insbesondere auch Zahlen. Im Unterschied zu Zeichenketten lässt man bei Zahlen die Anführungszeichen weg:

# Ausgabe von Zahlen
print(3)
print(-4)
print(6.789)
print("3")

Führt man das Programm aus, so erfolgt in der Shell folgende Ausgabe:

Die ersten zwei Anweisungen führen zur Ausgabe einer positiven und einer negativen Ganzzahl, die dritte Anweisung zu eine Kommazahl.

Genau genommen wandelt Python die Zahlen bei der Ausgabe automatisch in eine Zeichenfolge um. Man übergibt dem Interpreter zwar eine Zahl, aber diese wird umgewandelt und anschliessend als Zeichenfolge in der Shell ausgegeben. Man kann zum Vergleich auch eine Zahl direkt als Zeichenkette übergeben. Siehe hierzu die vierte Anweisung, welche ebenfalls zur Ausgabe von 3 in der Shell führt.

Der Unterschied zwischen Zahlen und Zeichenketten wird gleich in den entsprechenden Blogs detailliert aufgenommen und dann auch deutlicher. An dieser Stelle ist lediglich wichtig, dass man beim Funktionsaufruf die Anführungs- und Schlusszeichen weglässt, wenn es sich um eine Zahl handelt. Und selbstverständlich kann man beim Aufruf mit mehreren Argumenten auch Zeichenketten und Zahlen mischen:

Als letztes bleibt nochmals der Hinweis, dass in den zwei Beispielprogrammen jeweils eine weitere Zeile mit einem vorangestellten # Zeichen steht. In Python hat man die Möglichkeit im Quellcode Kommentare anzubringen. Dies erleichtert die Lesbarkeit für Dritte. Ein Kommentar beginnt jeweils mit einer Raute # (engl.: Hash Tag) und geht von diesem bis zum Ende der Zeile. Solche Kommentare werden dann beim Übersetzen vom Interpreter einfach ignoriert.

Exkurs: Zusätzliche Argumente (separat or, end, file)

Wir haben bereits gesehen, dass man beim print() Funktionsaufruf mehrere Argumente übergeben kann. Python gibt dann einfach sämtliche Argumente aus, wobei zwischen den jeweiligen Ausgaben automatisch ein Leerzeichen eingefügt wird. Am Ende erfolgt dann ein Zeilenumbruch (der Cursor geht an den Anfang einer neuen Zeile).

Die genaue Syntax des print() Funktionsaufrufs in Python ist wie folgt:

       print(object(s), sep=separator, end=end, file=file, flush=flush)

Die einzelnen Argumente bedeuten dabei folgendes:

object(s)

Beliebige viele Objekte (Zeichenfolgen, Zahlen). Diese werden vor der Ausgabe in eine Zeichenkette umgewandelt.

sep

Optional. Definiert, wie die Objekte getrennt werden.

Standard ist ein Leerzeichen » ».

end

Optional. Definiert, was am Ende gedruckt werden soll.

Standard ist »\n» (Zeilenumbruch). Siehe auch Escape Codes.

file

Optional. Ein Objekt mit einer Schreibmethode.

Standard ist sys.stdout (Ausgabe in der Shell)

flush

Optional. Ein Boolescher Wert, der angibt, ob die Ausgabe geleert (True) oder gebuffert (False) wird. Standard ist False

Mit Ausnahme des ersten Arguments sind somit alle Angaben optional. Es sind sogenannte Default Value Parameter. Werden diese nicht weiter spezifiziert, verwendet der Interpreter einfach die als Standard hinterlegten Werte. Die Anweisung

wird mangels Spezifikation der Default Value Parameter vom Interpreter vor der Verarbeitung automatisch ergänzt zu:

Von besonderer Bedeutung sind hier vor allem die zwei ersten optionalen Argumente sep und end. Die print() Funktion setzte aus den übergebenen Objekten (beispielsweise den 4 Objekten: «Mein», «Name», «ist», «Egon») eine einzelne Zeichenfolge zusammen, wobei dazwischen jeweils die unter sep definierte Zeichenfolge eingefügt wird. Am Ende der Zeichenkette wird die unter end spezifizierte Zeichenkette angehängt.

Der nachfolgende Code zeigt die Wirkungsweise anhand einiger Beispiele:

print(1, "Mein", "Name", "ist", "Egon")
print(2, "Mein", "Name", "ist", "Egon", sep=" ", end="\n")
print(3, "Mein", "Name", "ist", "Egon", sep="", end="\n")
print(4, "Mein", "Name", "ist", "Egon", sep="-", end="")
print(5, "weiter")

Führt man das Programm aus, so erfolgt folgende Ausgabe in der Shell:

Die erste Codezeile ist gleichbedeutend mit der zweiten Zeile. Zwischen den einzelnen Ausdrücken steht ein Leerzeichen und am Ende erfolgt ein Zeilenumbruch. Letzter wird über die sog. Escape Sequenz (siehe nachfolgend) «\n » ausgelöst.

Genau genommen ist die print() Funktion eigentlich bloss eine Funktion, welche dann eine andere Funktion oder Methode aufruft (eine Art «Wrapper Funktion»). Sie formatiert die Eingabe und ruft anschliessend die write() Methode eines Objekts auf. Hier es die write Methode des sys.stdout Objekts. Das heisst, es gibt ein Python System-Objekt mit dem Namen stdout, welches über eine Methode zur Ausgabe einer Zeichenkette in der Shell verfügt. Wir können diese Methode auch direkt aufrufen:

Unsere eigentliche Ausgabefunktion ist die write() Methode (Funktion). Die write Methode des sys.stdout Objektes verarbeitet aber nur eine einzelne Zeichenfolge. Eine Aufruf mit mehreren Zeichenfolgen

oder ein Aufruf mit einem vorab auszuwertendem Ausdruck wie beispielsweise

führt unmittelbar zu einem Fehler. Hier kommt unsere print() Funktion zum Zug. Sie generiert aus allen unseren Argumenten, unter Berücksichtigung eines zusätzlichen Separators und eines Endes, eine einzelne Zeichenkette, welche dann automatisch an die stdout.write() Ausgabefunktion übergeben wird.

Ferner kann man beim print() Funktionsaufrufs in Python optional ein file angeben.

print(object(s), sep=separator, end=end, file=file, flush=flush)

Standardmässig ist sys.stdout als Wert hinterlegt. Dies entspricht in der Regel einer Ausgabe in unserer Shell. Wir können zur einfachen Überprüfung die print() Funktion gleich direkt aus der Shell aufrufen.

Spezifiziert man als file sys.stdout, so erfolgt die Ausgabe in der Shell. Lässt man diese Angabe weg, so füllt Python die fehlende Angabe im Hintergrund ein. Genauso gut kann man aber auch einen anderen Ausgabekanal wählen. Beispielsweise eine Textdatei.

Hier erfolgt nun keine Ausgabe in der Shell. Die Anweisung erstellt im aktuellen Verzeichnis eine File «unsere_testausgabe.txt» und schreibt die Ausgabe in dieses File. Man kann das File mit einem beliebigen Texteditor öffnen und die zu erwartende Ausgabe so überprüfen.

Das Argument file muss ein Verweis auf ein Objekt mit einer write Methode sein. Ist dies nicht der Fall, so verwendet Python den Standardwert sys.stdout.

Exkurs: ANSI Escape Codes und Sonderzeichen

Manchmal möchte man im Text etwas hervorheben, um die Ausgabe übersichtlicher zu gestalten. Oder man möchte beispielsweise innerhalb einer Zeichenkette einen Zeilenumbruch erzeugen. Zur einfachen Formatierung der Ausgabe kann man ANSI Escape Sequenzen (ANSI Escape Codes) nutzen. Die Codes werden direkt in die Zeichenkette eingefügt.

Hierzu wiederum ein kleines Beispielprogramm:

print("Hallo")
print("Mein Name ist \"Egon\". Ich bin dein\nComputer")
print("Dieses Programm hat \033[4mMustermann\033[0m geschrieben.")
print("\033[4;31mMustermann ist ein ganz netter Kerl.\033[0m")
print()

Und die zugehörige Ausgabe:

Eine Escape-Sequenz ist eine Zeichenkombination, die sich zwar in einer Zeichenkette befindet, jedoch keinen eigentlichen Text repräsentiert. Sie wird vom Interpreter abgefangen (von engl. escape: entkommen) und anstelle dessen wird eine Sonderfunktion ausgeführt.

Escape Codes kommen klassischerweise bei Terminals zur Anwendung. Bei einem Bildschirmterminal (bzw. unserer Shell) kann die über den Code ausgelöste Sonderfunktion beispielsweise die Cursor-Positionierung steuern, spezielle Zeichen darstellen oder gar die Textformatierung ändern. Immer vorausgesetzt, dass das GUI auch in der Lage ist, die entsprechende Formatierung darzustellen. Sprich der Text kann nur rot angezeigt werden, wenn das Terminal auch farbigen Text anzeigen kann.

In Python (und vielen anderen Programmiersprachen) werden Escape Sequenzen durch einen Backslash \ eingeleitet. Eine Auflistung zahlreicher nützlicher Escape Sequenzen findet sich im Anhang. Die an dieser Stelle speziell hervorzuhebenden und in den folgenden Beispielcodes teilweise verwendeten Escape Codes sind:

  Steuerung des Cursors:

   \n                       Neue Zeile (Zeilenumbruch)
    \t                        Tabulator

  Sonderzeichen:

   \\                        einen Backslash machen (ohne dass dieser weggelassen wird)
    \»                       ein Anführungs- bzw. Schlusszeichen als Teil des Textes machen

  Formatierung:

   \033[4m            underline (unterstreichen) starten
   \033[0m            Formatierung zurückstellen (beenden)

Bei den Sonderzeichen nutzt man Escape Codes, dass der Interpreter beispielsweise das » Zeichen nicht irrtümlicherweise als Schluss der Zeichenkette interpretiert. Es gibt aber noch andere Möglichkeiten, um » bzw. ‘ Zeichen korrekt darzustellen. Beispielsweise kann man das jeweils andere Zeichen innerhalb der Zeichenkette verwenden. Alternativ kann man sog. lange Zeichenketten benutzen. Diese beginnen und enden mit jeweils drei Anführungszeichen. Innerhalb dieser dürfen dieselben Anführungszeichen stehen (und auch Zeilenumbrüche etc. sind möglich – was va. bei der Programmierung innerhalb der interaktiven Shell sinnvoll sein kann).

Die drei Anweisungen nachfolgenden Anweisungen führen zu ein und derselben Ausgabe:

print("Mein Name ist \"Egon\". Ich bin dein Computer")
print('Mein Name ist "Egon". Ich bin dein Computer')
print("""Mein Name ist "Egon". Ich bin dein Computer""")

Rechnen mit Zahlen (und Zeichenketten)

Um das zu schaffen, was gewisse Computer in einer einzelnen Sekunde schaffen, müsste jeder einzelne Mensch gleichzeitig rund 200 Zahlen addieren. Denn es gibt Computer, welche in einer Sekunde über 1’000’000’000’000 (1 Billion) Zahlen zusammenzählen. Kurzum: Computer sind Rechenmaschinen. Sie können unglaublich schnell rechnen. Und damit wollen wir uns nun beschäftigen.

Grundrechenarten mit Zahlen

Im letzten Kapitel haben wir den Computer dazu gebracht, einen Text auf dem Bildschirm anzuzeigen. Beispielsweise mit dem Befehl print(«hallo»). Ebenso kann man eine Zahl übergeben, indem man wie gezeigt einfach die Anführungs- und Schlusszeichen weglässt.

Nun kann man in Python auch ganze Rechnungen als Ausdrücke übergeben. Hierzu einige Beispielanweisungen:

# Ausgabe von Zahlen und Rechnungen
print(10)
print(10+2)
print(10-2)
print(10*2)
print(10/2)

Der Programmcode führt, wie nicht schwer zu erraten ist, zu folgender Ausgabe:

Beim print() Funktionsaufruf werden in obigen Beispielen jeweils eine Zahl bzw. eine Rechnung übergeben. Python wertet diese aus (berechnet das Resultat) und die print() Anweisung stellt anschliessend das Resultat für uns direkt in der Shell dar (dann aber als Zeichenfolge). Der print() Funktionsaufruf ist hier also bloss ein Mittel zum Zweck, um das Resultat der Rechnung für uns sichtbar zu machen. Wir werden gleich noch sehen, dass man auch direkt in der Shell oder etwa mit Variablen rechnen kann etc.

Nachfolgend ist eine tabellarische Übersicht der Operatoren für die Grundrechenarten der Mathematik (Addition, Subtraktion, Multiplikation, Division, ergänzt um die Operatoren für den Modulo, die zugehörige Ganzzahl und das Potenzrechnen). Diese bilden gewissermassen die Basis für das Rechnen mit Python. Die Nomenklatur, also die verwendeten Symbole, sind etwas anders wie in der Mathematik üblich. Man hat sich aber schnell daran gewöhnt – und sie sind in allen berühmteren Programmiersprachen gleich.

Symbol

Beschreibung

Beispiel

Mathe

+

Addition (Plus-Rechnen)

3 + 4  = 7

3 + 4  = 7

Subtraktion (Minus-Rechnen)

10 – 2 = 8

10 – 2 = 8

*

Multiplikation (Mal-Rechnen)

10 * 2 = 20

10 ·2 = 20

/

Division (Geteilt durch-Rechnen)

8 / 2 = 4

8 : 2 = 4

%

Modulo (Rest einer Division)

9 % 2 = 1

9 : 2 = 4 Rest 1

//

Ganzzahl einer Division (Pendent zu Modulo)

9 // 2 = 4

**

Potenzrechnen (Hochrechnen)

2 ** 3 = 8

23 = 8

In Python lassen sich auch mehrere Operationen hintereinander ausführen. Es herrschen dieselben Regeln wie sonst in der Mathematik. Insbesondere gilt die «Punkt vor Strich Regel», d.h. sofern keine Klammern gesetzt sind, haben Multiplikationen und Divisionen immer den Vorrang vor Additionen und Subtraktionen.

# Klammern
print (6+4*2)       # normales "Punkt" vor "Strich" Regel -> 6+8=14
print (6+(4*2))     # natürlich kann man auch Klammern verwenden
print1
print("Absolutbetrag von b        :", abs(b))
print("grösste Zahl               :", max(a, b, c))
print("kleinste Zahl              :", min(a, b, c))
print("runden von a auf 1 Stelle  :", round(a, 1))
print("runden von b auf 0 Stellen :", round(b))
print("umwandeln von b in Ganzzahl:", int(b))

Der abgebildete Programmcode führt zu folgender Ausgabe:

Bei der Funktion round() benötigt man im Unterschied zu den anderen Funktionen noch einen ergänzenden Parameter, welcher die Anzahl Kommastellen angibt, auf welche die Zahl gerundet werden soll. Der Befehl round(Zahl,3) rundet somit die Zahl auf 3 Kommastellen. Lässt man diesen Parameter weg, dann rundet die Funktion einfach automatisch auf 0 Stellen.

Im obigen Beispiel haben wir eine Alternative zum Herstellen einer Ganzzahl gesehen: die Funktion int(). Diese Funktion rundet streng genommen nicht, sondern wandelt die Kommazahl (Gleitkommazahl vom Datentyp float) in eine Ganzzahl (Datentyp int) um. Wir werden die 2 Datentypen gleich noch näher kennenlernen. 

An dieser Stelle sei nur auf 2 Sachen verwiesen:

Beachte hierzu insbesondere die dritte Zeile in nachfolgenden 4 Beispielen:

  round (2.5)     ergibt 3.0.             Die Werte 3 und 2 sind je 0.5 von 2.5 entfernt.

  round (2.4)     ergibt 2.0.             Der Wert 2 ist nur 0.4 entfernt, gegenüber 0.6 für 3.

  round (-1.5)   ergibt -2.0             Die Werte -2 und -1 sind je 0.5 von -1.5 entfernt.

  round (-1.4)   ergibt -1.0             Der Wert -1 ist nur 0.4 entfernt, gegenüber 0.6 für -2.

Exkurs: Mathematik Bibliotheken math, statistics

Python ist besonders verbreitet, weil es eine Reihe sehr guter Bibliotheken gibt, welche ergänzende Datentypen, Konstanten und zugehörige nützliche Funktionen enthalten.

Rund um eine Einführung zum «Rechnen mit Python» zählen dazu vor allem:

Man kann diese Module, auch wenn man sie importieren muss, gewissermassen zum Grundumfang von Python zählen. Für weitergehende Aufgaben im Beriech der Mathematik, der Statistik, der Datenaufbereitung und Analyse oder beispielsweise des maschinellen Lernens stehen eine Vielzahl spezialisierter, mächtiger Bibliotheken bereit. Dazu zählen beispielsweise:

Für die Darstellung von Grafiken gibt es beispielsweise:

Für die Datenaufbereitung wichtig ist beispielsweise:

Im Bereich der künstlichen Intelligenz (KI) verwendet man zum Beispiel:

Die einzelnen Bibliotheken bieten nicht nur zusätzliche Funktionalitäten an, sondern sind oftmals auch performanter. Denn der für Python standardmässig installierte Interpreter CPython führt Kommandos als unoptimierten Bytecode aus. Spezialisierte Bibliotheken wie NumPy sind bereits als C-API implementiert, so dass die Geschwindigkeit deutlich höher ist. D.h. mathematische Algorithmen sind in der CPython-Variante oft langsamer als eine äquivalente kompilierte Umsetzung.

Exkurs: Rechnen direkt in der Shell

Python ist ein Interpreter. Und entsprechend kann man auch das interaktive Shell nutzen, um direkt nach dem Prompt Zeichen >>> (Python Shell) bzw. In [] (IPyton Shell)  Rechnungen einzugeben. Beispielsweise so:

 

Zu beachten ist an dieser Stelle va. die zweite Eingabe. Mit dem Unterstrich _ kann man in der Shell bequem das letzte Resultat übernehmen und braucht es so nicht erneut eingeben. Mit den Cursortasten für hoch ˄ und runter ˅  kann man vorangehende Eingaben erneut holen. Tippt man 2 Mal Cursor ˄, so erscheint erneut die Eingabe von In[6].

Und natürlich kann man auch die bekannten Python Funktionen verwenden, Variablen definieren etc. Am Ende ist die die Eingabeaufforderung nichts anderes als eine einzelne Quellcodezeile, welche vom Interpreter übersetzt wird. Entsprechend kann man Bibliotheken importieren und verwenden. Beispielsweise die erwähnte Mathematikbibliothek math.

Zeichenketten und numerische Datentypen

In Programmen braucht man die Möglichkeit, Werte zu speichern. Beispielsweise die Eingabe eines Benutzers oder ein Zwischenergebnis einer Berechnung. Dies geschieht mit Hilfe von Variablen bzw. Namen und Objekten. 

Variablen: Nutzung eines Platzhalters für Texte und Zahlen

Eine Variable ist, genau wie in der Mathematik, nichts anderes wie ein Platzhalter für einen Wert. Betrachten wir als erstes das nachfolgende Beispielprogramm:

# mit Variablen
vorstellen = "Mein Name ist Egon. Ich bin dein Computer"

print("Hallo")
print(vorstellen)

Das Programm führt zu folgender Ausgabe in der Shell:

Im Programm verwenden wir die Variable vorstellen. Die Variable mit dem Namen vorstellen ist ein Platzhalter für die Zeichenfolge «Mein Name ist Egon. Ich bin dein Computer». In Python spricht man dabei von einer Zuweisung. D.h. der Text «Mein Name ist Egon. Ich bin dein Computer» wird mit dem Zuweisungszeichen = (einfaches Gleichheitszeichen) der Variable bzw. dem Namen vorstellen zugewiesen.

Variablen oder Platzhalter kann man sich bildlich wie kleine Kisten vorstellen, die dann mit dem Variablennamen beschriftet werden.

 

In dieser bildlichen Sprache bedeutet dann die Zuweisung   vorstellen = «Mein Name ist Egon. Ich bin dein Computer» übersetzt etwa:

  1. Nimm eine leere Kiste
  2. Beschrifte diese mit einem Namen (Variablennamen). Hier im Beispiel «vorstellen»
  3. Lege das was rechts vom Zuweisungszeichen steht in die Kiste. Hier die Zeichenfolge «Mein Name ist Egon. Ich bin dein Computer».

Diesen Platzhalter können wir anschliessend an beliebigen Stellen im Programm wiederverwenden. So schreiben wir bei der zweiten print() Anweisung nicht mehr den eigentlichen Text zwischen die Klammern, sondern nur noch den Namen vorstellen, welcher auf unseren Text verweist. Dieser hat dann selber keine Anführungszeichen mehr.

Neben Zeichenketten können Variablen auch Zahlenwerte darstellen. Mit solche numerische Variablen kann man anschliessend auch direkt Rechnungen durchführen. Hierzu wiederum ein Beispielcode:

# Ausgabe von Zahlen und Rechnungen, jetzt mit Variablen und Text
zahl1 = 10
zahl2 = zahl1 - 8

print("Addition:", zahl1 + zahl2, end="; ")
print("Subtraktion:", zahl1 - zahl2, end="; ")
print("Multiplikation:", zahl1 * zahl2, end="; ")
print("Division:", zahl1 / zahl2)

In der ersten Codezeile wird der Variable zahl1 die Zahl 10 zugewiesen, in der zweiten Zeile der Variable zahl2 der Wert der vorab definierten Variable zahl1 (also im Beispiel: 10) abzüglich 8. Der Code führt zu folgender Ausgabe:

    Addition: 12; Subtraktion: 8; Multiplikation: 20; Division: 5.0

Zuweisung: Namen mit Objekten verbinden

In Python spricht man weniger von Variablen sondern mehr von Namen und Objekten. Um das zu verstehen, muss man etwas mehr über den Begriff bzw. die Funktionsweise einer Zuweisung bzw. über Objekte verstehen. Die genaue Funktionsweise von Objekten wird in einem ausführlichen Blog erläutert und bildet Bestandteil des Kurses «Einführung in Python Teil II». An dieser Stelle ist aber ein erstes Basisverständnis nützlich und sinnvoll. 

Grundmechanismus der Zuweisung

Wie gezeigt können wir mit Zuweisungen in Python einfach einem frei wählbaren Namen etwas zuordnen. Dieses «etwas» ist in der Fachsprache ein sogenanntes Objekt. Es kann beispielsweise eine Zeichenkette (ein Text) oder aber auch eine Zahl sein. Wir können sogar einem Ergebnis eines (mathematischen) Ausdrucks einen Namen geben. In diesem Fall schreibt man in Python einfach den Namen, ein Gleichheitszeichen und den Ausdruck hin. 

kiste1 = "Das ist ein Text"   # Zuweisung einer Zeichenfolge
kiste2 = 3                    # Zuweisung einer Zahl
kiste3 = 4 + 6                # Zuweisung eines Ausdrucks

 

Der Name (also zum Beispiel kiste1 ) agiert gewissermassen nun als Platzhalter für das zugewiesene Objekt. Wir können ihn an einen anderen, späteren Stelle im Programm verwenden. Wie ist das zu verstehen? 

In Python werden alle Daten in Form eines Objekts gespeichert. Was wir gemeinhin als Variable bezeichnen, ist in erster Linie ein Name und ein zugehöriges Objekt. Mit der = Zuweisung verbinden man einen Namen mit einem Objekt. Verbinden bedeutet dabei, dass der Name auf das Objekt referenziert. Die eigentlichen Daten sind dann im Objekt enthalten. Die Zuweisungen in Python haben somit folgende Form:

  Name = Objekt

Was passiert bei einer Zuweisung im Wesentlichen? Bei einer Zuweisung mein_name = «Mein Name ist Egon» erstellt Python automatisch:

  1. ein Objekt (im nachfolgenden Bild: eine Kiste) vom Typ Zeichenkette.
    Python kennt verschiedene Objekt-Typen (Kisten-Typen), je nachdem, was man in einer Kiste ablegen will bzw. damit machen will. Das ist wie im richtigen Leben: man lagert «Holz» in einer anderen Kiste wie «Schmuck», «Werkzeuge» oder «Waffen». Bei einer Zuweisung mein_name = 5 würde Python entsprechend ein Objekt geeignet für Zahlen (hier vom Typ Ganzzahl) anlegen. Übrigens: der Interpreter generiert automatisch das passende Objekt zum Wert «Mein Name ist Egon» (in Python ist keine Typendeklaration notwendig). Das Objekt verfügt über alles, was benötigt wird, um mit der Zeichenfolge «Mein Name ist Egon»  sinnvoll umgehen zu können (die Methoden) und auch über genügend Speicherplatz etc. Es ist gewissermassen die richtige Kiste in der richtigen Grösse, um «Mein Name ist Egon»  darin ablegen zu können.

  2. dieses Objekt bekommt eine eindeutige Identifikationsnummer (ist hier der Speicherplatz).

  3. einen Namen mein_name, welcher auf die Identifikationsnummer des Objekts verweist.
    Damit weiss der Interpreter, welches Objekt bei Verwendung des Ausdrucks mein_namename tatsächlich gemeint ist.

Es wird also nicht die Kiste direkt mit dem Namen der Variable beschriftet. Vielmehr gibt es eine eine Art Karteikartensammlung mit Namen und Identifikationsnummern (Lagerplätzen), so dass man die Kisten im Lager rasch finden kann.

Der Name wird im Namensraum des Programms (bzw. des jeweiligen Bereichs) abgelegt. Dadurch braucht der Interpreter bei einer späteren Abfrage nach dem Inhalt der Variable nicht den ganzen Speicher des PCs zu durchsuchen, sondern lediglich den Namensraum. Man kann es sich bildlich wie in einer Bibliothek, wo man Bücher über Karteikarten sucht, vorstellen. Oder eben wie ein Lager, bei welchem auf Karteikarten vermerkt ist, welcher Artikel wo (in welcher Kiste) gelagert ist.

Übrigens kann man die Identifikationsnummer eines Objekts einfach über die Funktion id(Objektname) anzeigen lassen:

Dynamische Typisierung

In vielen Programmiersprachen muss man eine Variablen deklarieren, bevor man diese verwenden kann. Dadurch weiss der Interpreter (oder Compiler), wie er mit der Variablen umzugehen hat. Auch kann er bereits einen genügend grossen Platz im Speicher reservieren, so dass der Wert hineinpasst. Eine solche Deklaration würde dann etwas wie folgt aussehen:

int zahl
zahl = 3

Deklarieren bedeutet hier also etwas vereinfacht gesagt, dass man zuerst einmal eine «Kiste» anlegt, bevor man etwas in die Kiste hineintut. Mitunter erfolgt die Deklaration auch gleich mit der ersten Wertzuweisung. Man fasst hier einfach zwei Codezeilen in einer einzigen zusammen:

int zahl = 3

In Python, wie auch in vielen weiteren hochentwickelten Programmiersprachen, muss man Variablen nicht deklarieren. Python hat vielmehr eine dynamische Typisierung. Python erledigt die Deklaration für uns. Dabei  überprüft der Interpreter zur Laufzeit, welche Operationen zulässig sind und angewendet werden können.

In Python schreibt man also einfach:

kiste1 = "Das ist ein Text"   # Zuweisung einer Zeichenfolge
zahl = 3                      # Zuweisung einer Zahl

Python erkennt automatisch, dass es sich im ersten Fall um eine Zeichenfolge (bzw. eine Variable des Datentyps str) handelt und im zweiten Fall um eine Zahl (Datentyp int). Es generiert für uns automatisch ein Objekt (eine Kiste) vom Datentyp str  bzw. ein Objekt (eine Kiste) vom Datentyp int, beovr es die Werte darin ablegt und die Namen kiste1 und zahl mit den Objekten verbindet.

Diese automatische Typendeklaration nimmt dem Programmierer Arbeit ab und macht diese auch einfacher. Sie hat aber auch Nachteile, denn durch die explizite Angabe hat man mehr Kontrolle. Schreibt man beispielsweise später im Code zahl= «5», so verändert man damit den Datentyp der Variable zahl von int auf str. Der Inhalt der Variable ist keine Zahl mehr, sondern nun neu eine Zeichenfolge (ein Text).

Mitunter wird kritisiert, dass dadurch in Python keine Konstanten (also nicht änderbare Variablen) definiert werden können.

Mehrfachzuweisung im Speziellen

Jetzt, wo wir das Grundprinzip der Zuweisung gesehen haben, können wir unser Augenmerk noch auf zwei Spezialfälle wenden. Namentlich auf Mehrfachzuweisungen und auf die Inplace Operation +=. 

In Python gibt es die Möglichkeit von Mehrfachzuweisungen (engl.: multiple assignment). Der folgende Programmcode zeigt die 2 typischen Fälle an einem Beispiel:

# Ausgabe von Zahlen und Rechnungen, jetzt mit Variablen und Text
zahl1, zahl2, titel = 10, 20, "Addition:"
print(titel, zahl1 + zahl2)

zahl3 = zahl4 = 6
print(zahl3 * zahl4)

Das Programm führt zur Ausgabe von «Addition:30» aus der ersten print() Anweisung und «36» aus der zweiten print() Anweisung.

Die erste Zeile enthält die klassische Form einer Mehrfachzuweisung. Die Variablen zahl1zahl2 und titel bekommen gleichzeitig ihre Werte (Objekte) zugewiesen, wobei jede Variable einen eigenen Wert bekommt. Solche Mehrfachzuweisungen sparen Platz im Quellcode. Sie sind in der Praxis va. sinnvoll, um die unterschiedlichen Rückgabewerte von Funktionen abzufangen (siehe Blog zum Thema Funktionen).

Im zweiten Block erfolgt eine andere Form von Mehrfachzuweisungen. Hier wird eine Wert (ein Objekt) mehreren Namen zugewiesen.

Exkurs: Inplace Operation +=

Manchmal möchte man den Zahlenwert einer Variable, in der Regel einer Ganzzahl, erhöhen. Beispielsweise wenn man in einem Programm zählen möchte, wie oft etwas passiert ist. Python bietet zwei Möglichkeiten, wie dies gemacht werden kann.

zahl = 10

# Variante 1
zahl = zahl + 1
print(zahl)

# Variante 2
zahl += 1
print(zahl)

Im zweiten Block  findet sich eine in-place Operation zur Erhöhung der Variable. Die Zeile bedeutet übersetzt etwa soviel wie zahl1 = zahl1 + 1. Man erspart sich somit die Wiederholung des Variablennamens nach dem Zuweisungszeichen.  Solche «abgekürzten» Schreibweisen findet man oft bei Schleifen im Zusammenhang mit Zählvariablen bzw. Indexvariablen, wo der Wert einer Variable bei jedem Durchlauf um 1 erhöht werden soll. Grundsätzlich kann man die Zuweisung aber auch mit den anderen mathematischen Operatoren (also z.B. zahl1 -= 1) machen.

Ganz identisch sind zahl1 = zahl1 + 1 und zahl1 += 1 genau genommen nicht. Und in anderen Sprachen, wie beispielsweise C, gibt es sogar noch eine dritte Form ++zahl1, welche den Wert der Variable um 1 erhöht.

Der Unterschied liegt im Wesentlichen darin, wie das Ganze auf CPU Ebene verarbeitet wird. Gehen wir davon aus, der Name der Variable sei (anstelle zahl1), und im CPU Register D steht die Speicheradresse der Speicherstelle, an welcher der Wert von abgelegt ist. Der ALU (arithmetic logical unit) des Prozessors nimmt einen Parameter und gibt ein Ergebnis zurück in einem «Akkumulator» (nennen wir diesen A). Dann wären die 3 Varianten sinngemäss wie folgt übersetzt:

i = i +1

MOV A,(D);   verschiebe nach A den Inhalt des Speichers, dessen Adresse in D steht

ADD A, 1;       Addition (inclined constant)

MOV (D) A;    verschiebe das Resultat zurück an Speicher, dessen Adresse in D steht

i += 1

ADD (D),1;     addiere Konstante zum Wert der Speicheradresse, die in D steht

++i

INC (D);         Nur ein «tick» des memory located counter

Die erste Art beinhaltet viele Schritte, ist dafür aber generell anwendbar. Die zweite Art benötigt immer noch den ALU, aber verschiebt die Werte nicht hin und her. Sie ersetzt den alten Wert «in-place». Für eine einfache Addition ist diese ausreichend, versagt aber bei komplexeren Ausdrücken. Beispielsweise kann man die Zuweisung  i = 4*i + i-1 nicht in-place berechnen, da man ja mehrmals auf den «ursprünglichen» Wert von i zugreifen können muss.

Namenskonvention bei Variablen

Wir können also Platzhalter für Texte und Zahlen nutzen, indem wir letztere einer Variable bzw. einem Namen zuweisen. Bei der Wahl des Namens ist man relativ frei. Denn Python ist sehr flexibel, was die Bezeichnung von Variablen angeht:

Einige Einschränkungen gibt es dann doch noch. Wichtig sind insbesondere:

Auch wenn der Python Interpreter fast alles erlaubt, empfiehlt es sich dennoch Namen zu wählen, die einigermassen sinnvoll sind. Sinnvoll bedeutet, dass der Name der Variable etwas über deren Inhalt aussagen soll. Fragt man einen User nach seinem Jahrgang, so sollte man die Benutzereingabe in einer Variable mit dem Namen geburt oder jahrgang etc. abspeichern, und nicht in abstrakte Namen wie x oder aaa. Denn grosse Programme können schnell hunderte von Variablen haben. Allerdings gibt es in der Praxis einige Ausnahmen. Beispielsweise bezeichnet man bei Zählschlaufen (siehe Blog zum Thema Schleifen) die Zählvariable oft mit i. Diese ist dann aber nur ein Zähler und hat keine tiefere Bedeutung.

Darüber hinaus gibt es Style Guides, welche zusätzliche Regeln festlegen, wie Variablen zu benennen sind. Der bekannteste Styleguide für Python ist PEP8 (siehe PEP 8 — Style Guide for Python Code). Diese Regeln sind aber rein freiwilliger Natur. Man möchte damit lediglich erreichen, dass die Lesbarkeit des Quellcodes für andere Programmierer erleichtert wird.

An dieser Stelle empfehlen wir für die Namenswahl bei Variablen:

  • kurz, aber aussagekräftig
  • bei mehreren Wörtern diese mit _ verbinden
  • alles klein geschrieben

Datentypen im Speziellen

Übersicht

Wollen wir Werte ablegen, so mach wir dies mit Objekten. Objekte sind in erster Linie mal etwas abstraktes, weshalb sich das Bild einer Kiste auch so gut eignet. Objekte in Python haben eine eindeutige Identifikationsnummer, sind von einem speziellen Typ (Art einer Kiste), beinhalten den Wert und darüber hinaus noch ein Paket an Methoden. 

Die Identifikationsnummer nutzt Python zur Identifikation. Damit kann man mit einem Namen eindeutig auf ein bestimmtes Objekt verweisen und findet dieses entsprechend rasch im Speicher. Aus dem Datentyp kann man ableiten, wieviel Speicherplatz ein Objekt benötigt (wie gross ist die Kiste) und wie man mit den Werten umzugehen hat. Ersteres ist intuitiv leicht verständlich. Beispielsweise benötigt ein Text mit 100 Zeichen «Hallo meine Welt. Dies ist ein langer Text usw…… bis wir 100 Zeichen haben» sicherlich mehr Speicherplatz wie die kleine Zahl 3. Zweiteres hat damit zu tun, dass man mit unterschiedlichen Werten unterschiedlich umgehen möchte. Identifikationsnummer und Datentyp eines Objekts können wir über die Python Anweisungen id() und type() herausfinden. Hierzu ein Beispiel:

 

 

Unter IN[1] weisen wir die Zeichenfolge (den Text)  «5» dem Namen z zu. Genau genommen ein Objekt, welches den Wert «5» enthält. Wir können die Objektid und auch den Typ abfragen, siehe IN[2] und IN[3]. Wir können auch mit dem Objekt Operationen durchführen. Beispielsweise eine «Multiplikation» durchführen. Allerdings wird nicht der wahrscheinlich zu erwartende Wert 30 ausgegeben, sondern 555555. Denn sobald Python den Operator * trifft, schaut es nach, wie eine Multiplikation genau funktioniert. Und das ist beim Objekt definiert. Bei Objekten vom Typ str  werden bei einer Multiplikation die vorhandenen Zeichen einfach x Mal wiederholt.

Die wichtigsten Datentypen in Python sind die folgenden:
Nichts Datentyp

none

Variable hat noch keinen Wert

a = none

Numerische Datentypen

bool

Boolesche Werte (1: True, 0: False)

0, 1

int

Ganze Zahlen

-40, 673’456, 0, 1

float

Gleitkommazahlen

-3.345, 63.45, 0.0, 1.0

complex

Komplexe Zahlen

4+3j, 6.78 + 2.1j, 0+0j, 1+0j

Zeichenketten (String)

str

Folge von Zeichen, Text

«hallo», ‘Echo’

Listen

list

Folge Elementen

[«hallo», 1, 3]

Python unterscheidet drei grundlegende Arten von Zahlen: die ganzen Zahlen, die Gleitkommazahlen und die komplexen Zahlen.

Ganze Zahlen (Datentyp: int)

Ganze Zahlen sind Zahlen ohne Kommastellen. Sie werden in Python durch den Datentyp int repräsentiert.

Eine ganze Zahl ist letztlich einfach eine Folge von Ziffern, die dann vom Python Interpreter als Dezimalzahlen interpretiert werden. Also Beispielsweise

  • 3 für die Zahl Drei
  • 34 für die Zahl Vierunddreissig, bestehend aus 4 Einer und 3 Zehner
  • 6435 für die Zahl Sechstausendvierhundertfünfunddreissig
  • -3 für die Zahl Minusdrei

Aus der letzten Zeile ist ersichtlich, dass ganze Zahlen natürlich auch negative ganze Zahlen sein können. Hierzu stellt man einfach ein Minuszeichen vor die Ziffernfolge. Das Minuszeichen ist strenggenommen nicht Teil der Ziffernfolge, sondern ein mathematischer Operator.

Bei einigen Programmiersprachen (und alten Python Versionen) gibt es mehrere verschiedene Datentypen für ganzzahlige Werte. Das hat mit der Grösse des Speichers zu tun. Zahlen, welche eine gewisse Grösse überschreiten (z.B. den Wert 2’147’483’647 auf 32 Bit Rechnern) müssen dann vom Interpreter anders verarbeitet und deshalb vorab anders deklariert werden. Beispielsweise mit dem Datentyp longint. Bei aktuellen Versionen von Python ist diese Unterscheidung zwischen «einfachen» und «langen» ganzen Zahlen nicht notwendig. Wird der kritische Wert für «einfache» ganze Zahlen überschritten, so rechnet Python 3 automatisch mit «langen» ganzen Zahlen weiter.

Gleitkommazahlen (Datentyp: float)

Zahlen mit Kommastellen werden in Python durch den Datentyp float repräsentiert.

Die Nachkommastellen werden dabei – wie im englischen Sprachraum üblich – nicht durch ein Komma, sondern durch einen Punkt von dem ganzzahligen Anteil getrennt. Also beispielsweise:

  • 3.4 für die Zahl drei Komma vier
  • 34.87 für die Zahl vierunddreissig Komma acht sieben

Wird vor oder alternativ nach dem Dezimalpunkt keine Zahl eingegeben, so geht Python davon aus, dass es sich um eine 0 handelt.

  • 3. wird automatisch umgewandelt in 3.0
  • .87 wird automatisch umgewandelt in 0.87

Wissenschaftler verwenden oftmals eine etwas andere Zahlendarstellung wie jene, welche man aus der Schule kennt. Es ist die sogenannte Exponentialschreibweise. Sie eignet sich besonders für die Darstellung sehr grosser (oder sehr kleiner) Zahlen. Im Wesentlichen ergänzt man eine Zahl mit dem Buchstaben «e» und der Anzahl Stellen, welche das Komma dann nach links oder rechts verschoben wird.

  • 3.0 e2 bedeutet 3.0 · 102 und entspricht der Zahl 300
  • 4.1 e8 bedeutet 4.1 · 108 und entspricht der Zahl 410’000’000
  • 1.0 e-6 bedeutet 4.1 · 10-6 und entspricht der Zahl 0.000001

Python wird von vielen Wissenschaftlern verwendet und kann deshalb auch bestens mit der Exponentialschreibweise umgehen. Man kann dabei wahlweise ein kleines e oder grosses E verwenden. Übrigens: Man kann in Python auch zwischen verschiedenen Darstellungsformen wählen und so eine Zahl wahlweise im Exponentialformat anzeigen lassen. Für mehr Details siehe Blog zum Thema Formatierung von Zeichenketten.

Komplexe Zahlen (Datentyp complex)

Der Vollständigkeit halber sei hier erwähnt, dass Python standardmässig auch mit komplexen Zahlen rechnen kann.

Komplexen Zahlen werden benötigt um gewisse Gleichungen lösen zu können, welche sich mit den bekannten reellen Zahlen nicht lösen lassen. Sie erweitern den Zahlenbereich der reellen Zahlen durch Einführung einer neuen imaginären Zahl (mit der Eigenschaft ). Entsprechend bestehen Komplexe Zahlen aus einem Realteil und einem Imaginärteil.

Für jene, welche sich mit komplexen Zahlen bereits auskennen, einige Hinweise:

  • Python intern sind komplexe Zahlen einfach Paare von zwei Gleitkommazahlen, welche addiert werden. 
  • D.h. zur Darstellung muss man den Real- und den Imaginärteil einfach nur addieren.
  • Den Imaginärteil schreibt man mit dem Suffix «j» anstelle des in der Mathematik gebräuchlichen «i». 
  • Es gibt eine ergänzende Bibliothek (cmath), welche das Rechnen mit komplexen Zahlen erleichtert.

Datentypen umwandeln

Das Umwandeln von Datentypen in Python ist ziemlich intuitiv. Man benutzt einfach den Datentyp als Funktion und als Parameter nimmt man die umzuwandelnde Variable.

·         Ganzzahl (int) zu Gleitkommazahl (float):              float(5)

·         Gleitkommazahl (float) zu Ganzzahl (int):              int(5.345)

·         Ganzzahl (int) zu Zeichenkette(str):                         str(5)

·         Zeichenkette(str) zu Ganzzahl (int):                         str(«7»)

·         Gleitkommazahl (float) zu Zeichenkette(str):        str(5.345)

·         Zeichenkette(str) zu Gleitkommazahl (float):        float(«5.345»)

Eingabe: input () Funktion, eval() Funktion

Wir haben bis jetzt gesehen, wie man Werte (Zahlen, Zeichenfolgen) mittels der print() Anweisung in der Shell (oder in einer Datei) ausgeben kann, wie man mit Zahlen rechnen kann, und wie man mit Variablen arbeiten bzw. Werte in Variablen speichern kann. Für unser EVA (Eingabe – Verarbeitung – Ausgabe) Prinzip fehlt uns noch die erste Komponente: die Eingabe von Werten. 

Eingabefunktion Input()

Programme benötigen in aller Regel Eingaben. Der User (Nutzer des Computers, Anwender) gibt dem Computer Informationen, welche dieser dann weiterverarbeitet. Beispielsweise ein Datum, einen Spielernamen, einen Text für einen Brief, u.v.m.

Eingaben, welche anschliessend von einem Programm verarbeitet werden, können über viele Wege erfolgen. Man kann Daten aus einer abgespeicherten Datenbank einlesen oder Daten von einem Sensor erhalten, beispielsweise über eine Mausbewegung. Die einfachste und auch ursprünglichste Form der Eingabe erfolgt jedoch über die Tastatur. Für diese Form der Eingabe bietet Python die Funktion input().

Kommt es in Python zum Aufruf der Funktion input(), dann wird der Programmablauf solange gestoppt, bis der Benutzer eine Eingabe über die Tastatur getätigt hat (d.h. diese mit der Return-Taste abschliesst). Die Eingabe des Benutzers erfolgt direkt in der Shell, welche ja quasi die Python Standard- Interaktionsschnittstelle zum Benutzer ist. Für Eingaben über andere Interaktionsschnittstellen (Beispielsweise einem Tkinter Fenster Eingabefeld) muss man andere Anweisungen nutzen.

Hierzu ein kleines Beispiel:

print("Wie heisst Du? ")
name = input()
print("Aha, dein Name ist", name)

Das Programm führt zu folgender Ausgabe in der Shell:

Das Programm funktioniert einfach. Die erste Zeile gibt einen Text (hier eine Frage) aus. Anschliessend kommt die Eingabefunktion. Hier kann der User einen Namen eingeben, welcher dann in der Variable name gespeichert wird. Optional kann man übrigens der Funktion auch gleich direkt eine Zeichenkette übergeben, welche dem User angezeigt wird. Beispielsweise für einen erklärenden Text. 

name = input("Wie heisst Du? ")
print("Aha, dein Name ist", name)

Die direkte Angabe ist übersichtlicher und hat darüber hinaus den Vorteil, dass die Eingabe in der Shell in derselben Zeile erfolgt, wie die Frage steht.

Wichtig ist, dass die Anweisung name = input() aus zwei Bestandteilen besteht. Der erste, hintere Teil der Zeile, beinhaltet die die Anweisung input(), welche die Eingabe des Users abwartet und liestDer zweite, vordere Teil der Zeile, ist eine klassische Zuweisung, welche wir bereits kennen. Die Eingabe des Users muss irgendwo gespeichert werden, so dass wir später wieder auf diese zugreifen können. 

Die Anweisung input() ist ein sog. Funktionsaufruf. Eine Funktion ist nichts anderes als ein eigens kleines Programm. Dieses Programm liest die Zeichen, welche der User auf der Tastatur eingibt, solange bis dieser die Return/Enter Taste betätigt hat. Python hat also diese Funktionalität (dieses kleine Programm) schon bereits mit dabei – wir müssen es nicht selber schreiben. Am Ende gibt uns die Funktion die gelesene Eingabe als eine einzelne Zeichenkette heraus. Sie gibt uns also nicht «H», 0.1s warten, «a», 0.5s warten, «n», wieder zurück, nochmals «n», … sondern direkt «Hans Meier» heraus.

Zur Illustration nochmals eine Eingabe in der Shell

Unter In[1] haben wir den klassischen Input Funktionsaufruf mit anschliessender Zuweisung des Rückgabewerts an die Variable (an das Objekt, auf welches der Name name referenziert) gemacht. Unter In[2] haben wir dann die Zuweisung weggelassen. Python zeigt uns den Rückgabewert an. Danach ist er vergessen. Wollen wir mit diesem Objekt später nochmals arbeiten (wollen wir es im Lager finden), dann müssen wir deshalb stets einen Namen definieren und mit diesem auf die ID des Objekts (oder einer Kopie davon) verweisen. Dies geschieht über die Zuweisung .

Eingabe von Zahlen

Da man bei Python keine Variablendeklaration zu machen braucht, ist die Variable name im Beispielcode automatisch eine string Variable. Auch dann, wenn man eine Zahl eingib. Die input() Funktion liefert immer eine Zeichenkette zurück, also auch wenn der Benutzer eine Zahl eingibt. 

Damit haben wir ein Problem, sobald wir mit der Eingabe beispielsweise rechnen wollen. Jeder Datentyp hat seine eigenen Methoden (Werkzeugkasten). So werden beispielsweise mit dem + Operator Objekte vom Datentyp int oder float addiert, aber Objekte vom Datentyp str verkettet (aneinandergereiht). 

Möchte man, dass Python das eingegebene Zeichen «3» als Zahl versteht, so müssen wir es zuerst umwandeln. Eine Umwandlung können wir beispielsweise über den gleichnamigen Cast Operator int() für Ganzzahlen oder float() für Kommazahlen vornehmen. In der Regel macht man die Umwandlung direkt auf das Rückgabeobjekt, vor der Zuweisung, so dass alles in einer einzelnen Zeile steht.

Exkurs: eval() Funktion

Es gibt in Python Befehle zur Ausführung von Python Code zur Laufzeit, namentlich exec() und eval(). Letzterer wird oftmals im Zusammenhang mit der input() Eingabefunktion genutzt.

Die eval() Funktion evaluiert, d.h. führt einfache Python Ausdrücke aus, während das Programm läuft. Analog, wie wenn der Benutzer die Eingabe in das Shell Prompt >>> bzw. In[] eingeben würde. Die auszuführende Anweisung wird ihr übergeben in Form der entsprechenden Zeichenfolge. Die Codezeile

print(eval("round(4.777,1)"))

führt zur Ausgabe von 4.8, genau gleich, wie wenn der Benutzer im interaktiven Modus im Shell die entsprechende Anweisung direkt eingibt. Dies wird von vielen Programmierern ausgenutzt, denn dadurch lässt sich die Eingabe einer Zahl automatisch in den richtigen Datentyp umwandeln. Aus diesem Grund schreibt man anstelle von var = int(input()) oder var = float(input) in der Regel:

var = eval(input(".."))

Doch warum weiss Python, dass es sich um eine Zahl und nicht eine Zeichenkette handelt. Hintergrund ist, dass Python bei einer Zahl zuallererst einmal von einer Fliesskommazahl bzw. einer Ganzzahl ausgeht – im Unterschied zum Input Funktionsaufruf, der per Definition eine Zeichenkette zurückgibt. Man kann dies im Shell überprüfen. Zur Eingabe der Zahl 3 im Shell tippt man einfach die 3, für die Zeichenfolge ‹3› muss man diese durch Anführungs- & Schlusszeichen markieren.

Damit ist man aber auch schon beim eigentlichen Problem der eval Funktion angekommen. Gibt der User eine Zeichenfolge im obigen Programm ein, so führt dies zu einem Fehler und entsprechend Programmabbruch. Den Python geht davon aus, dass es sich um eine Variable bzw. einen Namen (Referenz auf ein Objekt) handelt. Der User müsste also seine Zeichenfolge als Zeichenfolge markieren. Man kann das Problem entschärfen, indem man die Abfrage in einen try except Block einbindet.

Im Gegenzug hat man dafür aber die Möglichkeit, eben ganze Ausdrücke auszuwerten oder den Benutzer Listen und weitere Datentypen direkt eingeben zu lassen.

  1. 6+4)*2) # hier braucht es Klammern 10*2 = 20 print ((6+4)*2 %3) # und noch Modulo 20%3 = 6 Rest 2 (Modulo)

Die Ausführung des Programmcodes wird zu den Werten 14, 14, 20 und 2 führen.

Ebenso kann man mit negativen Zahlen rechnen, indem man einfach ein Minuszeichen vor die Zahl stellt. Und wiederum gelten die bekannten Gesetze der Mathematik. So ergibt 3 + -2 sinngemäss 1.

Im letzten Kapitel 3.1 haben wir hervorgehoben, dass man beim Programmieren einen Unterschied zwischen Zahlen (Zahlenwerten) und Zeichenketten (einzelnen Zeichen, Buchstaben) macht. Auch wenn die Ausgabe in der Shell immer als Zeichenkette erfolgt, so ist es wichtig, jeweils den richtigen Typ bei der Übergabe von Werten zu verwenden. Beim Rechnen wird nun der Unterschied zwischen der Übergabe von Zahlen und Zeichenketten besonders deutlich:

print (3+3)
print ("3"+"3")
print (3*3)   
print ("3"*3) 

Der Code führt zu folgender Ausgabe:

Wie Zahlen kann man auch Zeichenketten addieren und multiplizieren. Das Resultat ist dann einfach das Aneinanderreihen bzw. Vervielfachen der Zeichenketten. Die anderen Operatoren (Subtraktion, Division, etc.) sind bei Zeichenketten nicht zulässig.