Warum Python?

Die Programmierumgebung

Der normale Pythoninterpreter wird mit dem Befehl python aufgerufen. 

   1 python
   2 #Python 2.4.4 (#2, Apr  5 2007, 20:11:18)
   3 [GCC 4.1.2 20061115 (prerelease) (Debian 4.1.1-21)] on linux2
   4 Type "help", "copyright", "credits" or "license" for more information.
   5 >>>

Ein Python Programm startet man entweder durch Aufruf des Interpreters und des Programmnamens 

   1 python hello.py
   2 Hallo Welt

Oder als ausführbares Programm 

   1 ./hello.py
   2 Hallo Welt

Dazu muss das Programm zuvor mit einer Magic-Line #!/usr/bin/python versehen werden und die Rechte mit chmod +x hello.py ensprechend gesetzt werden.

Der Quelltext des Programms mit dem Dateinamen hello.py sieht wie folgt aus. Die Endung .py ist Konvention für Python Programme. 

   1 #!/usr/bin/python
   2 print "Hallo Welt"

Das Programm kann mit einem Editor (z.B. nedit oder xemacs) erzeugt und verändert werden.

IPython

http://ipython.scipy.org/

IPython (Aufruf ipython) bietet eine stark erweiterte Interaktive Funktionalität des Interpreters (in Anlehnung an IDL und MATLAB).

Nützlich sind die Magic-Kommandos, Betriebssystem-Aliase und die einfache Hilfe-Funktion. 

   1 ipython
   2 ...
   3 In [1]: run hello.py
   4 Hallo Welt

Standardeditor

In der Konfigurationsdatei kann der Editor geändert werden: 

   1 nedit .ipython/ipythonrc


   1 # Which editor to use with the %edit command. If you leave this at 0, IPython
   2 # will honor your EDITOR environment variable. Since this editor is invoked on
   3 # the fly by ipython and is meant for editing small code snippets, you may
   4 # want to use a small, lightweight editor here.
   5 
   6 # For Emacs users, setting up your Emacs server properly as described in the
   7 # manual is a good idea. An alternative is to use jed, a very light editor
   8 # with much of the feel of Emacs (though not as powerful for heavy-duty work).
   9 
  10 editor nedit

Was ist ein Programm?

Interpreter versus Compiler

Quellcode -> Interpreter -> Ergebnis

Quellcode -> Compiler -> Objectcode -> Ausführung -> Ergebnis

Programmablauf

Eingabe, Ausgabe, Algorithmus

Debugging/Fehlersuche

Syntaxfehler: Formale Struktur des Programms

Laufzeitfehler: Fehler und Ausnahmen, die während des Ablaufs auftreten

Semantische Fehler: Formal korrektes Programm, welches zu falschem Ergebnis führt

Debugging ist Detektivarbeit und eine eigene Wissenschaft für sich. Durch Experimente können Fehler gefunden werden. Es muss eine Idee (Hypothese) über die Fehlerquelle vorhanden sein, die durch den Programmablauf getestet wird. Verschiende Werkzeuge können das Debugging erleichern. Eine vielbenutzte einfache Methode ist die Print Anweisung um Variablen zu überwachen.

Variablen, Ausdrücke, Anweisungen, Operatoren, Kommentare

Werte und Typen

Werte (z.B. 1) sind verschiedenen Typen zugeordnet 

   1 In [32]: type(1)
   2 Out[32]: <type 'int'>
   3 
   4 In [33]: type(1.0)
   5 Out[33]: <type 'float'>
   6 
   7 In [34]: type('Hallo')
   8 Out[34]: <type 'str'>

Variablen

Variablen sind Namen, zu denen ein Wert gehört 

   1 In [51]: a=1
   2 In [52]: s='Zeichenkette'
   3 
   4 In [53]: a
   5 Out[53]: 1
   6 
   7 In [54]: s
   8 Out[54]: 'Zeichenkette'
   9 
  10 In [55]: type(a)
  11 Out[55]: <type 'int'>
  12 
  13 In [56]: type(s)
  14 Out[56]: <type 'str'>

Über den Zustand der Variablen kann man sich mit dem IPython Kommando %who bzw. %whos informieren. 

   1 In [57]: %whos
   2 Variable   Type    Data/Info
   3 ----------------------------
   4 a          int     1
   5 s          str     Zeichenkette

Erlaubte Namen

