Python-Programmierung: Einführung

Aus Wikibooks

Wechseln zu: Navigation, Suche

<< Inhaltsverzeichnis

Programmiersprachen

Python

Einführung

Inhaltsverzeichnis

1 Erste Schritte mit Python
- 1.1 Installation
- 1.2 Entwicklungsumgebungen
2 Erste Experimente
- 2.1 Aufruf von Python
3 Kontrollstrukturen
4 Über Programme
5 Ein erstes Programm
- 5.1 Codeanalyse
6 Listen mit Python
7 Zusammenfassung

[Bearbeiten] Erste Schritte mit Python

Die beste Methode eine neue Programmiersprache zu lernen ist, mit ihr ein wenig zu spielen und Python ist eine Sprache, die sich geradezu zum spielen und experimentieren anbietet. In den nachfolgenden Abschnitten werden wir uns deswegen dem Thema spielerisch und vor allem ganz unbefangen zuwenden. Die beste Herangehensweise lautet daher auch: Ausprobieren! Auf keine Weise lernt man besser und gewinnt ein Gefühl für eine neue Sprache, als durch experimentieren, ausprobieren und rumspielen. Alles, was dazu benötigt wird, ist ein installierter, funktionsfähiger Pythoninterpreter.

[Bearbeiten] Installation

Die gängigen Linux-Distributionen und Mac OS X enthalten Python im Lieferumfang. Für Windows gibt es unter http://www.python.org/download/ ein (englischsprachiges) Installationspaket, das alles Nötige enthält. Um sich in Python zurechtzufinden sind Englisch-Kenntnisse hilfreich, weil die meisten Dokumentationen nur auf Englisch vorliegen. Für diejenigen, die Python unter Windows nutzen wollen ist die Pythondistribution von Activestate zu empfehlen [1]. Im Lieferumfang dieser Distrubution sind die PyWin32 extensions von Mark Hammond schon enthalten, die es z.B. ermöglichen über die COM-Schnittstelle Windowssoftware mit Python zu bedienen.

[Bearbeiten] Entwicklungsumgebungen

Jeder hat so seine eigenen Vorstellungen, wie man am besten mit Python arbeitet. Die Entwicklung von Python-Programmen ist durchaus mit einem einfachen Texteditor (z.B.: Notepad) möglich. es gibt sogar eine ganze Reihe Leute, die auf Editoren wie vim schwören. Andere bevorzugen spezielle Entwicklungsumgebungen (IDEs). Für Python gibt es davon jede Menge. Ein sehr einfacher, aber doch leistungsfähiger Editor ist IDLE (Integrated DeveLopment Environment), der Teil der Python-Standard-Distribution ist und im Normalfall nicht extra installiert werden muss. IDLE ist besonders für Anfänger geeignet, wird aber auch noch von vielen Profis verwendet. Weitere IDEs sind beispielsweise ERIC, Download hier [2] und pydev - ein Plugin für eclipse, DrPython.

[Bearbeiten] Erste Experimente

[Bearbeiten] Aufruf von Python

Für erste Gehversuche genügt unter Unix die Eingabe von python in einem beliebigen Terminal-Fenster. Unter Windows sollte im Startmenü eine Gruppe Python 2.5 zu finden sein. Das Fenster erscheint in etwa so (Versionsnummern können abweichen):

Python 2.5.4 (r254:67916, Feb 17 2009, 20:16:45)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Mit dieser Ausgabe meldet Python seine Bereitschaft sich mit einem in einer interaktiven Sitzung zu unterhalten. Das heißt, dass der interaktive Python-Interpreter auf eine Eingabe wartet. Dieser meldet sich mit dem >>>-Zeichen (meist Prompt genannt). Probieren wir es doch gleich einmal aus, in dem wir hinter dem Prompt folgendes eingeben:

>>> print("Hallo Welt!")
Hallo Welt!

