Python-Grundlagen: Werte, Variablen und Ausdrücke

Ein Programm ist eine Folge von Anweisungen. Der Python-Interpreter liest Python-Code und führt diese Anweisungen aus. Verwende Python 3, wo ein Aufruf wie print("Hello") Klammern hat.

Eine Zeile in der Shell ausprobieren

Die interaktive Shell, auch REPL genannt, zeigt >>>, wenn sie für Python-Code bereit ist. Gib nach der Eingabeaufforderung eine Anweisung ein und drücke die Eingabetaste. Das >>> gibst du nicht selbst ein.

>>> 3 + 4
7
>>> "hi"
'hi'

Die Shell zeigt den Wert eines Ausdrucks automatisch an. Sie setzt eine Zeichenkette in Anführungszeichen, um sie als Text kenntlich zu machen. Die Eingabeaufforderung ... bedeutet, dass eine Anweisung unvollständig ist und Python auf weitere Eingaben wartet. Beispielsweise kann zu einer öffnenden Klammer noch die schließende fehlen. Gib bei einer bereiten Eingabeaufforderung exit() ein, um die Shell zu verlassen.

Die Shell ist nützlich, um einen einzelnen Ausdruck zu testen. Sie kann einen Befehlsverlauf speichern, aber dieser Verlauf ist kein gespeichertes Programm. Setze Anweisungen, die du erneut gemeinsam ausführen möchtest, in ein Skript.

Ein Skript speichern und ausführen

Ein Skript ist eine reine Textdatei mit Code und der Endung .py. Verwende einen Code-Editor wie IDLE, Thonny oder VS Code. IDLE gehört zur Standarddistribution von Python. Eine Textverarbeitung kann gerade Anführungszeichen in typografische Anführungszeichen ändern; diese können Python-Zeichenketten nicht begrenzen.

Gib diese Zeilen im Editor ein und speichere das Skript:

print("Hello, world!")
print("Welcome to Python.")

Wähle in IDLE Run → Run Module oder drücke F5. Die Ausgabe lautet:

Hello, world!
Welcome to Python.

Python führt diese Anweisungen von oben nach unten aus. Jeder print()-Aufruf zeigt seinen Text an und beginnt eine neue Zeile. Wenn du die Anweisungen umkehrst, kehrt sich die Ausgabe um.

Du kannst ein gespeichertes Skript auch von einem Terminal aus ausführen. Öffne den Ordner mit deinem Skript und gib den Interpreterbefehl gefolgt vom gespeicherten Namen ein. Unter macOS oder Linux ist der Befehl üblicherweise python3 gefolgt vom Skriptnamen; unter Windows wird häufig python oder py verwendet. Der Terminalbefehl startet den Interpreter und gibt an, welches Skript er ausführen soll. Dieser Befehl gehört an die Eingabeaufforderung des Terminals, nicht hinter Pythons >>>. Ein Online-Editor kann stattdessen eine Schaltfläche zum Ausführen bereitstellen.

Entscheiden, was ausgegeben werden muss

Ein Skript, das nur 3 + 4 enthält, berechnet einen Wert, zeigt aber nichts an. Schreibe print(3 + 4), um 7 anzuzeigen. Ebenso zeigt print("hi") den Text ohne die umgebenden Anführungszeichen. Die Anführungszeichen gehören zum Code; sie markieren Anfang und Ende des Textes.

Python beachtet die Groß- und Kleinschreibung. print und Print sind verschiedene Namen, sodass Print("hi") einen NameError erzeugt, sofern dieser eigenständige Name nicht definiert wurde. Übernimm Schreibweise und Groß- und Kleinschreibung eingebauter Namen genau wie angegeben.

Auch vorangestellte Leerzeichen haben eine Bedeutung. Beginne bei diesen einfachen Folgen von Anweisungen jede Anweisung am linken Rand. Eine versehentliche Einrückung vor print("hi") kann IndentationError: unexpected indent verursachen. Leerzeichen innerhalb des Textes in Anführungszeichen sind etwas anderes: Python gibt sie als Teil der Nachricht aus.

Ein Fehler in einem Programm ist ein Programmfehler. Ihn zu finden und zu beheben, heißt Fehlersuche und Fehlerbehebung. Bestimme zuerst, welche Art von Problem vorliegt: Code, den Python nicht lesen kann, eine Operation, die während der Ausführung fehlschlägt, oder ein Ergebnis, das schlicht falsch ist.

Drei Arten von Problemen

Python prüft vor der Ausführung die Syntax des gesamten Skripts. Ein Syntaxfehler nahe dem Ende verhindert sogar die Ausführung der ersten Zeile. Bei einem Laufzeitfehler ist das anders: Frühere Anweisungen wurden bereits ausgeführt und ihre Ausgabe bleibt sichtbar.

Beim arithmetischen Mittel erfolgt die Division vor der Addition. Python berechnet 92 / 2 als 46.0 und addiert dann 88, sodass 134.0 herauskommt. Der gewünschte Ausdruck ist (88 + 92) / 2, der 90.0 ergibt. Es gibt keine Fehlermeldung, weil beide Ausdrücke zulässig sind. Eine Rechnung von Hand liefert dir einen Vergleich für das Programm.

Einen Traceback von unten lesen

Angenommen, der Code lautet:

name = "Ada"
print("Hello", nme)

Der Traceback endet mit einer Meldung wie NameError: name 'nme' is not defined. Die letzte Zeile nennt den Fehler und erklärt, was fehlgeschlagen ist. Darüber zeigt Python die Stelle, die Zeilennummer und den Code. Vergleiche nme mit dem Namen, dem zuvor ein Wert zugewiesen wurde: name. Wenn du die Schreibweise korrigierst, lautet die Ausgabe Hello Ada.

Die gemeldete Stelle ist dort, wo Python das Problem bemerkt hat. Sieht eine Zeile richtig aus, prüfe auch die Zeile davor. Ein zuvor fehlendes Anführungszeichen oder eine fehlende Klammer kann dazu führen, dass Python den folgenden Code nicht versteht. Aktuelle Versionen zeigen oft direkt auf die nicht geschlossene öffnende Klammer.

Den Fehlertyp als Suchhilfe nutzen

• NameError: Python findet einen Namen nicht, wie bei pirnt, Print oder einer Variablen, die vor ihrer Zuweisung verwendet wird. Prüfe Schreibweise, Groß- und Kleinschreibung und Reihenfolge der Zeilen.
• TypeError: Die Operation funktioniert mit diesen Datentypen nicht. "5" + 5 versucht, Text und eine Zahl zu verknüpfen.
• ValueError: Eine Umwandlung erhält unbrauchbaren Inhalt. int("abc") erhält Text, aber der Text beschreibt keine ganze Zahl.
• ZeroDivisionError: Ein Divisor ist null. Untersuche den Wert nach /, // oder %.

