Einführung in Python

Auftakt

Willkommen bei der Onlineanleitung für Python von Google. Er basiert auf dem internen Einführungskurs in Python. Wie auf der Einrichtungsseite erwähnt, bezieht sich dieses Material auf Python 3.

Wenn Sie nach einem begleitenden MOOC-Kurs suchen, versuchen Sie es mit den Kursen von Udacity und Coursera (Einführung in das Programmieren [Anfänger] oder Einführung in Python). Wenn Sie online lernen möchten, ohne sich Videos anzusehen, probieren Sie die am Ende dieses Beitrags genannten Optionen aus. Sie enthalten jeweils Lerninhalte sowie einen interaktiven Python-Dolmetscher, mit dem Sie üben können. Was ist dieser „Interpreter“? Das erfährst du im nächsten Abschnitt.

Sprache – Einführung

Python ist eine dynamische, interpretierte (Bytecode-kompilierte) Sprache. Im Quellcode gibt es keine Typdeklarationen für Variablen, Parameter, Funktionen oder Methoden. Dadurch wird der Code kurz und flexibel, aber die Typprüfung des Quellcodes bei der Kompilierung entfällt. Python verfolgt die Typen aller Werte zur Laufzeit und kennzeichnet Code, der bei der Ausführung keinen Sinn ergibt.

Eine gute Möglichkeit, die Funktionsweise von Python-Code zu sehen, ist die Ausführung des Python-Interpreters und das Eintippen von Code direkt in den Interpreter. Wenn Sie sich beispielsweise fragen, was passiert, wenn Sie einem list ein int hinzufügen, ist es am schnellsten und wahrscheinlich am besten, einfach den Code in den Python-Interpreter einzugeben. (Unten siehst du, was wirklich passiert.)

$ python3        ## Run the Python interpreter
Python 3.X.X (XXX, XXX XX XXXX, XX:XX:XX) [XXX] on XXX
Type "help", "copyright", "credits" or "license" for more information.
>>> a = 6       ## set a variable in this interpreter session
>>> a           ## entering an expression prints its value
6
>>> a + 2
8
>>> a = 'hi'    ## 'a' can hold a string just as well
>>> a
'hi'
>>> len(a)      ## call the len() function on a string
2
>>> a + len(a)  ## try something that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str
>>> a + str(len(a))  ## probably what you really wanted
'hi2'
>>> foo         ## try something else that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'foo' is not defined
>>> ^D          ## type CTRL-d to exit (CTRL-z in Windows/DOS terminal)

Die beiden Zeilen, die Python nach Eingabe von „python“ und vor dem Prompt „>>>“ ausgibt, geben Aufschluss über die verwendete Python-Version und wo sie kompiliert wurde. Solange als Erstes „Python 3“ angezeigt wird, sollten diese Beispiele für Sie funktionieren.

Wie Sie oben sehen, ist es ganz einfach, mit Variablen und Operatoren zu experimentieren. Außerdem löst der Interpreter einen Laufzeitfehler aus, wenn der Code versucht, eine Variable zu lesen, der kein Wert zugewiesen wurde. Wie in C++ und Java wird bei Python zwischen Groß- und Kleinschreibung unterschieden, sodass „a“ und „A“ unterschiedliche Variablen sind. Das Ende einer Zeile markiert das Ende einer Anweisung. Im Gegensatz zu C++ und Java ist in Python also kein Semikolon am Ende jeder Anweisung erforderlich. Kommentare beginnen mit einem # und reichen bis zum Ende der Zeile.

Python-Quellcode

Python-Quelldateien haben die Erweiterung „.py“ und werden als „Module“ bezeichnet. Python-Module hello.py lassen sich am einfachsten mit dem Shell-Befehl „python hello.py Alice“ ausführen. Dabei wird der Python-Interpreter aufgerufen, um den Code in hello.py auszuführen, wobei das Befehlszeilenargument „Alice“ übergeben wird. Informationen zu allen Optionen, die zur Ausführung von Python über die Befehlszeile zur Verfügung stehen, finden Sie auf der offiziellen Dokumentationsseite.

