Diese Seite wurde von der Cloud Translation API übersetzt.

Einführung in Python

Auftakt

Willkommen beim Online-Tutorial zu Python von Google. Er basiert auf dem intern angebotenen Einführungskurs zu Python. Wie auf der Einrichtungsseite erwähnt, wird in diesem Material Python 3 behandelt.

Wenn Sie einen begleitenden MOOC-Kurs suchen, probieren Sie die Kurse von Udacity und Coursera aus (Einführung in die Programmierung [Anfänger] oder Einführung in Python). Wenn Sie schließlich ohne Videos selbstgesteuertes Online-Lernen suchen, probieren Sie die am Ende dieses Beitrags aufgeführten aus. Sie enthalten jeweils Lerninhalte sowie einen interaktiven Python-Interpreter, mit dem Sie üben können. Was ist mit dem „Interpreter“ gemeint? Das erfahren Sie im nächsten Abschnitt.

Einführung in die Sprache

Python ist eine dynamische, interpretierte (Bytecode-kompilierte) Sprache. Im Quellcode sind keine Typdeklarationen von Variablen, Parametern, Funktionen oder Methoden vorhanden. Dadurch wird der Code kurz und flexibel, aber die Typüberprüfung des Quellcodes zur Kompilierzeit geht verloren. Python verfolgt die Typen aller Werte zur Laufzeit und kennzeichnet Code, der keinen Sinn ergibt, während er ausgeführt wird.

