Variablen in Python

Im vorherigen Tutorial zuBasic Data Types in Python haben Sie gesehen, wie Werte verschiedener Python-Datentypen erstellt werden können. Bisher waren alle angezeigten Werte wörtliche oder konstante Werte:

>>>

>>> print(5.3)
5.3

Wenn Sie komplexeren Code schreiben, benötigt Ihr Programm Daten, die sich im Verlauf der Programmausführung ändern können.

Here’s what you’ll learn in this tutorial: Sie erfahren, wie jedes Datenelement in einem Python-Programm durch den abstrakten Begriffobject beschrieben werden kann, und Sie lernen, wie Sie Objekte mit symbolischen Namen namensvariables bearbeiten.

Kostenloser PDF-Download: Python 3 Spickzettel

__ Take the Quiz: Testen Sie Ihr Wissen mit unserem interaktiven Quiz „Python-Variablen“. Nach Abschluss erhalten Sie eine Punktzahl, mit der Sie Ihren Lernfortschritt im Laufe der Zeit verfolgen können:

Das Quiz machen "

Variablenzuordnung

Stellen Sie sich eine Variable als einen Namen vor, der an ein bestimmtes Objekt angehängt ist. In Python müssen Variablen nicht im Voraus deklariert oder definiert werden, wie dies in vielen anderen Programmiersprachen der Fall ist. Um eine Variable zu erstellen, weisen Sie ihr einfach einen Wert zu und beginnen dann mit der Verwendung. Die Zuweisung erfolgt mit einem einzelnen Gleichheitszeichen (=):

>>>

>>> n = 300

Dies wird gelesen oder interpretiert als "n wird der Wert300 zugewiesen." Sobald dies erledigt ist, kannn in einer Anweisung oder einem Ausdruck verwendet werden, und sein Wert wird ersetzt:

>>>

>>> print(n)
300

So wie ein Literalwert direkt von der Interpreter-Eingabeaufforderung in einer REPL-Sitzung angezeigt werden kann, ohne dassprint() erforderlich sind, kann auch eine Variable:

>>>

>>> n
300

Wenn Sie später den Wert vonn ändern und erneut verwenden, wird stattdessen der neue Wert ersetzt:

>>>

>>> n = 1000
>>> print(n)
1000
>>> n
1000

Python erlaubt auch eine verkettete Zuweisung, wodurch es möglich ist, mehreren Variablen gleichzeitig denselben Wert zuzuweisen:

>>>

>>> a = b = c = 300
>>> print(a, b, c)
300 300 300

Die obige verkettete Zuordnung weist den Variablena,b undc gleichzeitig300 zu.

Variablentypen in Python

In vielen Programmiersprachen werden Variablen statisch typisiert. Das bedeutet, dass eine Variable anfänglich als ein bestimmter Datentyp deklariert wird und jeder Wert, der ihr während ihrer Lebensdauer zugewiesen wird, immer diesen Typ haben muss.

Variablen in Python unterliegen dieser Einschränkung nicht. In Python kann einer Variablen ein Wert eines Typs zugewiesen und später ein Wert eines anderen Typs neu zugewiesen werden:

>>>

>>> var = 23.5
>>> print(var)
23.5

>>> var = "Now I'm a string"
>>> print(var)
Now I'm a string

Objektreferenzen

Was passiert eigentlich, wenn Sie eine Variablenzuweisung vornehmen? Dies ist eine wichtige Frage in Python, da sich die Antwort etwas von der in vielen anderen Programmiersprachen unterscheidet.

Python ist ein hochobject-oriented language. Tatsächlich ist praktisch jedes Datenelement in einem Python-Programm ein Objekt eines bestimmten Typs oder einer bestimmten Klasse. (Dieser Punkt wird im Verlauf dieser Tutorials mehrmals wiederholt.)

Betrachten Sie diesen Code:

>>>

>>> print(300)
300

Wenn die Anweisungprint(300) angezeigt wird, führt der Interpreter Folgendes aus:

Erstellt ein ganzzahliges Objekt
Gibt ihm den Wert300
Zeigt es auf der Konsole an

Sie können sehen, dass ein ganzzahliges Objekt mit der integrierten Funktiontype()erstellt wird:

>>>

>>> type(300)