Hier ist ein sehr einfaches hello.py-Programm. Beachten Sie, dass Codeblöcke streng durch Einzüge und nicht durch geschweifte Klammern abgegrenzt werden. Mehr dazu später:

#!/usr/bin/python3

# import modules used here -- sys is a very standard one
import sys

# Gather our code in a main() function
def main():
    print('Hello there', sys.argv[1])
    # Command line args are in sys.argv[1], sys.argv[2] ...
    # sys.argv[0] is the script name itself and can be ignored

# Standard boilerplate to call the main() function to begin
# the program.
if __name__ == '__main__':
    main()

Das Ausführen dieses Programms über die Befehlszeile sieht so aus:

$ python3 hello.py Guido
Hello there Guido
$ ./hello.py Alice  ## without needing 'python3' first (Unix)
Hello there Alice

Importe, Befehlszeilenargumente und len()

Die äußersten Anweisungen in einer Python-Datei oder einem "Modul" führen eine einmalige Einrichtung durch. Diese Anweisungen werden beim ersten Import des Moduls von oben nach unten ausgeführt und richten die Variablen und Funktionen ein. Ein Python-Modul kann direkt ausgeführt werden (wie oben python3 hello.py Bob) oder von einem anderen Modul importiert und verwendet werden. Wenn eine Python-Datei direkt ausgeführt wird, wird die spezielle Variable „__name__“ auf „__main__“ gesetzt. Daher ist es üblich, den oben gezeigten Boilerplate-Code if __name__ ==... zu verwenden, um eine main()-Funktion aufzurufen, wenn das Modul direkt ausgeführt wird, aber nicht, wenn es von einem anderen Modul importiert wird.

In einem Standard-Python-Programm enthält die Liste sys.argv die Befehlszeilenargumente auf standardmäßige Weise. Dabei ist sys.argv[0] das Programm selbst, sys.argv[1] das erste Argument usw. Wenn Sie argc oder die Anzahl der Argumente kennen, können Sie diesen Wert einfach mit len(sys.argv) von Python anfordern, so wie wir es oben im interaktiven Interpretercode beim Anfordern der Länge eines Strings getan haben. Im Allgemeinen können Sie mit len() herausfinden, wie lang ein String ist, wie viele Elemente in Listen und Tupeln (eine weitere arrayähnliche Datenstruktur) enthalten sind und wie viele Schlüssel/Wert-Paare in einem Wörterbuch vorhanden sind.

Benutzerdefinierte Funktionen

Funktionen in Python werden so definiert:

# Defines a "repeat" function that takes 2 arguments.
def repeat(s, exclaim):
    """
    Returns the string 's' repeated 3 times.
    If exclaim is true, add exclamation marks.
    """

    result = s + s + s # can also use "s * 3" which is faster (Why?)
    if exclaim:
        result = result + '!!!'
    return result

Beachten Sie auch, wie die Zeilen, aus denen die Funktion oder die if-Anweisung besteht, so gruppiert werden, dass alle die gleiche Einrückung haben. Außerdem haben wir zwei verschiedene Möglichkeiten zum Wiederholen von Strings vorgestellt: mit dem +-Operator, der nutzerfreundlicher ist, aber auch * funktioniert, da es sich um den Wiederholungsoperator von Python handelt. Das bedeutet, dass '-' * 10 '----------' ergibt, eine praktische Möglichkeit, eine „Zeile“ auf dem Bildschirm zu erstellen. Im Codekommentar haben wir angedeutet, dass * schneller als + funktioniert. Der Grund dafür ist, dass * die Größe des resultierenden Objekts nur einmal berechnet, während bei + diese Berechnung jedes Mal erfolgt, wenn + aufgerufen wird. Sowohl + als auch * werden als "überladene" Operatoren bezeichnet, da sie für Zahlen unterschiedliche Bedeutungen haben als für Strings (und andere Datentypen).

