Ich habe hier eine kleine Einführung in Python (Version 2.2, neuere Versionen wurden nur zufällig berücksichtigt) geschrieben, die auf den Kenntnissen eines C-Programmierers aufbaut. Es wird also in erster Linie einen Überblick über die imperativen Sprachelemente von Python gegeben.
In Python gelten die gleichen Regeln für Bezeichner wie in C (Buchstaben, Unterstrich, am Anfang keinen Ziffern).
In Pyton gibt es weniger Overhead, als in C. Man kann in einer neuen (leeren) Datei anfangen zu programmieren, ohne vorher viele Standardkonstrukte einfügen zu müssen.
and else import raise assert except in return break exec is try class finally lambda while continue for not yield def from or del global pass elif if print
Variablen besitzen keinen Typ, sie zeigen eigentlich nur dynamisch auf ein Objekt von einem gewissen Typ. Also besitzt nicht die Variable einen Typ, sondern nur das Datum. Man kann also einer Variablen nacheinander beliebige Daten zuweisen, ohne sich weitere Gedanken zu machen.
Das bedeutet eine dynamische Typisierung, im Gegensatz zu Cs statischer Typisierung.
double.
j) geschrieben werden.
Das leidige Thema unter C ist einer der Glanzpunkte von Python.
Es gibt keine Zeichenkonstanten, sondern nur Strings. Diese werden in einfache
(`) oder (wie in C) in doppelte (") Hochkommata eingeschlossen. Die
jeweils andere Variante muss dabei nicht maskiert werden.
Man muss allerdings wie unter C Sonderzeichen maskieren (alle Ersatzdarstellungen von Steuerzeichen gelten auch für Python).
Zeilenumbrüche dürfen nicht direkt darin vorkommen, sondern müssen durch die
Ersatzdarstellung \n eingefügt werden. Dennoch kann man einen String in
mehreren Zeilen schreiben, indem man wie in C einem \ direkt einen
Zeilenumbruch folgen lässt (wird dann entfernt und ignoriert).
Will man die Zeilenumbrüche des Quelltextes auch wirklich in dem String haben,
dann muss man ihn in drei einfache oder doppelte Hochkommata einfassen
(``` oder """).
Wie in C: + - * / für die beiden Zahlarten. Daneben gibt es ebenfalls
die kombinierten Zuweisungen += -= *= /=.
Sind (z.T.) geordnete Felder, auf die man durch Indizierung zugreift
([<Index>] wie in C). Neu am Zugriff ist allerdings, dass man auch
negative Indizes für eine Zählung von Hinten einsetzen kann.
Außerdem kann man sog. Slices benutzen: das sind Index-Intervalle, die
Teilsequenzen definieren. a:e definiert den Bereich a, a+1, ..., b-1.
Lässt man eine Grenze weg, dann reicht das Intervall bis zur Sequenzgrenze.
Strings stellen ein Feld der Länge n dar, das die Indexpositionen 0 bis n-1 besitzt (wie in C). Alle Einträge sind Zeichen. Strings werden durch Stringkonstanten angelegt.
Tupel sind ebenfalls Felder, allerdings können die Einträge von einem
beliebigen Typ sein. Tupel legt man durch
(Wert1, Wert2) an. Man kann die Klammern auch weglassen.
Sind analog zu Tupeln
[,]
Dictionaries sind im strengen Verständnis gar keine Sequenzen, weil die Ordnung
fehlt, sie lassen sich aber ähnlich behandeln wie Sequenzen.
Der einzige wesentliche Unterschied ist, dass zur Indizierung nicht die natürlichen Zahlen benutzt werden, sondern eine
vorher noch nicht festgelegte Menge von Schlüsseln (Strings).
So definiert man ein Dictionary-Objekt wie folgt:
{<key_1>:<wert_1>, <k2>:<w2>}
Man kann also den Variablennamen genau wie eine Abbildung benutzen, die jedem
Schlüssel ihren Wert zuweist.
Slicing (s.o.) ist nicht möglich.
Um einen Wert auszugeben benutzt man die Anweisung print gefolgt von
einem Tupel von Variablen oder Konstanten. Man kann alle möglichen Datentypen
auf diese Weise ausgeben lassen.
Ähnlich wie in C: if-Bedingung. Aufruf:
if <Bedingung>:
<Anweisung>
Alle abhängigen Anweisungen müssen einheitlich eingerückt sein. Die Bedingung
kann aus Teilbedingungen durch and, or oder not zusammengesetzt sein.
Erweiterung:
if <Bedingung>:
<Anweisung>
elif <Bedingung>:
<Anweisung>
else:
<Anweisung>
Dabei können elif und else unabhängig voneinander benutzt oder
weggelassen werden. Man beachte die Doppelpunkte, die unbedingt gebraucht werden!
Es gibt im Gegensatz zu C nur eine Form:
while <Bedingung>:
<Anweisung>
Solange die Bedingung wahr ist, wird die Anweisung (und alle direkt folgenden, gleich eingerückten Zeilen mit Anweisungen) ausgeführt.
Falls die Schleife ohne Unterbrechungen (durch break oder continue) beendet
wird, dann kann ein optionaler
else:
<Anweisung>
Block durchlaufen werden.
Will man eine Anweisung häufig (z.B. für alle Elemente einer Liste) ausführen, dann bietet Python dafür einen sehr eleganten Mechanismus:
for <Zähler> in <Sequenz>:
<Anweisung>
Der Zählvariable werden nacheinander alle Werte in der Sequenz zugewisen. Für jede Belegung wird die Anweisung ausgeführt.
def <Funktionsname>():
<Anweisung>
Optional kann man hier eine kommaseparierte Liste von Parametern
in die Klammern schreiben, die
dann in der gleichen Reihenfolge auch im Funktionsaufruf stehen müssen.
Man kann für die Argumente einfach Defaultwerte festlegen, indem man ihn dem
entsprechenden Parameter in der Definition zuweist
(<Parameter>=<Defaultwert>). Man kann beim Aufruf auch in
beliebiger Reihenfolge den Parametern ihren Wert zuweisen.
Argumente werden call-by-reference-übergeben.
Der Rückgabewert muss nicht im Kopf der Funktion berücksichtigt werden. Man gibt
einfach einen gewünschten Wert per return-Anweisung zurück, fertig. Damit
kann eine Funktion theoretisch auch verschiedene Rückgabewerte liefern.
Hinweis: Man kann nicht mehr als 1000 rekursive Aufrufe erledigen, dann bricht das Laufzeitsystem ab. Ein weiterer Grund, iterative Verfahren zu entwickeln.
Module werden durch Dateien definiert. Modul- und Dateiname stimmen bis auf
die Endung .py überein.
Man importiert Module durch
import <Modul> (qualifizierte Aufrufe nötig) oder durch
from <Modul> import <Funktion> (keine weitere Qualifizierung von Funktionen
nötig, dafür aber eine Überdeckung anderer, gleichlautender Funktionen möglich).
Bei zweiterer Form werden nur die angegebenen Funktionen (* möglich) aus
dem Modul importiert.
So ist es leicht, seine Funktionen in Module zu gliedern.
Ähnlich wie in C:
assert <Bedingung>
Falls die Bedingung verletzt ist, wird eine Ausnahme ausgelöst.
Bei der Optimierung werden die assert-Anweisungen eliminiert.