Eine Python-Variable ist ein symbolischer Name, der als Referenz oder Zeiger auf ein Objekt dient. Sobald ein Objekt einer Variablen zugewiesen wurde, können Sie mit diesem Namen auf das Objekt verweisen. Die Daten selbst sind jedoch weiterhin im Objekt enthalten.

Zum Beispiel:

>>>

>>> n = 300

Diese Zuweisung erstellt ein ganzzahliges Objekt mit dem Wert300 und weist die Variablen zu, um auf dieses Objekt zu zeigen.

Der folgende Code überprüft, obn auf ein ganzzahliges Objekt zeigt:

>>>

>>> print(n)
300
>>> type(n)

Betrachten Sie nun die folgende Aussage:

>>>

>>> m = n

Was passiert, wenn es ausgeführt wird? Python erstellt kein anderes Objekt. Es wird einfach ein neuer symbolischer Name oder eine neue Referenz erstellt,m, die auf dasselbe Objekt zeigt, auf dasn zeigt.

Angenommen, Sie tun Folgendes:

>>>

>>> m = 400

Jetzt erstellt Python ein neues ganzzahliges Objekt mit dem Wert400, undm wird zu einer Referenz darauf.

Nehmen wir zum Schluss an, dass diese Anweisung als nächstes ausgeführt wird:

>>>

>>> n = "foo"

Jetzt erstellt Python ein String-Objekt mit dem Wert"foo" und verweistndarauf.

Es gibt keinen Verweis mehr auf das ganzzahlige Objekt300. Es ist verwaist und es gibt keine Möglichkeit, darauf zuzugreifen.

Tutorials in dieser Reihe beziehen sich gelegentlich auf die Lebensdauer eines Objekts. Das Leben eines Objekts beginnt mit seiner Erstellung. Zu diesem Zeitpunkt wird mindestens ein Verweis darauf erstellt. Während der Lebensdauer eines Objekts können, wie Sie oben gesehen haben, zusätzliche Verweise darauf erstellt und Verweise darauf gelöscht werden. Ein Objekt bleibt sozusagen am Leben, solange es mindestens einen Hinweis darauf gibt.

Wenn die Anzahl der Verweise auf ein Objekt auf Null fällt, ist es nicht mehr zugänglich. Zu diesem Zeitpunkt ist seine Lebensdauer vorbei. Python wird schließlich feststellen, dass nicht darauf zugegriffen werden kann, und den zugewiesenen Speicher zurückfordern, damit er für etwas anderes verwendet werden kann. Im Computerjargon wird dieser Prozess alsgarbage collection bezeichnet.

Objektidentität

In Python erhält jedes erstellte Objekt eine Nummer, die es eindeutig identifiziert. Es wird garantiert, dass in einem Zeitraum, in dem sich ihre Lebensdauern überschneiden, keine zwei Objekte dieselbe Kennung haben. Sobald der Referenzzähler eines Objekts auf Null fällt und es wie beim obigen Objekt300Müll gesammelt hat, wird seine Identifikationsnummer verfügbar und kann erneut verwendet werden.

Die integrierte Python-Funktionid() gibt die Ganzzahlkennung eines Objekts zurück. Mit der Funktionid() können Sie überprüfen, ob zwei Variablen tatsächlich auf dasselbe Objekt verweisen:

>>>

>>> n = 300
>>> m = n
>>> id(n)
60127840
>>> id(m)
60127840

>>> m = 400
>>> id(m)
60127872

Nach der Zuweisungm = n zeigenm undn beide auf dasselbe Objekt, was durch die Tatsache bestätigt wird, dassid(m) undid(n) dieselbe Zahl zurückgeben. Sobaldm400 zugewiesen wurde, zeigenm undn auf unterschiedliche Objekte mit unterschiedlichen Identitäten.

Deep Dive: Zwischenspeichern kleiner ganzzahliger Werte

Nach dem, was Sie jetzt über Variablenzuweisung und Objektreferenzen in Python wissen, wird Sie Folgendes wahrscheinlich nicht überraschen:

>>>
>>> m = 300
>>> n = 300
>>> id(m)
60062304
>>> id(n)
60062896
Mit der Anweisungm = 300 erstellt Python ein ganzzahliges Objekt mit dem Wert300 und setztm als Referenz darauf. n wird dann in ähnlicher Weise einem ganzzahligen Objekt mit dem Wert300 zugewiesen - jedoch nicht demselben Objekt. Daher haben sie unterschiedliche Identitäten, die Sie anhand der vonid() zurückgegebenen Werte überprüfen können.