Herzlichen Glückwunsch! Unser erstes Pythonprogramm... na ja, Progrämmchen. Eine Programmiersprache »Hallo Welt!« ausgeben zu lassen, scheint auf den ersten Blick ziemlich langweilig zu sein und ist es im Prinzip auch, zeigt aber, wenn man es mit anderen Programmiersprachen vergleicht, schon ein paar interessante Eigenschaften einer Sprache, z.B., dass es in Python nicht notwendig ist, ein Statement mit einem Semikolon abzuschließen. Guter Pythonstil heißt, eine Anweisung, Funktion, Zuweisung, Befehl, Vergleich usw. pro Zeile.

In unserem Fall haben wir es mit einem Funktionsaufruf zu tun, nämlich mit der Funktion print()^[1], die ihre Argumente, das Zeug in den runden Klammern, ausgibt, was in diesem Fall Wert vom Typ Zeichenkette ist, nämlich "Hallo Welt!". Python verfügt über viele Datentypen, z.B. Zahlen:

[Bearbeiten] Zahlen

Python kann man wie einen Taschenrechner benutzen. Natürlich werden alle Rechenregeln, wie Klammern, Punkt vor Strichrechnung, usw. korrekt beachtet:

>>> 7 + 3 * 4
19

Möchte man, wie in der Mathematik üblich, die Reihenfolge der Berechnung ändern, kann man Klammern einsetzten:

>>> (7 + 3) * 4
40

Python unterscheidet unterschiedliche Zahlentypen. Was wir bisher verwendet haben, sind ganze Zahlen, was man deutlich sehen kann, wenn wir uns an einer Division versuchen:

>>> 1 / 3
0
>>> 1 % 3
1

Man wird mir sicherlich zustimmen, dass die Division von 1 durch 3 nicht Null ergibt. Bei der ganzzahligen Divisionen werden die Nachkommastellen einfach abgeschnitten. Zum Glück gibt es aber noch den Modulooperator %, der den ganzzahligen Rest liefert. Möchte man hingegen mit Fließpunktzahlen rechnen, ist dies überhaupt kein Problem. Es reicht, wenn eine Zahl einen Dezimalpunkt besitzt:

>>> 1. / 3
0.33333333333333331

Wie genau Pythons Fließpunktzahlen sind, hängt übrigens von der Implementierung ab (Es gibt mehr als eine Python-Version).

Ausdrücke sind nicht nur mit Zahlen möglich, sondern auch mit Text. Eine ausführliche Aufstellung aller Varianten wird in einem folgenden Kapitel gegeben:

 >>> "ha"*3
 'hahaha'

Mit dem Gleichheitszeichen (=) können einer Variablen Werte zugewiesen werden.^[2]

 >>> a = 20
 >>> b = 5*9
 >>> a*b
 900

Komplexe Zahlen werden auch unterstützt. Dabei wird an den Imaginärteil ein "j" oder ein "J" angehängt. Komplexe Zahlen können auch mit der Funktion complex erzeugt werden.

 >>> 1j * 1J
 (-1+0j)
 >>> 1j * complex(0,1)
 (-1+0j)
 >>> (1+2j)/(1+1j)
 (1.5+0.5j)

[Bearbeiten] Zeichenketten

Zeichenketten (Strings) werden wahlweise von einfachen oder doppelten Anführungszeichen eingeschlossen

 >>> 'Hans'
 'Hans'
 >>> "Meier"
 'Meier'
 >>> "Brown'sche Bewegung"
 "Brown'sche Bewegung"
 >>> "Er sagte \"Ja\"."
 'Er sagte "Ja".'

Zeichenketten können mit dem Operator + konkateniert werden.

 >>> name = 'Hans' + ' ' + 'Meier' 
 >>> name
 'Hans Meier'

Zeichenketten sind einfach Listen (Arrays) von Zeichen. Man kann daher über den Index auf einzelne Zeichen zugreifen. Mit dem Slice-Operator : (start:stop) können auch Teilzeichenketten angesprochen werden.

 >>> name = 'Christian'
 >>> name[0]
 'C'
 >>> name[0:4]
 'Chri'
 >>> name[:2]
 'Ch'
 >>> name[3:4]
 'i'
 >>> name[5:]
 'tian'
 >>> name[:-3]
 'Christ'
 >>> name[-3:]
 'ian'
 >>> name[:4] + name[4:]
 'Christian'
 >>> len(name)
 9

