Python Mini-HOWTO (V0.2 2004-05-10)

Der Python Interpreter kann interaktiv benutzt werden, so zum rumspielen und ausprobieren sehr praktisch:

~> python
Python 2.3.3 (#2, Jan  4 2004, 12:24:16) 
[GCC 3.3.3 20031229 (prerelease) (Debian)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> print "hallo"
hallo
>>> 

Beendet wird der Interpreter mit Control+D.

Datentypen / Variablen

Variablen werden einfach durch setzen bekannt gemacht und mit del wieder gelöscht. Ein Zugriff auf eine nicht existierende Variable ist ein Fehler.

>>> print a
Traceback (most recent call last):
  File "", line 1, in ?
NameError: name 'a' is not defined
>>> a = 3
>>> print a
3
>>> del a
>>> print a
Traceback (most recent call last):
  File "", line 1, in ?
NameError: name 'a' is not defined

Skalar

>>> x = 2

Strings

Strings koenen in Hochkomma oder Anführungszeichen geschrieben werden. Wie in C koennen Sonderzeichen wie \n oder \r verwendet werden:

>>> str1 = "hallo"
>>> str2 = 'welt'
>>> str1 + " " + str2
'hallo welt'
>>> print str1 + " " + str2
hallo welt
>>> str1 + "\n" + str2
'hallo\nwelt'
>>> print str1 + "\n" + str2
hallo
welt

Mehrzeilige Strings können auch mit dreifachen Anführungszeichen geschrieben werden:

>>> str = """hallo
... das ist ein 
... mehrzeiliger
... string"""
>>> str
'hallo\ndas ist ein\nmehrzeiliger\nstring' 

Substrings erhält man mit eckigen Klammern und Doppelpunkt:

>>> str1[2:4]
'll'
>>> str1[2:]
'llo'
>>> str1[:4]
'hall'
>>> str1[-2:]
'lo'

Wichtig: Strings sind nicht veraenderbar (im Gegnsatz zu Listen):

>>> str1[-2:] = ""
Traceback (most recent call last):
  File "", line 1, in ?
TypeError: object doesn't support slice assignment

Listen (engl. list)

Listen werden mit eckigen Klammern definiert:

>>> liste = [ "hallo", "welt" ]
>>> liste
['hallo', 'welt']
>>> liste[0]
'hallo'
>>> liste[1]
'welt'

Listen sind veränderbar (im Gegnsatz zu Strings):

>>> liste = liste + [ "wie", "geht", "es" ]
>>> liste
['hallo', 'welt', 'wie', 'geht', 'es']
>>> liste[1:2] = [ "mars" ]
>>> liste
['hallo', 'mars', 'wie', 'geht', 'es']
>>> liste[1:2] = []
>>> liste
['hallo', 'wie', 'geht', 'es']
>>> liste[1:1] = [ "welt" ]
>>> liste
['hallo', 'welt', 'wie', 'geht', 'es']

Verzeichnisse (engl. dictionary)

Ein Verzeichnis ist eine Liste von Schlüssel/Wert paaren und wird mit geschweiften Klammern definiert. Bedingung ist dass der Schlüssel nicht veränderbar ist.

>>> verz = { "banane" : "gelb", "apfel" : "rot", "birne" : "gruen" }
>>> verz
{'banane': 'gelb', 'birne': 'gruen', 'apfel': 'rot'}
>>> verz["apfel"]
'rot'
>>> verz["pflaume"] = "blau"
>>> verz
{'banane': 'gelb', 'pflaume': 'blau', 'birne': 'gruen', 'apfel': 'rot'}

Verzeichnisse verwenden Hashwerte, darum ist die Reihenfolge undefiniert

Tupel (engl. tuple)

Ein Tupel ist eine unveränderbare Liste und wird mit runden Klammern definiert:

>>> tupel = ( 3, "hallo" )
>>> tupel
(3, 'hallo')
>>>  tupel[0]
3
>>> tupel[1]
'hallo'

Kreieren eines Tupels mit nur einem Element sieht etwas hässlich aus, muss aber so sein um es von normaler Klammerung zu unterscheiden:

>>> tupel
('nix',)
>>> tupel = "nix",
>>> tupel
('nix',)

Länge von Strings, Listen, Verzeichnissen und Tupel

Mit der Funktion len() kann die Länge von Strings, Listen, Verzeichnissen und Tupel bestimmt werden:

>>> len( str2 )
4
>>> len( liste )
5
>>> len( verz )
4
>>> len( tupel )
2

Formatierung und Flusskontrolle

Formatierung

Zusammengehörige Statements müssen immer gleich weit eingerückt sein. Leerzeilen dazwischen sind erlaubt.
Normalerweise pro Zeile nur ein Ausdruck geschrieben ohne ein Semikolon am Ende, es können aber mehrere durch Semikolon getrennte Ausdrücke auf eine Zeile geschrieben werden.
Kommentare beginnen mit einem # und gehen bis zum Ende der Zeile.

Beispiel:

def fakultaet( n ):
   """berechnet fakultaet von n
   
   gibt 0 zurueck falls n kleiner oder gleich 0 ist.
   gibt 1 * 2 * 3 * .. * n zurueck falls n groesser 0 ist."""
   
   # f auf 0 initialisieren
   f = 0
   if n > 0:
     # n ist groesser 0 also muss f mindestens 1 sein
     f = 1
     # werte von 2 bis n mit f multiplizieren
     for i in range( 2, n+1 ):
       f = f * i
   return f

Der hier angegebene Dokumentations-String kann mit help angezeigt werden:

>>> help(fakultaet)

if, elif, else

if x > 5:
  print "x ist grösser als 5"
elif x < 5:
  print "x ist kleiner als 5"
else:
  print "x ist gleich 5"

for

liste = [ "hallo", "wie", "geht", "es" ]
for wort in liste:
  print wort

Wichtig: Falls die Liste in der for-Schlaufe verändert wird, sollte eine Kopie davon verwendet werden:

liste = [ "hallo", "wie", "geht", "es" ]
for wort in liste[:]:
  print wort

while

n = 0
while n < 5:
  n = n + 1

Funktionen

def funktion( x, y, z ):
  "optionaler Dokumentations-String"
  statement1
  statement2
  ...
  return x

Eingebaute Funktionen

Hilfe

Die Funktion help(x) zeigt eine Hilfe an. Dies geht bei den meisten Objekten. Bei einigen muss man aber die Klasse ausgewaehlt werden.

help( fakultaet )
str = "hallo"
help( str.__class__ )

String

>>> a = 22
>>> print "Die Variable %s hat den Wert %d" % ( "a", a )
Die Variable a hat den Wert 22
>>> print "Die Variable a hat den Wert %d" % a
Die Variable a hat den Wert 22

Listen

>>> map( fakultaet, [0, 1, 2, 3, 4, 5] )
[0, 1, 2, 6, 24, 120]

>>> def f(x): return x % 2 == 0
... 
>>> filter( f, range( 0, 10 ) )
[0, 2, 4, 6, 8]

Verzeichnisse

Klassen

Definition

Klassen werden folgendermassen definiert:

class MyClass:
  "beschreibung ..."

  # variablen...
  a = 22

  # funktionen
  def setzeA( self, x ):
    "setzt den Wert von a"
    self.a = x

Funktionen

Funktionen werden gleich definiert wie sonst auch, mit dem Unterschied, dass der erste Parameter das Objekt ist und normalerweise self benannt wird. Mit self wird auf Funktionen und Variablen des Objekts zugegriffen.

class MyClass1:
  a = 22

  def setzeAundGibAltesA( self, newA ):
    # lokale variable
    oldA = self.a
    # variable a des objektes setzen
    self.a = newA
    # altes a zurueckgeben
    return oldA

Konstruktoren

Klassen können nur einen Konstruktor haben. Der Name des Konstruktors ist immer __init__.

class MyClass2:
  def __init__( self, a ):
    # setze wert fuer variable a
    self.a = a

Variablen

Variablen können fest vordefiniert werden, sie können aber auch jederzeit zugefügt und gelöscht werden.

class MyClass3:
  def createA( self, a ):
    self.a = a
  def removeA( self ):
    del self.a

Verwendung

oa = MyClass3()
ob = MyClass2( 33 )
oa.createA( 44 )
print oa.a