Das Schlüsselwort def definiert die Funktion mit ihren Parametern in Klammern und den eingerückten Code. Die erste Zeile einer Funktion kann ein Dokumentationsstring („Docstring“) sein, der die Funktion beschreibt. Der docstring kann eine einzelne Zeile oder eine mehrzeilige Beschreibung wie im obigen Beispiel sein. (Ja, das sind dreifache Anführungszeichen, eine Funktion, die es nur in Python gibt!) In der Funktion definierte Variablen sind lokal für diese Funktion. „Ergebnis“ in der obigen Funktion ist also unabhängig von einer „Ergebnis“-Variablen in einer anderen Funktion. Die return-Anweisung kann ein Argument annehmen. In diesem Fall ist dies der Wert, der an den Aufrufer zurückgegeben wird.

Hier ist der Code, der die obige Repeat()-Funktion aufruft und das zurückgegebene Ergebnis ausgibt:

def main():
    print(repeat('Yay', False))      ## YayYayYay
    print(repeat('Woo Hoo', True))   ## Woo HooWoo HooWoo Hoo!!!

Funktionen müssen zur Laufzeit durch die Ausführung eines „def“-Befehls definiert werden, bevor sie aufgerufen werden. Es ist üblich, eine „main()“-Funktion am Ende der Datei mit den aufgerufenen Funktionen darüber festzulegen.

Einzug

Eine ungewöhnliche Python-Funktion ist, dass sich die Einzüge von Codeblöcken auf deren Bedeutung auswirken. Ein logischer Block von Anweisungen, wie die, aus denen eine Funktion besteht, sollte alle die gleiche Einrückung haben, d. h. durch die Einrückung ihrer übergeordneten Funktion oder „if“ oder so weiter. Weist eine Zeile in einer Gruppe eine andere Einrückung auf, wird dies als Syntaxfehler gekennzeichnet.

Die Verwendung von Weißraum in Python ist auf den ersten Blick etwas seltsam, aber es ist logisch und ich habe mich sehr schnell daran gewöhnt. Verwenden Sie keine TABulatorzeichen, da sie das Einzugschema erheblich verkomplizieren. Außerdem können TABulatorzeichen auf verschiedenen Plattformen unterschiedliche Bedeutungen haben. Legen Sie in Ihrem Editor fest, dass für Python-Code Leerzeichen anstelle von TABs eingefügt werden.

Eine häufige Frage von Anfängern ist: „Wie viele Leerzeichen sollte ich einrücken?“ Gemäß dem offiziellen Python-Styleguide (PEP 8) sollten Sie vier Leerzeichen einrücken. Übrigens: Gemäß den internen Style-Richtlinien von Google ist das Einrücken um zwei Leerzeichen voreingestellt.

Code wird bei der Laufzeit geprüft

Python führt zur Kompilierungszeit nur sehr wenige Prüfungen durch und verschiebt fast alle Prüfungen von Typ, Name usw. auf jede Zeile, bis diese Zeile ausgeführt wird. Angenommen, die Funktion main() ruft repeat() so auf:

def main():
    if name == 'Guido':
        print(repeeeet(name) + '!!!')
    else:
        print(repeat(name))

Die If-Bedingung enthält einen offensichtlichen Fehler, da die Funktion „repeat()“ versehentlich als „repeeeet()“ eingegeben wurde. Das Lustige an Python ist, dass dieser Code kompiliert und fehlerfrei ausgeführt wird, solange der Name zur Laufzeit nicht „Guido“ lautet. Erst wenn bei einem Durchlauf versucht wird, die Funktion „repeat()“ auszuführen, wird festgestellt, dass es keine solche Funktion gibt, und es wird ein Fehler ausgegeben. Dieses Snippet enthält auch einen zweiten Fehler. name wurde kein Wert zugewiesen, bevor er mit „Guido“ verglichen wurde. Python löst einen „NameError“ aus, wenn Sie versuchen, eine nicht zugewiesene Variable auszuwerten. Diese Beispiele zeigen, dass bei der ersten Ausführung eines Python-Programms einige der ersten Fehler einfache Tippfehler oder nicht initialisierte Variablen wie diese sind. In diesem Bereich haben Sprachen mit einem ausführlicheren Typsystem wie Java einen Vorteil: Sie können solche Fehler zur Kompilierungszeit erkennen. Sie müssen jedoch natürlich alle diese Typinformationen verwalten. Es ist also ein Kompromiss.