Allerdings ist es nicht erlaubt einzelne Zeichen einer Zeichenkette auszutauschen.

 >>> wort = 'Hund'
 >>> wort[1] = 'a'
 Traceback (most recent call last):
 File "<stdin>", line 1, in ?
 TypeError: object doesn't support item assignment

Zeichenketten in Unicode werden mit vorangestelltem u deklariert.

 >>> x = u"äöü"
 >>> x
 u'\xe4\xf6\xfc'
 >>> print x
 äöü
 >>> str(x)
 Traceback (most recent call last):
  File "<stdin>", line 1, in ?
 UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2:
 ordinal not in range(128)

Zum Umwandeln eines Unicode-Strings in einen 8-bit String wird die Methode encode verwendet, oder decode für die andere Richtung..

 >>> y = x.encode('utf-8')
 >>> y
 '\xc3\xa4\xc3\xb6\xc3\xbc'
 >>> print y
 ├ñ├Â├╝
 >>> y.decode('utf-8')
 äöü
 >>> print unicode(y, 'utf-8')
 äöü

[Bearbeiten] Listen

 >>> a = ['dings', 'bums', 100, 9.9]
 >>> a
 ['dings', 'bums', 100, 9.9]
 >>> len(a)
 4
 >>> a[0]
 'dings'
 >>> a[3]
 9.9
 >>> a[1:-1]
 ['bums', 100]
 >>> a[:2] +['kirch', 5]
 ['dings', 'bums', 'kirch', 5]
 >>> a.append(7.8)
 ['dings', 'bums', 'kirch', 5, 7.8]

Listen können ineinander verschachtelt werden.

 >>> a = [1, 2, [3, 4], 5]
 >>> len(a)
 4
 >>> a[1]
 2
 >>> a[2]
 [3, 4]
 >>> a[2][1]
 4
 >>> a[2].append(6)
 [1, 2, [3, 4, 6], 5]

Um Python zu verlassen, gibt man unter Unix Strg+D und unter Windows Strg+Z ein. Eine laufende Berechnung kann mit Strg+C abgebrochen werden.

[Bearbeiten] Kontrollstrukturen

[Bearbeiten] if Anweisung

 >>> x = int(raw_input("Gib eine Zahl ein: "))
 >>> if x < 0:
 ...     x=0
 ...     print ("Negative Zahl zu Null geändert.")
 ... elif x == 0:
 ...     print "Null!"
 ... else:
 ...     print "Positive Zahl!"
 ...

[Bearbeiten] for Anweisung

Die For-Anweisung in Python ist mit der foreach-Anweisung in PHP oder VBA vergleichbar. Sie iteriert über die Elemente eine Sequenz, also einer Liste oder eines Generators.

 >>> namelist = ['Hans', 'Uli', 'Sabine']
 >>> for name in namelist:
 ...    print name, len(name)
 ...
 Hans 4
 Uli 3
 Sabine 6

Mit der Funktion range kann eine Sequenz von ganzen Zahlen erzeugt werden.

 >>> range(5)
 [0, 1, 2, 3, 4]
 >>> range(5,10)
 [5, 6, 7, 8, 9]
 >>> for i in range(3):
 ...     print i*i
 ...
 0
 1
 4
 >>> for i in range( len(namelist) ):
 ...     print namelist[i], len(namelist[i])
 ...
 Hans 4
 Uli 3
 Sabine 6

[Bearbeiten] while Anweisung

Die while-Schleife hat keine Besonderheiten. Sie wird so lange ausgeführt, solange die Bedingung wahr ist.

 >>> # Fibonacci Folge:
 ... a, b = 0, 1
 >>> while b < 10:
 ...       print b
 ...       a, b = b, a+b
 ... 
 1
 1
 2
 3
 5
 8

[Bearbeiten] break, continue und else