Eine gute Möglichkeit, um zu sehen, wie Python-Code funktioniert, ist, den Python-Interpreter auszuführen und Code direkt einzugeben. Wenn Sie sich jemals fragen, was passiert, wenn Sie ein int zu einem list hinzufügen, ist es am schnellsten und wahrscheinlich am besten, wenn Sie es einfach in den Python-Interpreter eingeben. (Unten sehen Sie, 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 der Eingabe von „python“ und vor dem Prompt „>>>“ ausgibt, enthalten Informationen zur verwendeten Python-Version und dazu, wo sie erstellt wurde. Solange als Erstes „Python 3.“ ausgegeben wird, sollten diese Beispiele funktionieren.

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

Python-Quellcode

Python-Quelldateien haben die Erweiterung „.py“ und werden als „Module“ bezeichnet. Bei einem Python-Modul hello.py ist die einfachste Möglichkeit, es auszuführen, der Shell-Befehl „python hello.py Alice“. Damit wird der Python-Interpreter aufgerufen, um den Code in hello.py auszuführen und das Befehlszeilenargument „Alice“ zu übergeben. Auf der offiziellen Dokumentationsseite finden Sie alle verschiedenen Optionen, die Ihnen beim Ausführen von Python über die Befehlszeile zur Verfügung stehen.

Hier ist ein sehr einfaches hello.py-Programm. Beachten Sie, dass Codeblöcke streng durch Einrückung und nicht durch geschweifte Klammern begrenzt werden. Dazu später mehr.

#!/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()

Wenn Sie dieses Programm über die Befehlszeile ausführen, sieht das 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“ werden einmalig ausgeführt. 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 es kann importiert und von einem anderen Modul 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 das Modul von einem anderen Modul importiert wird.

In einem Standard-Python-Programm enthält die Liste sys.argv die Befehlszeilenargumente auf die Standardweise, wobei sys.argv[0] das Programm selbst, sys.argv[1] das erste Argument usw. ist. Wenn Sie argv oder die Anzahl der Argumente kennen, können Sie diesen Wert einfach mit len(sys.argv) von Python anfordern, wie wir es oben im interaktiven Interpretercode beim Anfordern der Länge eines Strings getan haben. Im Allgemeinen kann len() Ihnen mitteilen, wie lang ein String ist, wie viele Elemente in Listen und Tupeln (einer weiteren arrayähnlichen Datenstruktur) enthalten sind und wie viele Schlüssel/Wert-Paare in einem Dictionary 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, dass die Zeilen, aus denen die Funktion oder die If-Anweisung besteht, alle dieselbe Einrückungsebene haben. Außerdem haben wir zwei verschiedene Möglichkeiten zum Wiederholen von Strings vorgestellt. Der Operator + ist benutzerfreundlicher, aber * funktioniert auch, da er der „Repeat“-Operator von Python ist. Das bedeutet, dass '-' * 10 das Ergebnis '----------' liefert. So lässt sich auf dem Bildschirm eine „Linie“ erstellen. Im Codekommentar haben wir darauf hingewiesen, dass * schneller als + ist. Das liegt daran, dass mit * die Größe des resultierenden Objekts nur einmal berechnet wird, während diese Berechnung mit + jedes Mal erfolgt, wenn + aufgerufen wird. Sowohl „+“ als auch „*“ werden als „überladene“ Operatoren bezeichnet, da sie für Zahlen und Strings (und andere Datentypen) unterschiedliche Bedeutungen haben.

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

Hier ist Code, der die oben genannte Funktion „repeat()“ aufruft und die Rückgabe ausgibt:

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

Zur Laufzeit müssen Funktionen durch die Ausführung einer „def“-Anweisung definiert werden, bevor sie aufgerufen werden. Normalerweise wird eine main()-Funktion unten in der Datei definiert, wobei die von ihr aufgerufenen Funktionen darüber stehen.

Einzug

Eine ungewöhnliche Python-Funktion ist, dass die Einrückung von Code durch Leerzeichen seine Bedeutung beeinflusst. Ein logischer Block von Anweisungen, z. B. die Anweisungen, die eine Funktion bilden, sollten alle dieselbe Einrückung haben, die durch die Einrückung der übergeordneten Funktion oder „if“ usw. festgelegt wird. Wenn eine der Zeilen in einer Gruppe eine andere Einrückung hat, wird sie als Syntaxfehler gekennzeichnet.

Die Verwendung von Leerzeichen in Python fühlt sich anfangs etwas seltsam an, ist aber logisch und ich habe mich sehr schnell daran gewöhnt. Vermeiden Sie die Verwendung von TABs, da sie das Einrückungsschema erheblich verkomplizieren. Außerdem können TABs auf verschiedenen Plattformen unterschiedliche Bedeutungen haben. Stellen Sie Ihren Editor so ein, dass für Python-Code Leerzeichen anstelle von Tabulatoren eingefügt werden.

Eine häufige Frage von Anfängern lautet: „Wie viele Leerzeichen soll ich einrücken?“ Gemäß dem offiziellen Python-Styleguide (PEP 8) sollten Sie mit 4 Leerzeichen einrücken. (Fun Fact: Die interne Style-Richtlinie von Google sieht eine Einrückung von 2 Leerzeichen vor.)

Code wird zur Laufzeit geprüft

Python führt nur sehr wenige Prüfungen zur Kompilierzeit durch und verschiebt fast alle Prüfungen von Typ, Name usw. für jede Zeile bis zur Ausführung dieser Zeile. Angenommen, die obige main()-Funktion ruft repeat() so auf:

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

Die if-Anweisung enthält einen offensichtlichen Fehler, bei dem die Funktion „repeat()“ versehentlich als „repeeeet()“ eingegeben wurde. Das Lustige an Python: Dieser Code wird kompiliert und ausgeführt, solange der Name zur Laufzeit nicht „Guido“ ist. Erst wenn ein Lauf tatsächlich versucht, „repeeeet()“ auszuführen, wird bemerkt, dass es keine solche Funktion gibt, und es wird ein Fehler ausgegeben. Außerdem enthält dieser Snippet einen zweiten Fehler: Der Variablen „name“ wurde kein Wert zugewiesen, bevor sie mit „Guido“ verglichen wurde. In Python wird ein „NameError“ ausgelöst, wenn Sie versuchen, eine nicht zugewiesene Variable auszuwerten. Hier sind einige Beispiele, die zeigen, dass bei der ersten Ausführung eines Python-Programms einige der ersten Fehler, die Sie sehen, einfache Tippfehler oder nicht initialisierte Variablen wie diese sind. Hier haben Sprachen mit einem ausführlicheren Typsystem wie Java einen Vorteil, da solche Fehler zur Kompilierzeit erkannt werden können. Allerdings müssen Sie natürlich alle diese Typinformationen verwalten.

Mit Python 3 wurden Typhints eingeführt. Mit Typ-Hinweisen können Sie angeben, welchen Typ die einzelnen Argumente in einer Funktion haben und welchen Typ das von der Funktion zurückgegebene Objekt hat. In der annotierten Funktion def is_positive(n: int) -> bool: ist das Argument n beispielsweise ein int und der Rückgabewert ein bool. Wir werden später noch genauer darauf eingehen, was diese Typen bedeuten. Die Angabe von Typ-Hinweisen ist jedoch völlig optional. Immer mehr Code verwendet Typ-Hinweise, da einige Editoren wie cider-v und VS.code Prüfungen durchführen können, um zu bestätigen, dass Ihre Funktionen mit den richtigen Argumenttypen aufgerufen werden. Sie können sogar Argumente vorschlagen und validieren, während Sie Code bearbeiten. In diesem Tutorial werden keine Typ-Hinweise behandelt. Wir möchten aber, dass Sie wissen, was sie sind, falls Sie davon hören oder sie in der Praxis sehen.

Variablennamen

Da Python-Variablen im Quellcode keinen expliziten Typ haben, ist es besonders hilfreich, ihnen aussagekräftige Namen zu geben, um sich daran zu erinnern, was passiert. 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 dadurch, dass vergessen wird, welcher Werttyp in jeder Variablen enthalten ist. Verwenden Sie daher Ihre Variablennamen (die Sie wirklich haben), um den Überblick zu behalten.

Was die tatsächliche Benennung angeht, werden in einigen Sprachen unterstrichene_Teile für Variablennamen bevorzugt, die aus „mehr als einem Wort“ bestehen, in anderen Sprachen wird CamelCase bevorzugt. Im Allgemeinen bevorzugt Python die Unterstrichmethode, empfiehlt Entwicklern jedoch, sich an die CamelCase-Schreibweise zu halten, wenn sie in vorhandenen Python-Code integriert wird, der diesen Stil bereits verwendet. Lesbarkeit ist wichtig. Weitere Informationen finden Sie im Abschnitt zu Namenskonventionen in PEP 8.

Wie Sie sich sicher denken können, dürfen Keywords wie „if“ und „while“ nicht als Variablennamen verwendet werden. Andernfalls erhalten Sie einen Syntaxfehler. Achten Sie jedoch darauf, keine integrierten Funktionen als Variablennamen zu verwenden. Die Namen „str“, „list“ und „print“ scheinen beispielsweise gute Namen zu sein, aber Sie würden diese Systemvariablen überschreiben. Integrierte 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 eine „def foo()“ enthält. Der vollständig qualifizierte Name dieser Funktion „foo“ ist „binky.foo“. Auf diese Weise können verschiedene Python-Module ihre Funktionen und Variablen beliebig benennen, ohne dass es zu Konflikten bei den Variablennamen kommt. module1.foo unterscheidet sich von module2.foo. Im Python-Vokabular würden wir sagen, dass binky, module1 und module2 jeweils eigene „Namespaces“ haben, die, wie Sie sich vorstellen können, Bindungen von Variablennamen an Objekte sind.

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

  import sys

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

Es gibt ein weiteres Importformular, das 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 so viel einfacher ist, zu ermitteln, woher eine Funktion oder ein Attribut stammt.

Viele Module und Pakete sind in einer Standardinstallation des Python-Interpreters enthalten, sodass Sie nichts weiter tun müssen, um sie zu verwenden. Sie werden zusammen als „Python-Standardbibliothek“ bezeichnet. Häufig verwendete Module/Pakete:

sys – Zugriff auf exit(), argv, stdin, stdout usw.
re – reguläre Ausdrücke
os – Betriebssystemschnittstelle, 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 aus irgendeinem Grund bei Python besser zu funktionieren als bei anderen Sprachen.
Die offizielle Python-Dokumentationswebsite docs.python.org bietet hochwertige Dokumentation. Trotzdem finde ich es oft schneller, ein paar Wörter in die Google Suche einzugeben.
Es gibt auch eine offizielle Tutor-Mailingliste, die speziell für Personen gedacht ist, die neu in Python und/oder Programmierung 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 Docstrings ähneln Javadocs. Mit der Funktion dir() können Sie die Attribute eines Objekts abrufen. Hier sind einige Möglichkeiten, wie Sie help() und dir() über den Interpreter aufrufen können:

help(len) – Hilfestring für die integrierte Funktion len(). Beachten Sie, dass es sich um „len“ und nicht um „len()“ handelt. „len()“ ist ein Aufruf der Funktion, den wir nicht möchten.
help(sys) – Hilfestring für das Modul sys (zuerst muss import sys ausgeführt werden)
dir(sys) – dir() ähnelt help(), bietet 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) – Hilfetext für die Methode split() für String-Objekte. Sie können help() mit dem Objekt selbst oder einem Beispiel dieses Objekts sowie seinem Attribut aufrufen. Der Aufruf von help('xyz'.split) entspricht beispielsweise dem Aufruf von help(str.split).
help(list) – Hilfetext für list-Objekte
dir(list): Zeigt list-Objektattribute an, einschließlich der zugehörigen Methoden.
help(list.append) – Hilfestring für die Methode append() für list-Objekte

Einführung in Python Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.