3. Eine informelle Einführung in Python

In den folgenden Beispielen werden Eingabe und Ausgabe durch das Vorhandensein oder Fehlen von Prompts (>>> und …) unterschieden: Um das Beispiel zu wiederholen, müssen Sie alles nach dem Prompt eingeben, wenn der Prompt erscheint; Zeilen, die nicht mit einem Prompt beginnen, sind Ausgaben des Interpreters. Beachten Sie, dass ein sekundärer Prompt auf einer eigenen Zeile in einem Beispiel bedeutet, dass Sie eine leere Zeile eingeben müssen; dies wird verwendet, um einen mehrzeiligen Befehl zu beenden.

Sie können die Schaltfläche „Kopieren“ (sie erscheint in der oberen rechten Ecke, wenn Sie mit der Maus über ein Codebeispiel fahren oder darauf tippen), die Prompts entfernt und die Ausgabe weglässt, verwenden, um die Eingabezeilen zu kopieren und in Ihren Interpreter einzufügen.

Viele der Beispiele in diesem Handbuch, selbst jene, die an der interaktiven Eingabeaufforderung eingegeben werden, enthalten Kommentare. Kommentare in Python beginnen mit dem Hashtag-Zeichen (#) und erstrecken sich bis zum Ende der physischen Zeile. Ein Kommentar kann am Anfang einer Zeile oder nach Leerzeichen oder Code erscheinen, jedoch nicht innerhalb eines String-Literals. Ein Hashtag-Zeichen innerhalb eines String-Literals ist nur ein Hashtag-Zeichen. Da Kommentare zur Klärung von Code dienen und nicht von Python interpretiert werden, können sie beim Eingeben von Beispielen weggelassen werden.

Einige Beispiele

# this is the first comment
spam = 1  # and this is the second comment
          # ... and now a third!
text = "# This is not a comment because it's inside quotes."

3.1. Python als Taschenrechner verwenden

Lassen Sie uns einige einfache Python-Befehle ausprobieren. Starten Sie den Interpreter und warten Sie auf den primären Prompt, >>>. (Das sollte nicht lange dauern.)

3.1.1. Zahlen

Der Interpreter fungiert als einfacher Taschenrechner: Sie können einen Ausdruck eingeben und er wird den Wert schreiben. Die Syntax für Ausdrücke ist einfach: Die Operatoren +, -, * und / können für arithmetische Operationen verwendet werden; Klammern (()) können zur Gruppierung verwendet werden. Zum Beispiel

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # division always returns a floating-point number
1.6

Die ganzen Zahlen (z. B. 2, 4, 20) haben den Typ int, diejenigen mit einem Bruchteil (z. B. 5.0, 1.6) haben den Typ float. Wir werden im Tutorial später mehr über numerische Typen erfahren.

Division (/) gibt immer einen Float zurück. Um eine Ganzzahldivision durchzuführen und ein ganzzahliges Ergebnis zu erhalten, können Sie den Operator // verwenden; um den Rest zu berechnen, können Sie % verwenden.

>>> 17 / 3  # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3  # floor division discards the fractional part
5
>>> 17 % 3  # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2  # floored quotient * divisor + remainder
17

Mit Python ist es möglich, den Operator ** zur Berechnung von Potenzen zu verwenden [1]

>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128

Das Gleichheitszeichen (=) wird verwendet, um einer Variablen einen Wert zuzuweisen. Danach wird vor dem nächsten interaktiven Prompt kein Ergebnis angezeigt

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

Wenn eine Variable nicht „definiert“ (einem Wert zugewiesen) ist, führt der Versuch, sie zu verwenden, zu einem Fehler

>>> n  # try to access an undefined variable
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

Es gibt volle Unterstützung für Gleitkommazahlen; Operanden mit gemischten Typen konvertieren den ganzzahligen Operanden in Gleitkommazahlen

>>> 4 * 3.75 - 1
14.0

Im interaktiven Modus wird der zuletzt ausgegebene Ausdruck der Variablen _ zugewiesen. Das bedeutet, dass es etwas einfacher ist, Berechnungen fortzusetzen, wenn Sie Python als Schreibtischrechner verwenden, zum Beispiel

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

Diese Variable sollte vom Benutzer als schreibgeschützt behandelt werden. Weisen Sie ihr keinen Wert explizit zu — Sie würden eine unabhängige lokale Variable mit demselben Namen erstellen, die die eingebaute Variable mit ihrem magischen Verhalten maskiert.

Zusätzlich zu int und float unterstützt Python andere Zahlentypen wie Decimal und Fraction. Python hat auch eingebaute Unterstützung für komplexe Zahlen und verwendet den Suffix j oder J, um den Imaginärteil anzugeben (z. B. 3+5j).

3.1.2. Text

Python kann Text (dargestellt durch den Typ str, sogenannte „Strings“) sowie Zahlen manipulieren. Dies umfasst Zeichen „!“, Wörter „rabbit“, Namen „Paris“, Sätze „Got your back.“, etc. „Yay! :)“. Sie können in einfache Anführungszeichen ('...') oder doppelte Anführungszeichen ("...") eingeschlossen werden, mit demselben Ergebnis [2].