Die Anweisung 'break' beendet die aktuelle Schleife durch einen Sprung an die erste, der aktuellen Schleife folgende Anweisung. Die Anweisung 'continue' verzweigt an die erste Anweisung vor dem Schleifeneingang.

 >>> for i in range(5):
 ...     if i == 2:
 ...         break
 ...     print i
 ...
 0
 1
 >>> for i in range(5):
 ...     if i == 2:
 ...         continue
 ...     print i
 ...
 0
 1
 3
 4

Die for- und die while-Schleife besitzen in Python noch eine else-Anweisung. Diese wird ausgeführt falls die Sequenz aufgebraucht (for) bzw. die Bedingung unwahr (while) ist und die Schleife nicht durch eine break-Anweisung beendet wurde.

 >>> namelist = ['Hans', 'Uli', 'Sabine']
 >>> suche = str(raw_input("Bitte gib einen Namen ein: "))
 >>> for name in namelist:
 ...     if name == suche:
 ...         print suche+" gefunden!"
 ...         break
 ... else:
 ...     print suche+" nicht vorhanden!"
 ...

[Bearbeiten] Funktionen

[Bearbeiten] Über Programme

Die "Taschenrechner"-Funktion ist nützlich, um sich mit der Sprache vertraut zu machen, oder auch, um schnell einen Programmteil auszuprobieren. In den meisten Fällen wird man jedoch ein Programm schreiben wollen, das wiederholt ausgeführt werden kann, ohne jedesmal die gesamte Befehls-Sequenz abtippen zu müssen. Nur so lassen sich komplexere Aufgabenstellungen lösen.

Programme sind Textdateien, die Python-Anweisungen enthalten.

[Bearbeiten] Ein erstes Programm

Als einfaches Beispiel für ein erstes Programm soll die Berechnung von Fibonacci-Zahlen dienen. Diese Zahlen sind u.a. eine gute Näherung des Goldenen Schnittes, der in der Architektur und Kunst bedeutsam ist. In der Mathematik ist die Folge der Fibonacci-Zahlen so definiert:

Die ersten beiden Fibonacci-Zahlen haben den Wert 1
Jede weitere Zahl der Folge ist die Summe ihrer beiden Vorgänger.

Es ergibt sich eine Folge, die so anfängt:

1, 1, 2, 3, 5, 8, 13, 21, 34...

Für den Anfang betrachten wir ein ganz altmodisches Programm, das dem Muster Eingabe-Verarbeitung-Ausgabe (EVA) genügt. Es berechnet für eine gegebene Zahl N die ersten N Fibonacci-Zahlen. So sieht es aus, Erklärungen weiter unten.

import sys
 
N = int( sys.argv[1])
fib1, fib2 = 1, 1
for step in range( N):
  print fib1, 
  fib1, fib2 = fib2, fib1+fib2

Wichtig ist, daß die letzten beiden Zeilen etwas weiter eingerückt sind, und zwar genau gleich weit. Ob zur Einrückung Tabulatoren oder Leerzeichen verwendet werden, ist egal, solange beide Zeilen auf die gleiche Art eingerückt sind.

Da das Progrämmchen Fibonacci-Zahlen errechnet, ist naheliegend, es z.B. als fibo.py zu sichern. Unter Unix ist die Endung .py nicht zwingend erforderlich, wird aber meist dennoch benutzt.

Um das Programm unter Unix / Linux / Mac OS X auszuführen, gebe man im Terminal ein:

python fibo.py 100

Unter Windows kann man es entweder in SciTe mit F5 starten, oder in der Eingabeaufforderung den Programmnamen eingeben:

fibo.py 100

[Bearbeiten] Codeanalyse

Anhand des Beispielprogrammes lassen sich einige Grundprinzipien von Python vorstellen. Eine systematische Einführung in die Sprache findet sich in den folgenden Kapiteln.

#!/usr/bin/python

Unter Unix kann man Scripte als eigenständige Programme ausführen, wenn in der ersten Zeile (in dieser merkwürdigen Schreibweise, auch Shebang Hack genannt) steht, in welcher Sprache das Skript geschrieben ist. In den meisten Fällen kann man das weglassen, aber die Angabe schadet nicht. Das Zeichen # dient in Python zur Einleitung eines Kommentares. Kommentare können überall erscheinen, sämtlicher Text ab dem Kommentarzeichen bis zum Zeilenende wird ignoriert.