Prüfe bei einem SyntaxError, ob jedes öffnende Anführungszeichen und jede öffnende Klammer geschlossen wird. print('It's late') beendet die Zeichenkette beim Apostroph in „It's“; verwende print("It's late"). Python-2-Code wie print "hi" braucht die Klammern von Python 3: print("hi"). Ersetze typografische Anführungszeichen durch gerade. Entferne bei einer unerwarteten Einrückung die versehentlichen Leerzeichen am Anfang der Zeile.

Behebe ein Problem und führe das Programm erneut aus. Der erste Fehler kann verhindert haben, dass Python einen zweiten erreicht. Erstelle ein Programm jeweils um wenige Zeilen weiter, damit du bei jedem neuen Fehler nur einen kleinen Bereich untersuchen musst.

Code sagt Python, was es tun soll. Ein Kommentar erklärt einem Menschen, warum der Code es tut oder was ein Wert bedeutet. Python ignoriert einen Kommentar bei der Ausführung des Programms.

Den Kommentar klar kennzeichnen

Ein Kommentar beginnt mit # außerhalb einer Zeichenkette und reicht bis zum Ende der Zeile. Er kann allein stehen oder auf eine Anweisung folgen:

# Convert a temperature from Fahrenheit to Celsius.
fahrenheit = 68
celsius = (fahrenheit - 32) * 5 / 9
print(celsius)  # Show the converted temperature.

Der Kommentar in einer eigenen Zeile erklärt den Zweck des Programms. Der Kommentar am Zeilenende folgt auf Code in derselben Zeile. PEP 8, der Stilratgeber von Python, empfiehlt mindestens zwei Leerzeichen vor einem # am Zeilenende und ein Leerzeichen danach. Durch diese Abstände ist die Grenze leicht zu erkennen.

Ein Rautezeichen innerhalb von Anführungszeichen ist gewöhnlicher Text:

print("#1 is not a comment")  # This part is a comment.

Die Ausgabe lautet #1 is not a comment. Python liest die gesamte Zeichenkette in Anführungszeichen einschließlich ihres Rautezeichens als Daten. Den Text nach dem späteren # ignoriert es, weil dieses Zeichen außerhalb der Anführungszeichen steht.

Bedeutung statt offensichtlicher Schritte erklären

Vergleiche diese Kommentare:

count = count + 1  # Add 1 to count.
attempts = attempts + 1  # One more failed login.

Der erste Kommentar wiederholt eine Operation, die bereits im Code sichtbar ist. Der zweite ergänzt einen Grund für die Änderung. Wer den Code liest, weiß nun, was gezählt wird. Ein klarer Name wie attempts übernimmt ebenfalls einen Teil der Arbeit, die bei einem ungenauen Namen den Kommentaren bliebe.

Nützliche Kommentare erklären eine Einheit, eine Entscheidung oder einen Zweck, die der Code allein nicht deutlich macht. Zum Beispiel verbindet tax_rate = 0.08 # 8% sales tax einen Dezimalsatz mit seiner Bedeutung. Wenn du diesen Satz später änderst, prüfe auch den Kommentar. Ein veralteter Kommentar kann in die falsche Richtung führen, selbst wenn der Code funktioniert.

Die Ausführung einer Zeile vorübergehend verhindern

Um eine Anweisung auszukommentieren, setze # davor:

print("Start")
# print("Checking this step")
print("Finish")

Nur Start und Finish erscheinen. Durch das Auskommentieren bleibt eine Zeile verfügbar, während du das Programm ohne sie testest. Entferne alten deaktivierten Code, wenn er nicht mehr hilft; sonst muss später geraten werden, ob er noch gebraucht wird.

Beginne für eine Notiz über mehrere Zeilen jede Zeile mit #:

# Read the temperature in degrees Fahrenheit.
# Keep the calculation in Celsius for the next step.

Text in dreifachen Anführungszeichen ist etwas anderes. Eine Zeile wie """Convert a temperature.""" ist ein Zeichenkettenausdruck, kein Kommentar. Solche Zeichenketten können an bestimmten Stellen als Dokumentation dienen und heißen Docstrings. Verwende #, wenn du einen gewöhnlichen Kommentar meinst. Eine Zeichenkette, die nichts verwendet, kann in einem Skript unsichtbar bleiben. Dadurch kann sie wie ein Kommentar aussehen, obwohl Python sie als Wert liest.

Ein Wert ist ein Datum, zum Beispiel 42, 3.5 oder "Ada". Jeder Wert hat einen Datentyp, der Python sagt, um welche Art von Daten es sich handelt. Ein Literal ist ein Wert, der direkt im Code steht. Seine Schreibweise ist wichtig: 7, 7.0 und "7" haben verschiedene Datentypen.

Vier grundlegende Datentypen

Ein Dezimalpunkt macht 2.0 zu einem float, obwohl der Zahlenwert gleich der ganzen Zahl 2 ist. Anführungszeichen machen "42" zu Text, obwohl die Zeichen wie eine Zahl aussehen. Der Datentyp ergibt sich aus dem geschriebenen Wert, nicht daraus, wofür jemand ihn verwenden könnte.

Boolesche Literale haben einen großen Anfangsbuchstaben und keine Anführungszeichen. True ist ein boolescher Wert; "True" ist eine Zeichenkette. Das kleingeschriebene true ist ein Name. Wird er ohne Definition verwendet, ergibt das einen NameError. Ein Vergleich kann einen booleschen Wert erzeugen: 3 < 5 wird zu True ausgewertet.

Python nach dem Datentyp fragen

Die eingebaute Funktion type() gibt den Datentyp ihres Arguments an. In der Shell zeigen diese Aufrufe:

>>> type(7)
<class 'int'>
>>> type(7.0)
<class 'float'>
>>> type("7")
<class 'str'>
>>> type(True)
<class 'bool'>

Verwende in einem Skript print(), um diese Ergebnisse zu sehen:

print(type(42), type("42"))

Das gibt <class 'int'> <class 'str'> aus. Das Wort class ist Teil der Ausgabe von Python; die Namen int und str bezeichnen die Datentypen.

Datentypen ändern die Bedeutung von Operatoren

Bei Zahlen addiert +. Bei zwei Zeichenketten verknüpft es Text:

print(5 + 3)
print("5" + "3")

Die erste Zeile gibt 8 aus. Die zweite gibt 53 aus. Der zweite Ausdruck enthält zwei Textwerte, also verknüpft Python ihre Zeichen. Es untersucht die Ziffernzeichen nicht, um dann zu entscheiden, sie zu addieren.

"5" + 5 löst einen TypeError aus: Ein Operand ist Text und der andere eine ganze Zahl. Prüfe die Datentypen, wenn sich eine Operation anders verhält als erwartet. Insbesondere beweisen Ziffern auf dem Bildschirm nicht, dass der gespeicherte Wert eine Zahl ist.

Einen zur Bedeutung passenden Datentyp wählen

Verwende eine ganze Zahl für eine Anzahl und eine Gleitkommazahl für einen Messwert, der einen Bruchteil enthalten kann. Speichere einen Identifikator wie eine Postleitzahl als Text. Die Zeichenkette "02134" bewahrt die führende null; sie gehört zur Kennung und nicht zu einer Berechnung. Auch Telefonnummern können Satzzeichen enthalten, die erhalten bleiben sollen.

Die Shell kann 'Ada' zeigen, während print("Ada") den Wert Ada zeigt. Beide beziehen sich auf denselben Text. Die Anführungszeichen der Shell kennzeichnen eine Zeichenkette; print() stellt die Zeichen für Leserinnen und Leser dar. Keine der beiden Anzeigen ändert den gespeicherten Datentyp.

Python hat getrennte Datentypen für ganze Zahlen und Gleitkommazahlen. Wenn du sie klar schreibst, verhinderst du sowohl Syntaxfehler als auch weniger offensichtliche Änderungen der Daten.

Anzahlen als ganze Zahlen schreiben

Eine ganze Zahl hat keinen Bruchteil. Schreibe einen int ohne Dezimalpunkt, wie in 42, 0 oder -7. Ganze Zahlen in Python können so groß werden, wie es der verfügbare Speicher erlaubt; es gibt keine feste Begrenzung ihrer Stellenzahl. Addition, Subtraktion und Multiplikation ganzer Zahlen sind exakt. Zum Beispiel ergibt 2 ** 100 die exakte ganze Zahl 1267650600228229401496703205376.

Verwende keine Kommas zur Tausendergruppierung. Schreibe 1000000 oder verwende zur besseren Lesbarkeit Unterstriche: 1_000_000. Die Unterstriche ändern den Wert nicht.

Ein dezimales Literal für eine ganze Zahl ungleich null darf nicht mit einer null beginnen. 02134 zu schreiben ist ein Syntaxfehler. Sind diese Ziffern ein Identifikator, bei dem die erste null wichtig ist, schreibe "02134" als Text.

Größen mit Bruchteilen als Gleitkommazahlen schreiben

Ein float verwendet einen Dezimalpunkt oder die Exponentenschreibweise. 3.5, 2.0 und -0.25 sind Gleitkommazahlen. Python akzeptiert auch .5 und 5., was 0.5 und 5.0 bedeutet; die zusätzliche null macht die Schreibweise oft leichter lesbar. Verwende Gleitkommazahlen für Messwerte wie Temperatur oder Entfernung und für einfache Berechnungen mit Preisen, die Bruchteile enthalten.

Python-Code verwendet einen Dezimalpunkt. Ein Komma trennt Werte; es kennzeichnet niemals den Nachkommateil. Zum Beispiel:

x = 3.5
print(x)

gibt 3.5 aus, während x = 3,5 ein Wertepaar erzeugt, das als (3, 5) angezeigt wird. Ebenso erzeugt x = 1,000 den Wert (1, 0), nicht eintausend. Diese Anweisungen können ausgeführt werden. Das Ausbleiben einer Fehlermeldung bedeutet also nicht, dass die Zahl richtig geschrieben wurde.

Wissenschaftliche Schreibweise verwenden

Der Buchstabe e bedeutet in einem Zahlenliteral „mal zehn hoch“:

Ein Literal mit Exponent ist ein float, selbst wenn sein Wert eine ganze Zahl ist. Das Minuszeichen nach e ergibt einen negativen Exponenten, sodass 2.5e-3 gleich 2,5 dividiert durch 1.000 bedeutet.

Mit begrenzter Genauigkeit rechnen

Gleitkommazahlen speichern Zahlen binär mit begrenzter Genauigkeit, üblicherweise etwa 15–17 signifikanten Dezimalstellen. Viele Dezimalbrüche, darunter 0.1, haben in dieser Speicherung keine exakte Darstellung. Daher:

print(0.1 + 0.2)
print(round(0.1 + 0.2, 2))

werden 0.30000000000000004 und dann 0.3 ausgegeben. Der winzige Unterschied entsteht durch die gespeicherten Näherungswerte. round(..., 2) rundet das Ergebnis für die Anzeige auf zwei Nachkommastellen; es ändert nicht, wie Gleitkommazahlen Werte speichern. Behalte die ursprüngliche Berechnung bis zum Ende bei und runde dann das angezeigte Ergebnis.

Ein Vorzeichen kann auch ein Operator sein. Das unäre Minus kehrt das Vorzeichen eines Werts um: -7 ist minus sieben. In 5 - -3 subtrahiert das erste Minus und das zweite ergibt minus drei, sodass das Ergebnis 8 ist. Unterscheide dieses Vorzeichen vom negativen Exponenten in einem Literal wie 2.5e-3.

Eine Zeichenkette ist eine Folge von Zeichen: Buchstaben, Ziffern, Leerzeichen, Satzzeichen und anderen Symbolen. Anführungszeichen sagen Python, wo diese Folge beginnt und endet. Die Zeichen darin sind Daten, auch wenn sie wie Python-Code aussehen.

Passende Anführungszeichen wählen

Einfache und doppelte Anführungszeichen erzeugen denselben Datentyp str. Sowohl 'Ada' als auch "Ada" enthalten dieselben drei Zeichen. Beginne und beende eine Zeichenkette mit derselben Art von Anführungszeichen.

Wähle die äußeren Anführungszeichen so, dass sich ein inneres Anführungszeichen leicht schreiben lässt:

print("It's late")
print('She said "hi"')

Die Ausgabe lautet:

It's late
She said "hi"

In print('It's late') schließt der Apostroph nach It die Zeichenkette zu früh. Python kann den Rest der Anweisung dann nicht lesen. Doppelte äußere Anführungszeichen halten den Apostroph innerhalb des Textes.

Eine Escape-Sequenz verwenden

Ein umgekehrter Schrägstrich beginnt eine Escape-Sequenz. Diese gebräuchlichen Sequenzen stehen jeweils für ein Zeichen:

Zum Beispiel gibt print("Line 1\nLine 2") zwei Zeilen aus. Der umgekehrte Schrägstrich und das n im Code stehen zusammen für einen Zeilenumbruch, nicht für einen sichtbaren Buchstaben n. Ebenso gibt print('It\'s late') den Text It's late aus: Das mit einem umgekehrten Schrägstrich versehene Anführungszeichen wird zu einem Zeichen, ohne die Zeichenkette zu beenden.

Um einen wörtlichen umgekehrten Schrägstrich gefolgt von einem Buchstaben auszugeben, schreibe den umgekehrten Schrägstrich doppelt. print("A\\B") zeigt A\B. Der erste umgekehrte Schrägstrich signalisiert, dass der nächste ein Zeichen sein soll.

Zeilenumbrüche beibehalten oder keine Zeichen verwenden

Mit dreifachen Anführungszeichen kann eine Zeichenkette mehrere physische Zeilen umfassen. Die Zeilenumbrüche werden Teil ihres Werts:

print("""Line one
Line two""")

Das gibt Line one und Line two in getrennten Zeilen aus. Dreifache einfache Anführungszeichen funktionieren ebenfalls. Dreifache Anführungszeichen erzeugen weiterhin eine Zeichenkette; sie erzeugen keinen #-Kommentar.

Die leere Zeichenkette "" hat keine Zeichen. Sie unterscheidet sich von " ", das ein Leerzeichen enthält. Dieses Leerzeichen ist in der Ausgabe möglicherweise schwer zu sehen, bleibt aber Teil der Daten.

Text von einem Ausdruck oder Namen unterscheiden

Vergleiche diese Anweisungen:

name = "Ada"
print("3 + 4")
print(3 + 4)
print("name")
print(name)

Die Ausgabe lautet 3 + 4, dann 7, dann name, dann Ada. Die Anführungszeichen machen das erste und das dritte Argument zu wörtlichem Text. Ohne Anführungszeichen wertet Python eine Berechnung aus oder schlägt eine Variable nach.

Vergisst du die Anführungszeichen um eine Nachricht wie Hello, sucht Python nach einem Namen. Wenn Hello nicht definiert wurde, löst print(Hello) einen NameError aus. Schreibe print("Hello"), wenn du dieses Wort ausgeben möchtest.

Zeichenketten können Zeichen aus vielen Sprachen und Symbole wie "café", "naïve" und "°F" enthalten. Daneben können Ziffern stehen: "Room 101" ist durchgehend Text. Ein Ziffernzeichen in Anführungszeichen wird nicht zu einer ganzen Zahl.

Eine Variable ist ein Name, der auf einen Wert im Speicher verweist. Eine Zuweisung verbindet einen Namen links von = mit dem Wert eines Ausdrucks rechts davon.

Zuerst die rechte Seite lesen

In age = 30 wertet Python 30 aus und lässt dann age auf diese ganze Zahl verweisen. Die linke Seite muss eine zulässige Stelle für die Zuweisung eines Werts sein. 30 = age ist ein Syntaxfehler: Du kannst dem Literal 30 keinen neuen Wert zuweisen.

Das Zeichen = bedeutet „weise zu“. Es fragt nicht, ob zwei Werte gleich sind. Für die Gleichheitsprüfung wird == verwendet. Wenn du die Zuweisung als Arbeitsrichtung liest, werden Anweisungen wie x = x + 1 verständlich: Verwende rechts den alten Wert von x, berechne den neuen Wert und weise ihn dann links x zu.

Betrachte ein Rechteck:

width = 4
height = 2.5
area = width * height
print(area)

Nach der ersten Zeile verweist width auf 4. Nach der zweiten verweist height auf 2.5. Für die dritte Zeile schlägt Python beide aktuellen Werte nach und wertet 4 * 2.5 aus, was 10.0 ergibt. Es weist dieses Ergebnis area zu. Die letzte Zeile gibt 10.0 aus.

Die Zuweisung selbst gibt den Wert nicht aus. Verwende den Namen in einem späteren print()-Aufruf, wenn du ihn anzeigen möchtest.

Vor der Verwendung eines Namens einen Wert zuweisen

Python folgt der Reihenfolge der Anweisungen. Dieser Code schlägt in der ersten Zeile fehl:

print(total)
total = 10

Zu diesem Zeitpunkt hat total keinen Wert. Die spätere Zuweisung kann einer früheren Anweisung keinen Wert liefern. Verschiebe total = 10 vor print(total).

Eine Shell kann Namen aus früheren Versuchen behalten. Ein gespeichertes Programm sollte die benötigten Zuweisungen in seiner eigenen Ausführungsreihenfolge bereitstellen, damit sein Ergebnis nicht davon abhängt, was du zuvor eingegeben hast.

Einem bestehenden Namen erneut einen Wert zuweisen

Eine erneute Zuweisung lässt einen Namen auf einen neuen Wert verweisen:

score = 10
score = 15

Nun ist score gleich 15; der frühere Wert 10 ist über diesen Namen nicht mehr erreichbar. Für eine Aktualisierung auf Grundlage des alten Werts:

x = 3
x = x + 1

Die zweite Zeile wertet 3 + 1 aus und weist dann x den Wert 4 zu. Es gibt weder eine zu lösende Gleichung noch einen Widerspruch.

Ein Datentyp gehört zum Wert, nicht dauerhaft zum Variablennamen. Python erlaubt temp = 3 gefolgt von temp = "three"; danach gibt type(temp) den Datentyp str an. Ein Programm lässt sich meist leichter nachvollziehen, wenn Bedeutung und erwarteter Datentyp eines Namens gleich bleiben.

Ein kopierter Wert ist keine zukünftige Verknüpfung

a = 5
b = a
a = 10
print(a, b)

Das gibt 10 5 aus. Bei b = a verweisen beide Namen auf die aktuelle ganze Zahl 5. Eine erneute Zuweisung an a ändert, auf welchen Wert a verweist; b verweist weiterhin auf 5. Ebenso speichert die Zuweisung von width * height das Ergebnis, keine Formel, die sich bei einer Änderung von width selbst aktualisiert.

Eine Anweisung kann mehreren Namen Werte zuweisen. a = b = 0 gibt beiden Namen den Wert 0. In x, y = 1, 2 werden die Werte den Namen anhand ihrer Position zugeordnet, sodass x gleich 1 und y gleich 2 wird.

Ein Name muss Pythons Grammatik entsprechen und Menschen helfen, das Programm zu verstehen. Das sind zwei getrennte Anforderungen: Python kann einen Namen akzeptieren, der den Code trotzdem schwer lesbar macht.

Die Namensregeln beachten

Ein Variablenname darf Buchstaben, Ziffern und Unterstriche enthalten. Er darf nicht mit einer Ziffer beginnen, kein Leerzeichen enthalten und keine Satzzeichen wie einen Bindestrich verwenden.

Python akzeptiert auch Buchstaben aus anderen Alphabeten. Englische Buchstaben sind eine häufige Wahl für Bezeichner. Welche Buchstaben du auch wählst, behalte die Schreibweise bei: age, Age und AGE sind drei verschiedene Namen. Die Zuweisung age = 30 definiert Age nicht.

Schlüsselwörter und eingebaute Namen unterscheiden

Ein Schlüsselwort ist für Pythons Grammatik reserviert. Du kannst es nicht als Variablennamen verwenden. Die fest reservierten Schlüsselwörter sind:

False None True and as assert async await break class
continue def del elif else except finally for from
global if import in is lambda nonlocal not or pass
raise return try while with yield

Du musst die Liste nicht auswendig lernen, bevor du ein Programm schreibst. Fürs Erste reicht es zu erkennen, dass ein Name wie class nicht zur Verfügung steht: class = 3 ist ein Syntaxfehler. Editoren zeigen Schlüsselwörter oft in einer besonderen Farbe an.

Namen eingebauter Funktionen, darunter print, input, int, str, type, sum und max, sind keine Schlüsselwörter. Python erlaubt dir, ihnen Werte zuzuweisen, aber diese Zuweisung verdeckt die ursprüngliche Funktion:

print = 5
print("hi")

Die zweite Zeile versucht, die ganze Zahl 5 aufzurufen, und löst einen TypeError aus. Wähle einen Namen, der deine Daten beschreibt, etwa total, damit die eingebaute Funktion verfügbar bleibt. Ein Neustart der Shell macht versehentliche Ersetzungen aus Versuchen rückgängig.

Namen einheitlich schreiben

PEP 8 empfiehlt snake_case für Variablennamen: kleingeschriebene Wörter, die durch Unterstriche verbunden sind, wie in hourly_rate und first_name. Der Unterstrich hält einen Namen aus mehreren Wörtern ohne Leerzeichen zusammen.

Eine Konstante ist ein Wert, der unverändert bleiben soll. Üblicherweise wird ihr Name in Großbuchstaben geschrieben:

SALES_TAX_RATE = 0.08

Python sperrt diesen Namen nicht. Eine spätere Zuweisung kann ihn ändern; die Großbuchstaben teilen den Lesenden eine Absicht mit.

Bedeutung und Einheiten angeben

hours_worked = 38 sagt dir mehr als h = 38. Ein Name wie distance_miles oder temp_f nennt auch die Einheit. So sinkt die Gefahr, Meilen wie Kilometer oder Fahrenheit wie Celsius zu behandeln. Kurze Namen wie x und y eignen sich für Koordinaten oder eine kurze Formel, bei der ihre Bedeutung bereits klar ist.

Vermeide fast identische Namen wie total und totl. Ein Tippfehler kann einen NameError erzeugen oder versehentlich eine andere vorhandene Variable verwenden. PEP 8 rät auch von den einzelnen Buchstaben l, O und I ab, die wie Ziffern aussehen können. Einige zusätzliche Buchstaben können eine Berechnung viel leichter nachvollziehbar machen.

Eine Aktualisierung berechnet aus dem aktuellen Wert einer Variablen ihren nächsten Wert. Wenn du jede Aktualisierung der Reihe nach verfolgst, kannst du die Ausgabe vorhersagen und Logikfehler finden, bevor du das Programm ausführst.

Vor der Aktualisierung einen Anfangswert zuweisen

count = count + 1 addiert eins zum alten Zählerwert. Diese Änderung ist ein Inkrement. Eine Variable, die eine laufende Summe sammelt, ist ein Akkumulator. Gib ihr einen Anfangswert wie total = 0, bevor du Werte addierst.

Eine erweiterte Zuweisung verbindet eine Operation mit einer Zuweisung. Bei Zahlen hat x += 3 dieselbe Wirkung wie x = x + 3. Zu den verfügbaren Formen gehören +=, -=, *=, /=, //=, %= und **=.

score = 10
score -= 3
score **= 2
print(score)

Die Subtraktion ändert score zu 7. Die Potenzierung ändert den Wert dann zu 49, das ausgegeben wird. Ohne die anfängliche Zuweisung würde die Aktualisierung versuchen, einen nicht definierten Namen zu verwenden, und einen NameError auslösen.

Der gewählte Operator beeinflusst auch den Datentyp. Ausgehend von n = 7 erzeugt n /= 2 den float 3.5. Erneut ausgehend von n = 7 erzeugt n //= 2 die ganze Zahl 3. Python hat keinen Inkrementoperator ++: x++ ist ungültig. ++x wendet das unäre Plus zweimal an und aktualisiert x nicht; verwende x += 1.

Eine Anweisung nach der anderen nachvollziehen

Eine Ablauftabelle hält die Variablenwerte nach jeder Anweisung fest. Schreibe eine Spalte pro Variable und eine Zeile pro Schritt:

price = 20
quantity = 3
total = price * quantity
price = 25
total += 5
print(total, price)

Die Ausgabe lautet 65 25. Die Änderung von price hat die frühere Multiplikation nicht wiederholt. Die Variable total enthielt den berechneten Wert 60; sie war keine mit price verknüpfte Tabellenformel. Erst ihre spätere Aktualisierung änderte den Wert zu 65.

Werte beim Nachvollziehen von Hand die rechte Seite anhand der Zeile direkt darüber aus und aktualisiere dann den Namen, dem ein Wert zugewiesen wird. Lass alle anderen Spalten unverändert. Vergleiche die Vorhersage mit der tatsächlichen Ausgabe des Programms.

Beim Tausch beide Werte erhalten

Angenommen, a = 1 und b = 2. Der Versuch a = b gefolgt von b = a ergibt 2 2. Nach der ersten Zuweisung ist der ursprüngliche Wert von a über diesen Namen nicht mehr erreichbar, sodass die zweite Zeile den neuen Wert zurückkopiert.

Eine temporäre Variable hält den ursprünglichen Wert verfügbar:

a = 1
b = 2
temp = a
a = b
b = temp
print(a, b)

Das gibt 2 1 aus. Du kannst auch a, b = b, a schreiben. Python wertet beide Werte rechts aus, bevor es einem der Namen links einen Wert zuweist. So stehen beide ursprünglichen Werte für den Tausch zur Verfügung. Verfolge die Variante mit der temporären Variablen, wenn du genau sehen möchtest, wo jeder ursprüngliche Wert erhalten bleibt.

Ein Ausdruck wird zu einem Wert ausgewertet. Er kann ein einzelnes Literal, eine Variable oder eine Kombination wie 2 + 3 sein. Das + ist ein Operator; die Werte, auf die er angewendet wird, sind seine Operanden.

Den Operator wählen

Pythons arithmetische Operatoren funktionieren wie folgt:

Schreibe die Multiplikation ausdrücklich mit *. Eine mathematische Schreibweise wie 2x funktioniert nicht als Python-Multiplikation. Schreibe 2 * x oder 2 * (x + 1). Bei x = 1 versucht 2(x + 1), die ganze Zahl 2 wie eine Funktion aufzurufen, und löst einen TypeError aus.

Der Potenzoperator ist **, nicht ^. Zum Beispiel ist 7 ** 2 gleich 49, während 7 ^ 2 gleich 5 ist, weil das Zirkumflexzeichen eine andere Operation ausführt. Ein Programm kann also laufen und dabei ein unbeabsichtigtes Ergebnis berechnen.

Datentyp und Zahl vorhersagen

Eine Division mit / ergibt bei ganzzahligen Operanden einen float, selbst wenn die Division aufgeht: 6 / 2 ist 3.0. Verwende // für eine ganzzahlige Anzahl voller Gruppen: 6 // 2 ist 3.

Bei zwei ganzzahligen Operanden ergeben Addition, Subtraktion, Multiplikation, abrundende Division und Rest ganzzahlige Ergebnisse. Das gilt auch für nicht negative ganzzahlige Potenzen: 2 ** 10 ergibt die exakte ganze Zahl 1024. Ein negativer Exponent ändert das: 2 ** -1 ergibt den float 0.5.

Bei gewöhnlichen arithmetischen Berechnungen mit einer ganzen Zahl und einer Gleitkommazahl wird mit Gleitkommawerten gerechnet. 3 + 4.0 ergibt 7.0; 7.0 // 2 ergibt 3.0. Abrundende Division beschreibt, wie der Quotient gerundet wird, und verspricht nicht, dass sein Datentyp immer int ist.

Mit einem gebrochenen Exponenten lässt sich eine Wurzel aus einer positiven Zahl berechnen. 4 ** 0.5 ergibt 2.0 und 2 ** 0.5 ergibt ungefähr 1.4142135623730951.

Eine Berechnung aus benannten Werten aufbauen

Ein Auto fährt 287 Meilen mit 10,25 Gallonen:

miles = 287
gallons = 10.25
mpg = miles / gallons
print("Miles per gallon:", mpg)

Die Division berechnet 28.0, die Ausgabe lautet also Miles per gallon: 28.0. Die Namen bezeichnen die Größen und die ausgegebene Beschriftung nennt die Einheit des Ergebnisses. Die Multiplikation 28.0 * 10.25 ergibt wieder 287 Meilen und dient als Kontrolle der Division.

Ein Divisor null führt bei /, // und % zu einem Fehler. Zum Beispiel löst 10 / 0 einen ZeroDivisionError aus. Untersuche bei diesem Fehler eine Variable, die als Divisor verwendet wird.

Leerzeichen um Operatoren ändern ihre Bedeutung nicht: 2+3 und 2 + 3 ergeben beide 5. Leerzeichen um = und die meisten Operatoren machen die Teile leichter lesbar. Sie können keinen Operator ersetzen; 2 x bedeutet weiterhin keine Multiplikation.

Python berechnet einen Ausdruck nicht einfach vom linken bis zum rechten Rand. Der Vorrang legt fest, welche Operationen zuerst stattfinden. Mit Klammern kannst du eine andere Gruppierung wählen oder die beabsichtigte Gruppierung verdeutlichen.

Die Stufen der Reihe nach anwenden

Für die hier eingeführten Operatoren gilt diese Reihenfolge:

1. Ausdrücke in Klammern.
2. Potenzen, **.
3. Unäre Vorzeichen, etwa das Minus in -x.
4. Multiplikations- und Divisionsoperationen: *, /, //, %.
5. Addition und Subtraktion: +, -.

Werte bei 3 + 4 * 2 ** 2 den Ausdruck 2 ** 2 aus, um 4 zu erhalten. Der Ausdruck wird zu 3 + 4 * 4. Die Multiplikation ergibt 16 und die Addition 19. Bei (3 + 4) * 2 ** 2 ist die Summe in Klammern 7; die Potenz ist 4; das Produkt ist 28.

Operatoren auf der Multiplikations- und Divisionsstufe haben denselben Vorrang. Rechne von links nach rechts: 8 / 2 * 4 bedeutet (8 / 2) * 4 und ergibt 16.0. Die Multiplikation wird nicht vor der Division ausgeführt. Ebenso ergibt 100 / 10 / 5 den Wert 2.0 und 10 - 4 - 3 den Wert 3.

Mit Potenzen und Vorzeichen sorgfältig umgehen

Aufeinanderfolgende Potenzen werden von rechts nach links gruppiert. 2 ** 3 ** 2 bedeutet 2 ** (3 ** 2). Zuerst ergibt 3 ** 2 den Wert 9; dann ergibt 2 ** 9 den Wert 512. Eine Gruppierung von links würde 64 ergeben, also ein anderes Ergebnis.

Ein vorangestelltes Minuszeichen wird nach einer folgenden Potenzierung angewendet: -2 ** 2 bedeutet -(2 ** 2) und ergibt -4. In (-2) ** 2 machen die Klammern minus zwei zur Basis, sodass das Ergebnis 4 ist. Ein Minus nach ** kann zum Exponenten gehören: 2 ** -1 ergibt 0.5.

Die vollständige Gruppierung einer Formel übertragen

Für ein arithmetisches Mittel müssen beide Werte addiert werden, bevor durch zwei dividiert wird:

average = (88 + 92) / 2

Die Summe ist 180, die anschließende Division ergibt 90.0. Ohne Klammern dividiert 88 + 92 / 2 nur 92 und ergibt 134.0.

Ein Bruchstrich gruppiert ebenfalls alles darüber und darunter. Ein Zähler mit a + b und ein Nenner mit c + d werden zu (a + b) / (c + d). Lässt du eines der Klammerpaare weg, kann sich ändern, welche Terme dividiert werden.

Dasselbe Problem tritt bei einer Temperaturumrechnung auf:

celsius = (98.6 - 32) * 5 / 9

Die Subtraktion ergibt 66.6, die Multiplikation 333.0 und die Division 37.0. Ohne die Gruppierung ergibt 98.6 - 32 * 5 / 9 den Wert 80.82222222222222.

Die richtigen Gruppierungszeichen verwenden

Runde Klammern gruppieren einen Ausdruck. Eckige und geschweifte Klammern haben in Python andere Bedeutungen. Zum Beispiel erzeugt [2 + 3] * 4 den Wert [5, 5, 5, 5], nicht 20.

Klammern um eine Operation, die ohnehin zuerst ausgeführt würde, lassen das Ergebnis unverändert: Sowohl (2 * 3) + 1 als auch 2 * 3 + 1 ergeben 7. Klammern, die die Gruppierung ändern, können den Wert ändern: 2 * (3 + 1) ergibt 8. Ergänze Klammern, wo sie die Bedeutung der Berechnung leichter erkennbar machen.

Abrundende Division und Rest beantworten zwei zusammengehörige Fragen: Wie viele ganze Gruppen passen hinein und was bleibt nach diesen Gruppen übrig? Bei nicht negativen ganzzahligen Mengen ist das Paar für Zeit, Geld, Verpackungen und Ziffern nützlich.

Quotient und Rest gemeinsam bestimmen

17 // 5 ergibt 3, die Anzahl voller Fünfergruppen. 17 % 5 ergibt 2, die verbleibende Menge. Die beiden Ergebnisse ergeben zusammen wieder die Ausgangsmenge:

print((17 // 5) * 5 + 17 % 5)

Der Ausdruck ergibt 17: drei Fünfergruppen plus zwei. Allgemeiner ist für ganze Zahlen und einen Divisor ungleich null der Ausdruck (a // b) * b + a % b gleich a. Nutze diese Beziehung, um beide Antworten zu prüfen.

Konkrete Mengen aufteilen

Für 135 Minuten:

hours = 135 // 60
minutes = 135 % 60

Es sind 2 volle Stunden und 15 Minuten übrig. Der Divisor ist 60, weil eine Stunde 60 Minuten enthält. Die Division mit / ergibt 2.25, was Stunden mit einem Bruchteil ausdrückt; die verbleibenden Minuten werden dadurch nicht gesondert angegeben.

Dieselbe Struktur funktioniert mit einer anderen Gruppengröße:

Die Anzahl der Kartons ist die Anzahl der vollen Kartons. Falls du auch für die übrigen Eier einen Behälter brauchst, ist das eine andere Frage als die nach der Anzahl voller Gruppen.

Stellenwert und Parität nutzen

Bei einer positiven ganzen Zahl trennt die Division durch zehn ihre letzte Ziffer ab. 1234 % 10 ergibt 4 und 1234 // 10 ergibt 123. Die erneute Kombination 123 * 10 + 4 ergibt wieder 1234.

Für jede ganze Zahl n ist n % 2 gleich 0, wenn sie gerade ist, und gleich 1, wenn sie ungerade ist. Das funktioniert auch für negative Zahlen: -7 % 2 ist 1. Bei ganzen Zahlen und einem positiven Divisor b liegt der Rest im Bereich von 0 bis einschließlich b - 1.

Division mit negativen Zahlen verstehen

Die abrundende Division rundet in Richtung minus unendlich ab, nicht in Richtung null. Da minus sieben dividiert durch zwei −3,5 ist, ergibt -7 // 2 den Wert -4. Der Rest ist dann 1, weil -4 * 2 + 1 gleich -7 ist.

Ein Rest ungleich null hat das Vorzeichen des Divisors. Bei einem negativen Divisor ergibt 7 % -2 den Wert -1 und 7 // -2 den Wert -4. Auch diese ergeben zusammen wieder den Ausgangswert: -4 * -2 + -1 ist 7.

Das unterscheidet sich von der Umwandlung eines Quotienten mit int(): int(-7 / 2) ergibt -3, weil die Umwandlung die Nachkommastellen in Richtung null abschneidet.

Beide Operatoren akzeptieren auch Gleitkommazahlen. 7.5 // 2 ist 3.0 und 7.5 % 2 ist 1.5. Sie stehen auf derselben Vorrangstufe wie * und /, sodass 5 * 3 + 17 % 5 den Wert 17 ergibt. Der Operator % bedeutet hier Rest, nicht Prozent: Berechne 8 Prozent eines Preises mit price * 0.08 oder price * 8 / 100.

Das Zeichen eines Operators ist nur ein Teil seiner Bedeutung. Python berücksichtigt auch die Datentypen seiner Operanden. Die Operatoren + und * funktionieren mit Zeichenketten, führen dabei aber Textoperationen aus.

Zeichenketten mit Plus verknüpfen

Die Verkettung hängt eine Zeichenkette an das Ende einer anderen:

print("ab" + "cd")
print("Hello" + "Ada")
print("Hello " + "Ada")

Diese Zeilen geben abcd, HelloAda und Hello Ada aus. Die Verkettung fügt von selbst kein Leerzeichen hinzu. Das Leerzeichen im dritten Ergebnis stammt vom letzten Zeichen in "Hello ".

Für Ziffernzeichen gilt dieselbe Regel: "5" + "3" ergibt die Zeichenkette "53". Ohne Anführungszeichen ergibt 5 + 3 die ganze Zahl 8. Wähle Zahlenwerte, wenn du rechnen möchtest, und Zeichenketten, wenn du Text meinst.

Eine Zeichenkette durch Multiplikation wiederholen

Eine mit einer ganzen Zahl multiplizierte Zeichenkette wiederholt ihre Zeichen. "3" * 2 ergibt "33", während 3 * 2 den Wert 6 ergibt. Die Anzahl der Wiederholungen kann auf beiden Seiten stehen: 3 * "ab" ergibt "ababab". Eine Wiederholung null Mal ergibt die leere Zeichenkette, also ist "ab" * 0 gleich "".

Die Anzahl der Wiederholungen muss eine ganze Zahl sein. "ab" * 2.5 löst einen TypeError aus, ebenso wie "ab" * "cd". Bei dieser Operation gibt es keine gebrochene Anzahl von Kopien.

Operationen der Reihe nach kombinieren

Auch bei diesen Ausdrücken hat die Multiplikation Vorrang vor der Addition:

print("-" * 4 + "Menu" + "-" * 4)

Zuerst erzeugt jede Wiederholung "----". Dann verknüpfen die Additionen die drei Zeichenketten und ergeben ----Menu----. Die Reihenfolge der Verknüpfungen erhält die Reihenfolge ihrer Zeichen.

Für eine Berechnung, die Teil einer Zeichenkette wird:

print("7" + str(3 * 2))

Die innere Berechnung ergibt die ganze Zahl 6. str(6) erzeugt die Zeichenkette "6". Schließlich ergibt die Verkettung "76". Sie ergibt nicht 13, weil das letzte + zwei Zeichenketten als Operanden hat.

Mit nicht kompatiblen Datentypen bewusst umgehen

"Age: " + 30 löst einen TypeError aus. Wandle die ganze Zahl vor der Verkettung um:

print("Age: " + str(30))

Das ergibt Age: 30. Alternativ zeigt print("Age:", 30) die beiden Werte mit einem Leerzeichen dazwischen. Das ist das Verhalten von print() bei getrennten Argumenten und keine Textaddition.

Ganze Zahlen und Gleitkommazahlen können bei gewöhnlichen arithmetischen Berechnungen gemischt werden: 2 * 3.0 ergibt den float 6.0. Python wandelt eine Zeichenkette mit einer Zahl bei + nicht auf dieselbe Weise in eine Zahl um. Wenn du mit "30" rechnen musst, wandle sie zuerst in einen numerischen Datentyp um.

Die Subtraktion funktioniert mit diesen Zeichenkettenoperanden nicht. "10" - 3 löst einen TypeError aus, obwohl die Zeichen 10 eine Zahl beschreiben könnten. Um einen gemischten Ausdruck vorherzusagen, bestimme den Datentyp jedes Operanden, werte die Operationen mit höherem Vorrang aus und prüfe die Datentypen bei der nächsten Operation erneut. Eine Umwandlung kann ändern, welcher Regel der nächste Operator folgt.

Eine Typumwandlung, auch Casting genannt, erzeugt einen Wert eines anderen Datentyps. Mit den Funktionen int(), float() und str() kannst du die Form wählen, die für die nächste Operation benötigt wird.

Das umgewandelte Ergebnis behalten

x = "42"
int(x)
print(type(x))

Das gibt weiterhin <class 'str'> aus. Die Umwandlung hat eine ganze Zahl erzeugt, aber keine Zuweisung hat sie gespeichert. Schreibe x = int(x), damit x auf diese ganze Zahl verweist, oder weise sie einem anderen Namen zu, wenn du beide Formen behalten möchtest.

Eine numerische Umwandlung wählen

int() akzeptiert eine Zeichenkette, die eine ganze Zahl darstellt, einschließlich eines optionalen Vorzeichens und umgebender Leerzeichen. int("42"), int("-12") und int(" 42 ") ergeben 42, -12 und 42.

Ein Dezimalpunkt in einer Zeichenkette verhindert die direkte Umwandlung in eine ganze Zahl. int("3.5") und int("4.0") lösen einen ValueError aus; das gilt auch für int("abc") und int(""). Dass 4,0 mathematisch ganzzahlig ist, macht "4.0" nicht zu einer Zeichenkette in der Form einer ganzen Zahl.

float() akzeptiert Dezimaltext und Exponentenschreibweise. float("3.5") ergibt 3.5, float("3") ergibt 3.0 und float("1e3") ergibt 1000.0. Die Funktion wandelt auch ganze Zahlen um: float(7) ergibt 7.0. Ein Dezimalkomma führt zu einem Fehler: float("3,5") löst einen ValueError aus.

Bewusst abschneiden oder runden

Die Umwandlung einer Gleitkommazahl in int entfernt ihren Nachkommateil in Richtung null. int(3.99) ergibt 3 und int(-3.99) ergibt -3. Dabei wird nicht die nächstgelegene ganze Zahl gewählt. Um Dezimaltext umzuwandeln und dann die Nachkommastellen abzuschneiden, verwende int(float("3.5")), was 3 ergibt.

round() wählt einen nächstgelegenen Wert. round(3.7) ergibt die ganze Zahl 4; round(3.14159, 2) ergibt den float 3.14. Das zweite Argument legt die Anzahl der Nachkommastellen fest.

Liegt ein Wert genau in der Mitte, wählt Python den geraden Nachbarwert: round(2.5) ergibt 2, während round(3.5) den Wert 4 ergibt. Als Gleitkommazahlen gespeicherte Dezimalbrüche liegen möglicherweise nicht genau in der Mitte. round(2.675, 2) ergibt aufgrund seiner binären Darstellung 2.67.

Diese Operationen beantworten verschiedene Fragen. Wähle die Operation, die zum gewünschten Ergebnis passt, besonders wenn negative Werte möglich sind.

Für die Verkettung in Text umwandeln

str(42) erzeugt "42" und str(3.0) erzeugt "3.0". Nach der Umwandlung verknüpft + ihre Zeichen:

print("7" + "3")
print(int("7") + int("3"))
print(str(7) + str(3))
print(float("7") + 3)

Die Ausgaben sind 73, 10, 73 und 10.0. Die Umwandlungen entscheiden, ob das letzte + Text oder Zahlen erhält.

Ein ValueError weist auf ungeeigneten Inhalt für eine Umwandlung hin, etwa bei int("abc"). Ein TypeError weist auf eine Operation hin, die mit ihren Operanden nicht kompatibel ist, etwa bei "5" + 5. Nutze diesen Unterschied, um zu entscheiden, ob du den Eingabetext untersuchst oder die Operation änderst.

print() zeigt Werte an, damit Menschen sie lesen können. Seine Argumente sind die Werte oder Ausdrücke innerhalb der Klammern. Kommas trennen die Argumente; Python wertet sie aus, bevor es ihre Ergebnisse anzeigt.

Werte mit hilfreichen Beschriftungen anzeigen

print("Total:", 5)
print(3 + 4)
print("3 + 4")

Die Zeilen zeigen Total: 5, 7 und 3 + 4. Eine Beschriftung sagt den Lesenden, was ein Wert bedeutet. Eine Berechnung ohne Anführungszeichen wird ausgewertet; ein Ausdruck in Anführungszeichen wird als Text angezeigt.

Standardmäßig setzt print() ein Leerzeichen zwischen Argumente und endet mit einem Zeilenumbruch. Es wandelt jeden Wert für die Anzeige um, sodass print("Total:", 5) Text und eine ganze Zahl ohne ausdrückliches str() mischen kann.

Vergleiche print("Total:" + str(5)), das Total:5 ausgibt. Hier erstellt + eine Zeichenkette, bevor print() sie erhält. Die Verkettung liefert kein automatisches Leerzeichen und es gibt nur ein Argument zur Anzeige.

Das Trennzeichen festlegen

Das benannte Argument sep legt den Text fest, der zwischen Argumente gesetzt wird:

print("a", "b", sep="-")
print(1, 2, 3, sep=", ")
print("A", 12, sep="")

Die Ausgabe lautet:

a-b
1, 2, 3
A12

Verwende den Namen sep. Die Schreibweise print("a", "b", "-") liefert einen dritten Wert, sodass das Ergebnis a b - ist. Ein leeres Trennzeichen fügt die angezeigten Argumente direkt zusammen; es entfernt keine Leerzeichen, die bereits in ihren Zeichenketten stehen.

Den Zeilenabschluss festlegen

Das benannte Argument end ändert, was auf den letzten Wert folgt. Standardmäßig ist das ein Zeilenumbruch. Ein leerer Abschluss hält die nächste Ausgabe in derselben Zeile:

print("a", end="")
print("b")

Das zeigt ab in einer Zeile. Du kannst Satzzeichen und einen Zeilenumbruch gemeinsam angeben:

print("Hello,", "Ada", end="!\n")

Die Ausgabe ist Hello, Ada!, gefolgt von einer neuen Zeile. sep gilt zwischen Argumenten innerhalb eines Aufrufs; end gilt nach dem letzten Argument dieses Aufrufs. Sie steuern unterschiedliche Stellen.

Zeilenumbrüche ergänzen und angezeigte Genauigkeit wählen

Der Aufruf von print() ohne Argumente gibt eine leere Zeile aus. Ein \n innerhalb einer Zeichenkette erzeugt einen Zeilenumbruch innerhalb dieser Zeichenkette, wie in print("Line 1\nLine 2"). Wiederholter Text kann eine Trennlinie bilden: print("=" * 20) zeigt zwanzig Gleichheitszeichen.

Python zeigt eine Gleitkommazahl in einer kurzen Form, die ihren gespeicherten Wert darstellt. print(1 / 3) zeigt 0.3333333333333333. Um einen gerundeten Wert anzuzeigen, berechne ihn zuerst innerhalb des Aufrufs: print(round(1 / 3, 2)) zeigt 0.33.

Die Rundung garantiert keine feste Anzahl sichtbarer Nachkommastellen. round(2.50, 2) wird als 2.5 angezeigt, weil die Gleitkommazahl abschließende Nullen nicht als Anzeigeanweisung speichert. Verwende beim Prüfen eines Programms die Ausgabe genau so, wie Python sie erzeugt.

input() zeigt eine Eingabeaufforderung, wartet auf eine Eingabe und das Drücken der Eingabetaste und gibt dann den eingegebenen Text ohne die Eingabetaste als Zeichenkette zurück. Ein vollständiges kurzes Programm liest die benötigten Daten, verarbeitet sie und zeigt ein Ergebnis an.

Text lesen und Zahlen umwandeln

name = input("What is your name? ")
print("Hello", name)

Das Leerzeichen am Ende der Eingabeaufforderung trennt die eingegebene Antwort von der Frage. Die Variable speichert Text als Text, auch wenn Ziffern eingegeben werden. Die Eingabe von 30 bei input() erzeugt "30", nicht die ganze Zahl 30.

Wähle vor einer arithmetischen Berechnung eine Umwandlung:

age = int(input("Age in whole years: "))
print("Next year:", age + 1)

Der innere Aufruf von input() wird zuerst ausgeführt. Bei der Eingabe von 30 gibt er "30" zurück; int() wandelt das in 30 um; die Zuweisung speichert die ganze Zahl. Die Addition ergibt dann 31.

Verwende float(input(...)), wenn Werte mit Bruchteilen zulässig sind. Eine Eingabeaufforderung sollte angeben, welche Art von Antwort erwartet wird. Die Eingabe von 2.5 oder thirty für eine Umwandlung mit int() löst einen ValueError aus. Auch die Eingabe von 98,6 für eine Umwandlung mit float() schlägt fehl; das Dezimaltrennzeichen muss ein Punkt sein.

Eine fehlende Umwandlung löst nicht immer einen Fehler aus. Erhalten zwei input-Aufrufe die Eingaben 5 und 3, werden ihre nicht umgewandelten Werte als Zeichenketten addiert und ergeben 53. Beide Operanden haben einen Datentyp, der + unterstützt, aber es ist die falsche Operation, um Mengen zu addieren.

Eine vollständige Berechnung durcharbeiten

Das Eingabe–Verarbeitung–Ausgabe-Muster macht die Hauptschritte leicht nachvollziehbar:

# Convert a temperature from Fahrenheit to Celsius.
fahrenheit = float(input("Temperature in °F: "))
celsius = (fahrenheit - 32) * 5 / 9
print(fahrenheit, "°F is", round(celsius, 1), "°C")

Bei der Eingabe 98.6 liest das Programm den float 98.6. Es subtrahiert 32 und erhält 66.6, multipliziert mit 5 und erhält 333.0 und dividiert durch 9 und erhält 37.0. Die angezeigte Zeile lautet 98.6 °F is 37.0 °C. Die Eingabe 50 wird zu 50.0, sodass die Zeile 50.0 °F is 10.0 °C lautet.

Hier ist ein Programm mit ganzzahligen Daten:

total_minutes = int(input("Enter a whole number of minutes: "))
hours = total_minutes // 60
minutes = total_minutes % 60
print("Hours:", hours, "Minutes:", minutes)

Die Eingabe 135 erzeugt Hours: 2 Minutes: 15. Die Beschriftungen funktionieren für null, eins und größere Ergebnisse, ohne den Wortlaut zu ändern. Die beiden Verarbeitungszeilen verwenden dieselbe ursprüngliche Gesamtzahl; die Zuweisung an hours entfernt nichts aus total_minutes.

Gewöhnliche Werte und Grenzwerte testen

Wähle Eingaben, deren Ergebnisse du von Hand berechnen kannst. Für das Temperaturprogramm sollte 32 den Wert 0.0 °C und 212 den Wert 100.0 °C ergeben. Teste für Minuten 0, 59 und 60: Diese prüfen den Anfangswert und den Übergang von keiner vollen Stunde zu einer vollen Stunde.

Teste auch einen typischen Wert wie 135. Vergleiche die genauen Beschriftungen, Abstände, Zahlenergebnisse und Datentypen mit deiner Vorhersage. Läuft der Code, aber das Ergebnis ist falsch, verfolge die gespeicherten Werte und die Reihenfolge der Rechenoperationen. Schlägt eine Umwandlung fehl, untersuche den eingegebenen Text und den Datentyp, den deine Eingabeaufforderung verlangt.