Variablennamen sollten sinnvoll vergeben werden. Die Länge ist unbegrenzt und es können Buchstaben und Zahlen verwendet werden. Am Anfang darf jedoch keine Zahl stehen. Als Sonderzeichen ist der Unterstrich erlaubt. Illegale Namen führen zu Syntaxfehlern: 

   1 In [59]: 5a=1
   2 ------------------------------------------------------------
   3    File "<ipython console>", line 1
   4      5a=1
   5       ^
   6 SyntaxError: invalid syntax

Python Keywords dürfen nicht als Variablennamen verwendet werden. Reservierte Keywords sind: 

   1 and                 else                import              raise
   2 assert              except              in                  return
   3 break               exec                is                  try
   4 class               finally             lambda              while
   5 continue            for                 not                 yield
   6 def                 from                or
   7 del                 global              pass
   8 elif                if                  print

Anweisung (Statements)

Eine Anweisung ist ein Befehl, den der Python Interpreter ausführen kann, z.B. eine Print-Anweisung oder Variablen-Zuweisung 

   1 In [60]: s='Welt'
   2 
   3 In [61]: print 'Hallo '+s
   4 Hallo Welt

Operaturen

Operatoren sind spezielle Symbole für Rechenanweisungen

Das Plus Zeichen kann im Zusammenhang mit Strings als Operator verwendet werden, um diese zu verbinden. 

   1 In [63]: a='Aller Anfang '
   2 
   3 In [64]: b='ist schwer'
   4 
   5 In [65]: a+b
   6 Out[65]: 'Aller Anfang ist schwer'

Ausdrücke (Expressions)

Ein Ausdruck ist eine Kombination von Variablen, Werten und Operatoren. Der Interpreter evaluiert den Ausruck. 

   1 In [62]: 1+1
   2 Out[62]: 2

Kommentare

