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 zahl1, zahl2 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 i (anstelle zahl1), und im CPU Register D steht die Speicheradresse der Speicherstelle, an welcher der Wert von i 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.