In Python 3 wurden Typhinweise eingeführt. Mit Typhinweisen können Sie den Typ für jedes Argument in einer Funktion sowie den Typ des Objekts angeben, das von der Funktion zurückgegeben wird. In der kommentierten Funktion def is_positive(n: int) -> bool: ist das Argument n beispielsweise ein int und der Rückgabewert ein bool. Auf die Bedeutung dieser Typen gehen wir später ein. Typhinweise sind jedoch völlig optional. Es werden immer mehr Hinweise zur Codeübernahme von Typen angezeigt. Wenn Sie diese verwenden, können einige Editoren wie cider-v und VS.code Prüfungen ausführen, um zu überprüfen, ob Ihre Funktionen mit den richtigen Argumenttypen aufgerufen werden. Sie können sogar Argumente vorschlagen und validieren, während Sie Code bearbeiten. In dieser Anleitung werden keine Typhinweise behandelt. Wir möchten Sie aber darauf hinweisen, falls Sie sie hören oder sehen.

Variablennamen

Da für Python-Variablen kein Typ im Quellcode ausgeschrieben ist, ist es besonders hilfreich, den Variablen aussagekräftige Namen zu geben, damit Sie immer daran erinnert werden, was vor sich geht. Verwenden Sie also „name“, wenn es sich um einen einzelnen Namen handelt, „names“, wenn es sich um eine Liste von Namen handelt, und „tuples“, wenn es sich um eine Liste von Tupeln handelt. Viele grundlegende Python-Fehler entstehen, weil vergessen wird, welche Art von Wert sich in jeder Variablen befindet. Verwenden Sie daher die Variablennamen (das ist alles, was Sie haben), um den Überblick zu behalten.

Im Hinblick auf die eigentliche Benennung bevorzugen einige Sprachen Unterstrich_parts für Variablennamen, die aus "mehr als einem Wort" bestehen, während andere Sprachen CamelCasing bevorzugen. Im Allgemeinen bevorzugt Python die Unterstrich-Methode, führt Entwickler jedoch dazu, sich bei einer Integration in vorhandenen Python-Code, der bereits diesen Stil verwendet, auf "CamelCasing" zu beschränken. Die Lesbarkeit ist wichtig. Weitere Informationen finden Sie im Abschnitt zu Namenskonventionen in PEP 8.

Wie Sie sich vorstellen können, können Keywords wie „if“ und „while“ nicht als Variablennamen verwendet werden. Andernfalls erhalten Sie einen Syntaxfehler. Verwenden Sie aber auch keine vordefinierten Funktionen als Variablennamen. Namen wie „str“, „list“ und „print“ mögen zwar gut klingen, aber Sie würden damit diese Systemvariablen überschreiben. Eingebettete Funktionen sind keine Keywords und können daher von neuen Python-Entwicklern versehentlich verwendet werden.

Weitere Informationen zu Modulen und ihren Namespaces

Angenommen, Sie haben ein Modul „binky.py“, das „def foo()“ enthält. Der voll qualifizierte Name dieser Foo-Funktion lautet „binky.foo“. So können verschiedene Python-Module ihre Funktionen und Variablen beliebig benennen und die Variablennamen führen nicht zu Konflikten – „modul1.foo“ unterscheidet sich von „modul2.foo“. In der Python-Terminologie würden wir sagen, dass „binky“, „modul1“ und „modul2“ jeweils eigene „Namespaces“ haben, also Variablennamen, die an Objekte gebunden sind.