Kommentare helfen ein Programm zu verstehen. Sie werden durch ein Doppelkreuz (#) eingeleitet

Funktionen

Eine Funktion ist eine Reihe von Anweisungen um eine Rechenoperation durchzuführen. Eine Funktion wird durch einen Namen spezifiziert (erlaubte Namen wie bei Variablen). Nach der Definition kann die Funktion durch den Namen aufgerufen werden. 

   1 In [9]: type(1)
   2 Out[9]: <type 'int'>

Dies ist ein Beispiel für eine eingebaute Funktion (Übersicht http://docs.python.org/lib/built-in-funcs.html).

Der Name der Funktion ist type. In Klammern wird der Funktion ein Argument (1) übergeben. Die Funktion liefert einen Rückgabewert (int) zurück.

Typumwandlungsfunktionen

   1 In [12]: int(2.3)
   2 Out[12]: 2
   3 
   4 In [13]: float(2)
   5 Out[13]: 2.0
   6 
   7 In [14]: 1/2
   8 Out[14]: 0
   9 
  10 In [15]: 1/float(2)
  11 Out[15]: 0.5
  12 
  13 In [16]: str(1)
  14 Out[16]: '1'

Hinzufügen neuer Funktionen

Das Hinzufügen neuer Funktionen geschieht durch eine Deklaration (Definition). Dabei ist die Python Symtax der Einrückungen wichtig. Die Einrückungen definieren den Gültigkeitsbereich der Funktion.

Quellcode einfache_funktion.py 

   1 def summe(a,b): 
   2     c=a+b 
   3     return c 
   4 
   5 a=1
   6 b=2
   7 print summe(a,b)


   1 In [17]: %edit einfache_funktion.py
   2 Editing... done. Executing edited code...
   3 3
   4 
   5 In [18]: run einfache_funktion.py
   6 3
   7 
   8 In [19]: summe(4,5)
   9 Out[19]: 9

Das Beispiel enthält nicht nur eine Funktion sondern auch ein Hauptprogramm, welches die Funktion aufruft. Nach dem Editieren wird dieser Teil sofort ausgeführt.

Dokumentation

Gute Dokumentation ist wichtig!

Funktionen können durch docstrings ergänzt werden 

   1 def summe(a,b):
   2     """Berechne die Summe aus a und b"""
   3     c=a+b
   4     return c
   5 
   6 a=1
   7 b=2
   8 print summe(a,b)

Ruft man nun die Hilfefunktion auf, dann bekommt man eine Auskunft über das Interface: 

   1 In [27]: help(summe)
   2 
   3 Help on function summe in module __main__:
   4 
   5 summe(a, b)
   6     Berechne die Summe aus a und b

Module

Module sind Sammlungen von Funktionen und erweitern den sehr minimalen Sprachumfang von Python um neue Funktionen.

Eine Liste der verfügbaren Module erhält man durch die Hilfe-Funktion: 

   1 In [3]: help()
   2 help> modules
   3 
   4 ArgImagePlugin      WalImageFile        ftplib              pygtk
   5 ArrayPrinter        WmfImagePlugin      gc                  pylab
   6 ..
   7 UserString          fpformat            pyexpat             zonetab2pot

Um ein Modul zu nutzen muss es zunächst importiert werden: 

   1 import scipy

Jetzt können die Funktionen des Moduls scipy genutzt werden. Mit scipy erhält Python mathematische Fähigkeiten ähnlich wie IDL und MATLAB. 

   1 In [9]: a=scipy.array([1,2,3,4,5])
   2 In [10]: b=scipy.array([1,2,3,4,5])
   3 In [11]: a+b
   4 Out[11]: array([ 2,  4,  6,  8, 10])

Es gibt verschiedene Möglichkeiten Module zu importieren. Davon hängt ab, in welchem Namensraum das Modul erreichbar ist 

   1 import scipy as sp


   1 In [9]: a=sp.array([1,2,3,4,5])
   2 In [10]: b=sp.array([1,2,3,4,5])
   3 In [11]: a+b
   4 Out[11]: array([ 2,  4,  6,  8, 10])

Durch die Möglichkeit das Modul in den Wurzelnamensraum zu importieren 

   1 from scipy import *

spart man sich einige Schreibarbeit 

   1 In [9]: a=array([1,2,3,4,5])
   2 In [10]: b=array([1,2,3,4,5])
   3 In [11]: a+b
   4 Out[11]: array([ 2,  4,  6,  8, 10])

jedoch besteht die Möglichkeit von Konflikten falls noch weitere Module mit Funktionen gleichen Namens importiert werden.

scipy

http://www.scipy.org/

Das Modul scipy beinhaltet eine Reihe von Submodulen für eine Vielzahl von wissenschaftlichen Anwendungen 

   1 import scipy
   2 help(scipy)
   3 
   4     ndimage          --- n-dimensional image package [*]
   5     stats            --- Statistical Functions [*]
   6     io               --- Data input and output [*]
   7     lib              --- Python wrappers to external libraries [*]
   8     linalg           --- Linear algebra routines [*]
   9     linsolve.umfpack --- Interface to the UMFPACK library. [*]
  10     signal           --- Signal Processing Tools [*]
  11     misc             --- Various utilities that don't have another home.
  12     interpolate      --- Interpolation Tools [*]
  13     lib.lapack       --- Wrappers to LAPACK library [*]
  14     cluster          --- Vector Quantization / Kmeans [*]
  15     linsolve         --- Linear Solvers [*]
  16     fftpack          --- Discrete Fourier Transform algorithms [*]
  17     sparse           --- Sparse matrix [*]
  18     maxentropy       --- Routines for fitting maximum entropy models [*]
  19     integrate        --- Integration routines [*]
  20     optimize         --- Optimization Tools [*]
  21     special          --- Special Functions [*]
  22     lib.blas         --- Wrappers to BLAS library [*]
  23       [*] - using a package requires explicit import (see pkgload)

Scipy baut auf dem Modul Numpy auf, welches optimierte Matrixoperationen bereitstellt.

Der Umstieg von IDL und MATLAB auf scipy/numpy fällt mit diesen Kurzanleitungen besonders leicht:

[http://37mm.no/mpy/idl-numpy.html NumPy for IDL users]

[http://www.scipy.org/NumPy_for_Matlab_Users NumPy for Matlab users]

pylab

http://matplotlib.sourceforge.net/

Pylab (matplotlib) reichert Python um die Fähigkeiten zur graphischen Ausgabe an, die im grossen Umfang mit Matlab kompatibel ist.

Um ein gutes interaktives Arbeiten mit diesem Modul zu ermöglichen, muss der Interpreter mit besonderer Option gestartet werden: ipython -pylab

GDAL

[http://www.gdal.org/ GDAL - Geospatial Data Abstraction Library]

Weiterführende Information

http://www.greenteapress.com/thinkpython/