>>> 'spam eggs'  # single quotes
'spam eggs'
>>> "Paris rabbit got your back :)! Yay!"  # double quotes
'Paris rabbit got your back :)! Yay!'
>>> '1975'  # digits and numerals enclosed in quotes are also strings
'1975'

Um ein Zitat in einem Zitat zu versehen, müssen wir es mit \ „escapen“. Alternativ können wir die andere Art von Anführungszeichen verwenden

>>> 'doesn\'t'  # use \' to escape the single quote...
"doesn't"
>>> "doesn't"  # ...or use double quotes instead
"doesn't"
>>> '"Yes," they said.'
'"Yes," they said.'
>>> "\"Yes,\" they said."
'"Yes," they said.'
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'

In der Python-Shell können sich die String-Definition und die Ausgabe-Strings unterscheiden. Die Funktion print() liefert eine besser lesbare Ausgabe, indem sie die umschließenden Anführungszeichen weglässt und maskierte und spezielle Zeichen ausgibt

>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), special characters are included in the string
'First line.\nSecond line.'
>>> print(s)  # with print(), special characters are interpreted, so \n produces new line
First line.
Second line.

Wenn Sie nicht möchten, dass Zeichen, denen ein \ vorangestellt ist, als Sonderzeichen interpretiert werden, können Sie *Roh-Strings* verwenden, indem Sie ein r vor das erste Anführungszeichen setzen

>>> print('C:\some\name')  # here \n means newline!
C:\some
ame
>>> print(r'C:\some\name')  # note the r before the quote
C:\some\name

Es gibt einen subtilen Aspekt bei Roh-Strings: Ein Roh-String darf nicht mit einer ungeraden Anzahl von \-Zeichen enden; weitere Informationen und Workarounds finden Sie im FAQ-Eintrag.

String-Literale können sich über mehrere Zeilen erstrecken. Eine Möglichkeit ist die Verwendung von dreifachen Anführungszeichen: """...""" oder '''...'''. Zeilenendezeichen werden automatisch in den String aufgenommen, aber es ist möglich, dies zu verhindern, indem ein \ am Ende der Zeile hinzugefügt wird. Im folgenden Beispiel ist der anfängliche Zeilenumbruch nicht enthalten

>>> print("""\
... Usage: thingy [OPTIONS]
...      -h                        Display this usage message
...      -H hostname               Hostname to connect to
... """)
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

>>>

Strings können mit dem Operator + konkateniert (aneinandergefügt) und mit * wiederholt werden

>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

Zwei oder mehr *String-Literale* (d. h. diejenigen, die in Anführungszeichen eingeschlossen sind) nebeneinander werden automatisch konkateniert.

>>> 'Py' 'thon'
'Python'

Dieses Feature ist besonders nützlich, wenn Sie lange Strings aufteilen möchten