Beispielsweise gibt es das Standardmodul „sys“, das einige Standardsystemfunktionen wie die argv-Liste und die Funktion „exit()“ enthält. Mit der Anweisung „import sys“ können Sie dann auf die Definitionen im sys-Modul zugreifen und sie unter ihrem vollständig qualifizierten Namen verfügbar machen, z. B. sys.exit(). Ja, auch „sys“ hat einen Namespace.

  import sys

  # Now can refer to sys.xxx facilities
  sys.exit(0)

Es gibt noch eine andere Importform, die so aussieht: „from sys import argv, exit“. Dadurch sind argv und exit() unter ihren Kurznamen verfügbar. Wir empfehlen jedoch die ursprüngliche Form mit den vollqualifizierten Namen, da es viel einfacher ist, zu ermitteln, woher eine Funktion oder ein Attribut stammt.

Viele Module und Pakete sind in einer Standardinstallation des Python-Interpreters enthalten. Sie müssen also nichts weiter tun, um sie zu verwenden. Sie werden zusammen als „Python Standard Library“ bezeichnet. Zu den häufig verwendeten Modulen/Paketen gehören:

• sys – Zugriff auf exit(), argv, stdin, stdout, …
• re – reguläre Ausdrücke
• os – Betriebssystemoberfläche, Dateisystem

Die Dokumentation aller Standardbibliotheksmodule und ‑pakete finden Sie unter http://docs.python.org/library.

Onlinehilfe, help() und dir()

Es gibt verschiedene Möglichkeiten, Hilfe zu Python zu erhalten.

• Führen Sie eine Google-Suche durch, die mit dem Wort „python“ beginnt, z. B. „python list“ oder „python string lowercase“. Der erste Treffer ist oft die Antwort. Diese Technik scheint für Python besser zu funktionieren als für andere Sprachen.
• Die offizielle Python-Dokumentationswebsite docs.python.org bietet hochwertige Dokumente. Trotzdem finde ich oft, dass eine Google-Suche mit ein paar Wörtern schneller ist.
• Es gibt auch eine offizielle Mailingliste für Tutoren, die speziell für diejenigen gedacht ist, die neu in Python und/oder Programmieren sind.
• Viele Fragen und Antworten finden Sie auf StackOverflow und Quora.
• Verwenden Sie die Funktionen „help()“ und „dir()“ (siehe unten).

Im Python-Interpreter ruft die Funktion „help()“ Dokumentationsstrings für verschiedene Module, Funktionen und Methoden auf. Diese Dokument-Strings ähneln Javadoc-Strings. Mit der Funktion „dir()“ können Sie die Attribute eines Objekts ermitteln. Im Folgenden finden Sie einige Möglichkeiten, wie Sie help() und dir() über den Interpreter aufrufen können:

• help(len): Hilfestring für die integrierte len()-Funktion. Hinweis: Es ist „len“, nicht „len()“, was einen Aufruf der Funktion darstellt, was wir nicht möchten.
• help(sys) – Hilfestring für das sys-Modul (import sys muss zuerst ausgeführt werden)
• dir(sys) – dir() ähnelt help(), enthält aber nur eine kurze Liste der definierten Symbole oder „Attribute“.
• help(sys.exit): Hilfestring für die Funktion exit() im Modul sys
• help('xyz'.split): Hilfestring für die Methode split() für Stringobjekte. Sie können help() mit dem Objekt selbst oder einem Beispiel dieses Objekts und seinem Attribut aufrufen. Das Aufrufen von help('xyz'.split) ist beispielsweise dasselbe wie das Aufrufen von help(str.split).
• help(list) – Hilfestring für list-Objekte
• dir(list): Zeigt list-Objektattribute einschließlich der Methoden an
• help(list.append): Hilfestring für die append()-Methode für list-Objekte