Aber bedenken Sie Folgendes:

>>>
>>> m = 30
>>> n = 30
>>> id(m)
1405569120
>>> id(n)
1405569120
Hier werdenm undn ganzzahligen Objekten mit dem Wert30 getrennt zugeordnet. In diesem Fall sindid(m) undid(n) identisch!

Zum Zwecke der Optimierung erstellt der Interpreter beim Start Objekte für die Ganzzahlen im Bereich[-5, 256] und verwendet sie dann während der Programmausführung wieder. Wenn Sie also einem ganzzahligen Wert in diesem Bereich separate Variablen zuweisen, verweisen diese tatsächlich auf dasselbe Objekt.

Variablennamen

In den Beispielen, die Sie bisher gesehen haben, wurden kurze, knappe Variablennamen wiem undn verwendet. Variablennamen können jedoch ausführlicher sein. Tatsächlich ist es normalerweise vorteilhaft, wenn dies der Fall ist, da dadurch der Zweck der Variablen auf den ersten Blick deutlicher wird.

Offiziell können Variablennamen in Python beliebig lang sein und aus Groß- und Kleinbuchstaben (A-Z,a-z), Ziffern (0-9) und dem Unterstrich (_) bestehen. s). Eine zusätzliche Einschränkung besteht darin, dass, obwohl ein Variablenname Ziffern enthalten kann, das erste Zeichen eines Variablennamens keine Ziffer sein kann.

Note: Eine der Ergänzungen zu Python 3 war die vollständige Unicode-Unterstützung, die auch Unicode-Zeichen in einem Variablennamen zulässt. In einem zukünftigen Tutorial werden Sie mehr über Unicode erfahren.

Beispielsweise sind alle folgenden Variablen gültige Variablennamen:

>>>

>>> name = "Bob"
>>> Age = 54
>>> has_W2 = True
>>> print(name, Age, has_W2)
Bob 54 True

Dies ist jedoch nicht der Fall, da ein Variablenname nicht mit einer Ziffer beginnen kann:

>>>

>>> 1099_filed = False
SyntaxError: invalid token

Beachten Sie, dass der Fall von Bedeutung ist. Klein- und Großbuchstaben sind nicht identisch. Die Verwendung des Unterstrichs ist ebenfalls von Bedeutung. Jede der folgenden Definitionen definiert eine andere Variable:

>>>

>>> age = 1
>>> Age = 2
>>> aGe = 3
>>> AGE = 4
>>> a_g_e = 5
>>> _age = 6
>>> age_ = 7
>>> _AGE_ = 8

>>> print(age, Age, aGe, AGE, a_g_e, _age, age_, _AGE_)
1 2 3 4 5 6 7 8

Nichts hindert Sie daran, zwei verschiedene Variablen im selben Programm namensage undAge oderagE zu erstellen. Aber es ist wahrscheinlich schlecht beraten. Es würde sicherlich jeden verwirren, der versucht, Ihren Code zu lesen, und sogar Sie selbst, nachdem Sie eine Weile davon entfernt waren.

Es lohnt sich, einer Variablen einen Namen zu geben, der aussagekräftig genug ist, um zu verdeutlichen, wofür sie verwendet wird. Angenommen, Sie zählen die Anzahl der Personen, die das College abgeschlossen haben. Sie können möglicherweise eine der folgenden Optionen auswählen:

>>>

>>> numberofcollegegraduates = 2500
>>> NUMBEROFCOLLEGEGRADUATES = 2500
>>> numberOfCollegeGraduates = 2500
>>> NumberOfCollegeGraduates = 2500
>>> number_of_college_graduates = 2500

>>> print(numberofcollegegraduates, NUMBEROFCOLLEGEGRADUATES,
... numberOfCollegeGraduates, NumberOfCollegeGraduates,
... number_of_college_graduates)
2500 2500 2500 2500 2500

Alle von ihnen sind wahrscheinlich bessere Entscheidungen alsn oderncg oder dergleichen. Zumindest können Sie anhand des Namens erkennen, was der Wert der Variablen darstellen soll.