>>> text = ('Put several strings within parentheses '
...         'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

Dies funktioniert jedoch nur mit zwei Literalen, nicht mit Variablen oder Ausdrücken

>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  File "<stdin>", line 1
    prefix 'thon'
           ^^^^^^
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  File "<stdin>", line 1
    ('un' * 3) 'ium'
               ^^^^^
SyntaxError: invalid syntax

Wenn Sie Variablen oder eine Variable und ein Literal konkatenieren möchten, verwenden Sie +

>>> prefix + 'thon'
'Python'

Strings können *indiziert* (subskriptiert) werden, wobei das erste Zeichen den Index 0 hat. Es gibt keinen separaten Zeichentyp; ein Zeichen ist einfach ein String der Größe eins

>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

Indizes können auch negative Zahlen sein, um vom rechten Ende aus zu zählen

>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'

Beachten Sie, dass, da -0 dasselbe wie 0 ist, negative Indizes bei -1 beginnen.

Neben der Indizierung wird auch das *Slicing* unterstützt. Während die Indizierung zum Abrufen einzelner Zeichen verwendet wird, ermöglicht das *Slicing* das Abrufen eines Teilstrings

>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'

Slice-Indizes haben nützliche Standardwerte; ein ausgelassener erster Index ist standardmäßig null, ein ausgelassener zweiter Index ist standardmäßig die Größe des geslicten Strings.

>>> word[:2]   # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]   # characters from position 4 (included) to the end
'on'
>>> word[-2:]  # characters from the second-last (included) to the end
'on'

Beachten Sie, wie der Anfang immer enthalten ist und das Ende immer ausgeschlossen ist. Dies stellt sicher, dass s[:i] + s[i:] immer gleich s ist

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

Eine Möglichkeit, sich zu merken, wie Slices funktionieren, ist, sich die Indizes als *zwischen* Zeichen zeigend vorzustellen, wobei der linke Rand des ersten Zeichens mit 0 nummeriert ist. Dann hat der rechte Rand des letzten Zeichens eines Strings von *n* Zeichen den Index *n*, zum Beispiel

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

Die erste Zahlenreihe gibt die Position der Indizes 0…6 im String an; die zweite Reihe gibt die entsprechenden negativen Indizes an. Der Slice von *i* bis *j* besteht aus allen Zeichen zwischen den Kanten, die mit *i* und *j* beschriftet sind.

Für nicht-negative Indizes ist die Länge eines Slices die Differenz der Indizes, wenn beide innerhalb der Grenzen liegen. Zum Beispiel ist die Länge von word[1:3] 2.

Der Versuch, einen Index zu verwenden, der zu groß ist, führt zu einem Fehler

>>> word[42]  # the word only has 6 characters
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

Allerdings werden Slice-Indizes außerhalb des Bereichs beim Slicing gut behandelt

>>> word[4:42]
'on'
>>> word[42:]
''

Python-Strings können nicht verändert werden – sie sind unveränderlich. Daher führt die Zuweisung an eine indizierte Position im String zu einem Fehler

>>> word[0] = 'J'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

Wenn Sie einen anderen String benötigen, sollten Sie einen neuen erstellen

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

Die eingebaute Funktion len() gibt die Länge eines Strings zurück

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

Siehe auch

Text-Sequenz-Typ — str

Strings sind Beispiele für *Sequenztypen* und unterstützen die gängigen Operationen, die von solchen Typen unterstützt werden.

String Methods

Strings unterstützen eine große Anzahl von Methoden für grundlegende Transformationen und Suchen.

f-Strings

String-Literale, die eingebettete Ausdrücke enthalten.

Format-String-Syntax

Informationen zur String-Formatierung mit str.format().

printf-Stil String-Formatierung

Die alten Formatierungsoperationen, die aufgerufen werden, wenn Strings der linke Operand des Operators % sind, werden hier detaillierter beschrieben.

3.1.3. Listen

Python kennt eine Reihe von *zusammengesetzten* Datentypen, die verwendet werden, um andere Werte zu gruppieren. Der vielseitigste ist die *Liste*, die als eine Liste von komma-getrennten Werten (Elementen) zwischen eckigen Klammern geschrieben werden kann. Listen können Elemente unterschiedlicher Typen enthalten, aber normalerweise haben alle Elemente denselben Typ.

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

Wie Strings (und alle anderen eingebauten *Sequenztypen*), können Listen indiziert und geslicet werden

>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[9, 16, 25]

Listen unterstützen auch Operationen wie Konkatenation

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Im Gegensatz zu Strings, die unveränderlich sind, sind Listen ein veränderlicher Typ, d. h. es ist möglich, ihren Inhalt zu ändern

>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

Sie können auch neue Elemente am Ende der Liste hinzufügen, indem Sie die *Methode* list.append() verwenden (wir werden später mehr über Methoden erfahren)

>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

Einfache Zuweisungen in Python kopieren niemals Daten. Wenn Sie eine Liste einer Variablen zuweisen, verweist die Variable auf die *bestehende Liste*. Alle Änderungen, die Sie an der Liste über eine Variable vornehmen, werden auch über alle anderen Variablen, die darauf verweisen, sichtbar sein.

>>> rgb = ["Red", "Green", "Blue"]
>>> rgba = rgb
>>> id(rgb) == id(rgba)  # they reference the same object
True
>>> rgba.append("Alph")
>>> rgb
["Red", "Green", "Blue", "Alph"]

Alle Slice-Operationen geben eine neue Liste zurück, die die angeforderten Elemente enthält. Das bedeutet, dass der folgende Slice eine flache Kopie der Liste zurückgibt

>>> correct_rgba = rgba[:]
>>> correct_rgba[-1] = "Alpha"
>>> correct_rgba
["Red", "Green", "Blue", "Alpha"]
>>> rgba
["Red", "Green", "Blue", "Alph"]

Die Zuweisung zu Slices ist ebenfalls möglich, und dies kann sogar die Größe der Liste ändern oder sie vollständig leeren

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

Die eingebaute Funktion len() gilt auch für Listen

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

Es ist möglich, Listen zu verschachteln (Listen zu erstellen, die andere Listen enthalten), zum Beispiel

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

3.2. Erste Schritte zur Programmierung

Natürlich können wir Python für kompliziertere Aufgaben verwenden, als zwei und zwei zu addieren. Zum Beispiel können wir eine anfängliche Teilsequenz der Fibonacci-Folge wie folgt schreiben

>>> # Fibonacci series:
>>> # the sum of two elements defines the next
>>> a, b = 0, 1
>>> while a < 10:
...     print(a)
...     a, b = b, a+b
...
0
1
1
2
3
5
8

Dieses Beispiel führt mehrere neue Funktionen ein.

  • Die erste Zeile enthält eine *Mehrfachzuweisung*: Die Variablen a und b erhalten gleichzeitig die neuen Werte 0 und 1. In der letzten Zeile wird dies erneut verwendet, was zeigt, dass die Ausdrücke auf der rechten Seite alle zuerst ausgewertet werden, bevor eine der Zuweisungen stattfindet. Die Ausdrücke auf der rechten Seite werden von links nach rechts ausgewertet.

  • Die while-Schleife wird ausgeführt, solange die Bedingung (hier: a < 10) wahr bleibt. In Python, wie in C, ist jeder von Null verschiedene ganzzahlige Wert wahr; Null ist falsch. Die Bedingung kann auch ein String- oder Listenwert sein, tatsächlich jede Sequenz; alles mit einer Länge ungleich Null ist wahr, leere Sequenzen sind falsch. Der im Beispiel verwendete Test ist ein einfacher Vergleich. Die Standard-Vergleichsoperatoren werden wie in C geschrieben: < (kleiner als), > (größer als), == (gleich), <= (kleiner oder gleich), >= (größer oder gleich) und != (ungleich).

  • Der *Körper* der Schleife ist *eingerückt*: Einrückung ist Pythons Art, Anweisungen zu gruppieren. An der interaktiven Eingabeaufforderung müssen Sie für jede eingerückte Zeile eine Tabulator- oder Leerzeicheneingabe tätigen. In der Praxis werden Sie kompliziertere Eingaben für Python mit einem Texteditor vorbereiten; alle anständigen Texteditoren verfügen über eine automatische Einrückungsfunktion. Wenn eine zusammengesetzte Anweisung interaktiv eingegeben wird, muss sie von einer leeren Zeile gefolgt werden, um die Fertigstellung anzuzeigen (da der Parser nicht erraten kann, wann Sie die letzte Zeile eingegeben haben). Beachten Sie, dass jede Zeile innerhalb eines grundlegenden Blocks gleich weit eingerückt sein muss.

  • Die Funktion print() gibt den Wert der ihr übergebenen Argumente aus. Sie unterscheidet sich von der bloßen Ausgabe des Ausdrucks, den Sie schreiben möchten (wie wir es früher in den Taschenrechner-Beispielen getan haben), in der Art, wie sie mehrere Argumente, Gleitkommazahlen und Strings behandelt. Strings werden ohne Anführungszeichen ausgegeben und zwischen den Elementen wird ein Leerzeichen eingefügt, sodass Sie Dinge schön formatieren können, wie hier

    >>> i = 256*256
>>> print('The value of i is', i)
The value of i is 65536

    Das Schlüsselwortargument *end* kann verwendet werden, um den Zeilenumbruch nach der Ausgabe zu vermeiden oder die Ausgabe mit einem anderen String zu beenden

    >>> a, b = 0, 1
>>> while a < 1000:
...     print(a, end=',')
...     a, b = b, a+b
...
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

Fußnoten