import sys
N = int(sys.argv[1])

Das Programm erwartet eine Zahl als Eingabe. Um den beim Programmaufruf anzugebenen Wert zu bekommen, benötigen wir das Modul sys. Durch den import eines Modules können bereits vorhandene Funktionen für ein Programm nutzbar gemacht werden. Es gibt eine Unmenge an Modulen für alle denkbaren Aufgaben.

sys.argv[1] bezeichnet den ersten Text, der nach fibo.py auf der Kommandozeile angegeben wurde, in unserem Fall also die Zeichenkette 100. Mit int() wird der Text 100 in eine Zahl umgewandelt, mit der man rechnen kann. Diese Zahl wird der Variable N zugewiesen.

fib1, fib2 = 1, 1

Um anzufangen, benötigen wir die ersten zwei Fibonacci-Zahlen. Die jeweils aktuelle Zahl soll fib1 heißen, die folgende fib2. In Python kann man mehrere Variablen simultan belegen.

for step in range( N):

range(N) ist der Zahlenbereich von 0 bis N-1. Mit for step in range(N) werden die eingerückten Anweisungen mehrfach ausgeführt, wobei step zuerst den Wert 0 annimmt, dann im nächsten Durchlauf 1, und so fort, bis N erreicht wird. Wie oben bereits erläutert, spielt die Einrückung eine Rolle. Im Falle einer for-Anweisung (die mit einem Dopppelpunkt enden muß), werden die nachfolgenden eingerückten Anweisungen für jeden Wert von step durchlaufen. Wenn eine Zeile mit einem Doppelpunkt endet und die nachfolgenden Zeilen eingerückt sind, bezeichnet man dies auch als Block.

print fib1, 
fib1, fib2 = fib2, fib1+fib2

Mit print wird ein Wert ausgegeben. Anders als im Taschenrechner-Modus werden bei der Abarbeitung eines Programmes nicht automatisch alle Ergebnisse angezeigt, sondern nur solche, die mit print explizit gedruckt werden. Das abschließende Komma in print fib1, sorgt dafür, daß die Zahlen, in einer Zeile ausgegeben werden. Mit print fib1 (also ohne Komma) würde jeder Wert in einer eigenen Zeile erscheinen.

In der folgenden Zuweisung werden die Werte der Fibonacci-Folge gebildet, die beim nächsten Durchlaufen der for-Anweisung benutzt werden. Man beachte, daß alle Ausdrücke auf der rechten Seite der Zuweisung ausgewertet werden, bevor die Variablen auf der linken Seite geändert werden. Dies ist dann wichtig, wenn auf beiden Seiten dieselben Variablennamen erscheinen, so wie hier.

[Bearbeiten] Listen mit Python

Eine Liste ist eine Folge von verschiedenartigen Objekten mit einer eindeutig festgelegten Reihenfolge. Es ist möglich in einer bestehenden Liste Objekte hinzuzufügen oder wegzunehmen oder deren Reihenfolge zu verändern.

liste_figur=["A", 2, "B", 3, "C", 4]
for schritt in range (0,len(liste_figur)):
		      print liste_figur[schritt]*liste_figur[schritt+1]

Mit "liste_figur" wird die nachstehende "Liste" definiert. Diese besteht aus mehreren Objekten, wobei man in diesem Fall zwischen zeien unterscheidet

"A" - Wird als Text erkannt und auch nur SO wie geschrieben ausgegeben
2 - Wird als Zahl erkannt, die den vornestehenden Text mit ihrem Wert multipliziert

[Bearbeiten] Zusammenfassung

Python ist eine interpretierte Sprache, d.h. man kann sie interaktiv benutzen.
Programme sind simple Textdateien, die durch den Python-Interpreter abgearbeitet werden können.
Blöcke werden durch Einrückungen gekennzeichnet.
Kommentare werden durch das Zeichen # eingeleitet.