Andererseits sind sie nicht unbedingt alle gleich gut lesbar. Wie bei vielen Dingen ist es eine Frage der persönlichen Präferenz, aber die meisten Menschen würden die ersten beiden Beispiele, bei denen alle Buchstaben zusammengeschoben sind, als schwerer lesbar empfinden, insbesondere das in allen Großbuchstaben. Die am häufigsten verwendeten Methoden zum Erstellen eines Variablennamens mit mehreren Wörtern sind die letzten drei Beispiele:

Camel Case: Zweites und nachfolgendes Wort werden großgeschrieben, um das Erkennen von Wortgrenzen zu erleichtern. (Vermutlich fiel jemandem irgendwann auf, dass die im Variablennamen verstreuten Großbuchstaben vage Kamelbuckeln ähneln.)
- Beispiel:numberOfCollegeGraduates
Pascal Case: Identisch mit Camel Case, außer dass das erste Wort ebenfalls groß geschrieben wird.
- Beispiel:NumberOfCollegeGraduates
Snake Case: Wörter werden durch Unterstriche getrennt.
- Beispiel:number_of_college_graduates

Programmierer diskutieren heiß und mit überraschender Leidenschaft, welche davon vorzuziehen ist. Für alle können anständige Argumente vorgebracht werden. Verwenden Sie eine der drei Optionen, die für Sie am attraktivsten sind. Wählen Sie eine aus und verwenden Sie sie konsequent.

Sie werden später sehen, dass Variablen nicht die einzigen Dinge sind, denen Namen gegeben werden können. Sie können auch Funktionen, Klassen, Module usw. benennen. Die Regeln, die für Variablennamen gelten, gelten auch für Bezeichner, der allgemeinere Begriff für Namen, die Programmobjekten zugewiesen werden.

Style Guide for Python Code, auch alsPEP 8 bezeichnet, enthältNaming Conventions, in denen vorgeschlagene Standards für Namen verschiedener Objekttypen aufgeführt sind. PEP 8 enthält die folgenden Empfehlungen:

Snake Case sollte für Funktionen und Variablennamen verwendet werden.
Pascal Case sollte für Klassennamen verwendet werden. (PEP 8 bezeichnet dies als "CapWords" -Konvention.)

Reservierte Wörter (Schlüsselwörter)

Es gibt noch eine Einschränkung für Bezeichnernamen. Die Python-Sprache reserviert einen kleinen Satz von Schlüsselwörtern, die spezielle Sprachfunktionen kennzeichnen. Kein Objekt kann denselben Namen wie ein reserviertes Wort haben.

In Python 3.6 gibt es 33 reservierte Schlüsselwörter:

Python
Schlüsselwörter

Python Schlüsselwörter
`False`	`def`	`if`	`raise`
`None`	`del`	`import`	`return`
`True`	`elif`	`in`	`try`
`and`	`else`	`is`	`while`
`as`	`except`	`lambda`	`with`
`assert`	`finally`	`nonlocal`	`yield`
`break`	`for`	`not`
`class`	`from`	`or`
`continue`	`global`	`pass`

False

def

if

raise

None

del

import

return

True

elif

in

try

and

else

is

while

as

except

lambda

with

assert

finally

nonlocal

yield

break

for

not

class

from

or

continue

global

pass

Sie können diese Liste jederzeit anzeigen, indem Siehelp("keywords") in den Python-Interpreter eingeben. Reservierte Wörter unterscheiden zwischen Groß- und Kleinschreibung und müssen genau wie gezeigt verwendet werden. Sie sind alle vollständig klein geschrieben, mit Ausnahme vonFalse,None undTrue.

Der Versuch, eine Variable mit demselben Namen wie ein reserviertes Wort zu erstellen, führt zu einem Fehler:

>>>

>>> for = 3
SyntaxError: invalid syntax

Fazit

In diesem Lernprogramm wurden die Grundlagen von Pythonvariablesbehandelt, einschließlich Objektreferenzen und Identität sowie die Benennung von Python-Bezeichnern.

Sie haben jetzt ein gutes Verständnis für einige der Python-Datentypen und wissen, wie Sie Variablen erstellen, die auf Objekte dieser Typen verweisen.

Als nächstes sehen Sie, wie Sie Datenobjekte zuexpressions kombinieren, an denen verschiedeneoperations beteiligt sind.

Das Quiz machen "

TOC

Variablen in Python