Python unter Linux: Überblick

In diesem Kapitel geben wir einen Überblick über Module, die meistens mitinstalliert werden. Anschließend wird eine Methode gezeigt, mit der man selbst mehr über unbekannte (aber auch vermeintlich bekannte) Module herausfinden kann.

Modul cmath

Dieses Modul beinhaltet mathematische Funktionen zur Arbeit mit komplexen Zahlen. In Python haben komplexe Zahlen einen eigenen Typ, complex. Aufgeschrieben werden sie zum Beispiel als 5+3j.

Ein Beispiel:

#!/usr/bin/python import cmath z=5+4j print z print cmath.sqrt(z) 

Ausgabe

user@localhost:~$ ./datei3.py
(5+4j)
(2.38779440462+0.837593050781j)

Modul datetime

Das Modul datetime ist für die Verwaltung von Datum und Zeit zuständig. Dazu werden die Klassen time, date, datetime (Zusammenfassung von time und date) sowie timedelta (Zeitdifferenzen) und tzinfo (Zeitzoneninformationen) definiert. Die Verwendung von date wird in folgendem Programm demonstriert:

#!/usr/bin/python from datetime import date t=date(2008, 4, 10) print "Datum allgemein: " + str(t) print "Datum auf Deutsch: " + str(t.day) + "." + str(t.month) + "." + str(t.year) 

Ausgabe

user@localhost:~$ ./date.py
Datum allgemein: 2008-04-10
Datum auf Deutsch: 10.4.2008

Hier folgt eine kurze Übersicht über einige der vorhandenen Methoden:

Date-Funktionen	Bedeutung
fromtimestamp(timestamp)	Liefert das Datum passend zum Unix-Zeitstempel. Zeitstempel kann man von time.time() (Modul time) geliefert bekommen.
today()	Liefert das heutige Datum
year, month, day	(Klassenattribute) Repräsentieren das Jahr, den Monat und den Tag

Time-Funktionen	Bedeutung
hour, minute, second, microsecond	(Klassenattribute) Repräsentieren Stunde, Minute, Sekunde und Mikrosekunde
isoformat()	Liefert die Zeit im ISO8601-Format: HH:MM:SS.microsekunden
strftime(format)	Liefert die Zeit unter Verwendung von Formatangaben. Beispiele: %f: Mikrosekunden %H: Stunden im 24-Stunden-Format %M: Minuten %S: Sekunden

Modul getopt

Funktionen innerhalb von getopt behandeln das Thema Kommandozeilenargumente:

Funktion	Bedeutung
getopt(Argumente, kurzeOptionen, langeOptionen)	Liest Kommandozeilenoptionen, wie sie in Argumente übergeben wurden und vergleicht sie mit kurzeOptionen (-f, -h, ...) und langeOptionen (--file, --help, ...). Es werden zwei Listen zurückgegeben, eine enthält alle empfangenen Optionen einschließlich der Argumente, die andere Liste enthält alle Kommandozeilenargumente, denen keine Option vorangestellt wurde.
gnu_getopt(Argumente, kurzeOptionen, langeOptionen)	Wie oben, jedoch dürfen Options- und nicht-Optionsargumente gemischt werden.

langeOptionen ist optional und enthält eine Liste mit Strings, die als lange Optionen interpretiert werden. Ein nachgestelltes Gleichheitszeichen bewirkt, dass diese Option ein Argument erwartet. kurzeOptionen ist ein String, der die Buchstaben zu den passenden Optionen beinhaltet. Ein einem Buchstaben nachgestellter Doppelpunkt bewirkt, dass diese Option ein Argument erwartet. Kommandozeilenparameter werden typischerweise von der Variablen sys.argv bereitgestellt, wobei sys.argv[0] der Skriptname ist. Beispiel:

#!/usr/bin/python import getopt import sys print "Alle Argumente: ", sys.argv shortOptions = 'hf:' longOptions = ['help', 'filename=', 'output='] def usage(): print sys.argv[0], "--help --filename=meinedatei [--output=ausgabedatei] ..." print sys.argv[0], "-h -f meinedatei ..." opts = [] args = [] try: opts, args = getopt.getopt(sys.argv[1:], shortOptions, longOptions) except getopt.GetoptError: print "ERR: Mindestens eine der Optionen ist nicht verfuegbar" usage() sys.exit() print "Optionenargumente:", opts print "Nicht-Optionen-Argumente:", args for o, a in opts: if o == "--help" or o == "-h": print "HELP" usage() elif o == "--filename" or o == "-f": print "Filename, Bearbeite Datei:", a elif o == "--output": print "Output, Dateiname:", a for a in args: print "Weiteres Argument, keine Option: ", a 

Ausgabe

user@localhost:~$ ./getopt1.py --output test --filename test1 -f test2 test3
Alle Argumente: ['./getopt1.py', '--output', 'test', '--filename', 'test1', '-f', 'test2', 'test3']
Optionenargumente: [('--output', 'test'), ('--filename', 'test1'), ('-f', 'test2')]
Nicht-Optionen-Argumente: ['test3']
Output, Dateiname: test
Filename, Bearbeite Datei: test1
Filename, Bearbeite Datei: test2
Weiteres Argument, keine Option: test3

Falls eine Option eingegeben wurde, die nicht Bestandteil der kurzen oder Langen Optionsliste ist, dann wird die Exception getopt.GetoptError geworfen. Die Optionen -f, --filename und --output erwarten weitere Argumente.

Modul math

Das Modul math enthält mathematische Funktionen und Konstanten. Die folgende Tabelle zeigt einen Auschnitt:

Funktion	Bedeutung
e	Der Wert der Eulerkonstante 2.718...
pi	Der Wert der Kreiszahl pi 3.14...
sin(), cos()	Sinus, Kosinus eines Winkels im Bogenmaß
degrees()	Rechnet einen Winkel vom Bogenmaß in Grad um
radians()	Umrechnung Grad -> Bogenmaß
log(), exp()	Logarithmus, Exponentialfunktion

Ein Beispiel:

#!/usr/bin/python import math print math.e print math.sin(math.pi/2) 

Ausgabe

user@localhost:~$ ./math.py
2.71828182846
1.0

Modul os

Dieses Modul beinhaltet Variablen und Funktionen, die stark vom eingesetzten Betriebssystem (Linux, Mac, OpenBSD, ...) abhängen.

Beispiel:

#!/usr/bin/python import os print "Arbeite unter " + os.name print "Dieses Programm ist unter " + os.curdir + os.sep + "ostest" + os.extsep + "py" + " zu erreichen" 

Ausgabe

user@localhost:~$ ./ostest.py
Arbeite unter posix
Dieses Programm ist unter ./ostest.py zu erreichen

Anmerkung: Dieses Programm gibt unter verschiedenen Betriebssystemen unterschiedliche Ergebnisse aus.

Hier folgen einige nützliche Funktionen aus dem Modul:

Dateien und Verzeichnisse

Funktion	Bedeutung
chdir(pfad)	Wechselt in das angegebene Verzeichnis
chmod(pfad, modus)	Ändert die Modi (Lesen, Schreiben, Ausführen) der Datei mit dem Dateinamen pfad.
chown(pfad, uid, gid)	Ändert die Besitzrechte der Datei mit dem Namen pfad auf die der angegebenen UID und GID
close()	Datei wird geschlossen
curdir, pardir	(Konstanten) Kürzel für das aktuelle Verzeichnis (meist ".") oder das übergeordnete Verzeichnis ("..")
getcwd()	Liefert das aktuelle Arbeitsverzeichnis
listdir(pfad)	Erzeugt eine Liste mit dem Inhalt des angegebenen Verzeichnisses pfad.
lseek(fd, pos, how)	Positioniert den Dateizeiger der geöffneten Datei fd an die Position pos. how bestimmt, wie positioniert wird: SEEK_SET: relativ zum Anfang der Datei (voreingestellt) SEEK_CUR: relativ zur aktuellen Position SEEK_END: relativ zum Ende der Datei
name	(Konstanten) Kennung für das Betriebssystem (posix, os2, riscos, ...)
open(file, flags[, mode])	file: Dateiname, flags: Modi der Art O_RDONLY: nur Lesen O_WRONLY: nur schreiben O_RDWR: lesen und schreiben O_APPEND: anhängen O_CREAT: Datei wird erzeugt O_EXCL: Datei wird erzeugt, wenn es sie noch nicht gibt. Falls es die Datei gibt, liefert open() einen Fehler. O_TRUNC: Datei wird geleert Diese Flags können verodert werden. mode: Dateirechte, wie z. B. "0660"
read(fd, n)	Liest n Zeichen aus der offenen Datei fd.
remove(pfad), rmdir(pfad)	Entfernt eine Datei oder ein Verzeichnis (rekursiv).
write(fd, s)	Schreibt einen String s in die offene Datei fd.
sep, extsep	(Konstanten) Trennzeichen für Pfadnamen ("/") und Dateiendungen (".")
tmpfile()	Öffnet eine temporäre Datei im Modus "w+"

Prozessmanagement

Funktion	Bedeutung
fork()	Erzeugt einen Kindprozess. Liefert 0, wenn dieses der Kindprozess ist, sonst die Prozessnummer (PID) des Kindes.
kill(pid, signal)	Sendet das Signal signal an den Prozess mit der angegebenen pid.
nice(wert)	Fügt dem aktuellen Prozess den Nicewert wert hinzu.
system(befehl)	Führt einen externen Befehl aus.

Modul os.path

Dieses Modul enthält Funktionen, die Auskunft über Dateien geben. Man kann Änderung- und Zugriffszeiten abfragen, feststellen, ob ein Pfad eine (existierende) Datei oder ein Verzeichnis ist und vieles mehr.

Funktion	Bedeutung
exists(Pfad)	Liefert True, wenn Pfad existiert und das Programm das Recht hat, diesen Pfad einzusehen.
expanduser(~username)	Erzeugt einen Pfad, der das Home-Verzeichnis von Benutzer username ist.
getatime(Pfad), getmtime(Pfad)	Liefert die letzte Zugriffszeit oder die Änderungszeit
isfile(Pfad)	True, wenn der Pfad eine Datei darstellt
join(Pfad1, Pfad2, ...)	Fügt Pfade zusammen, wobei Pfad1 ein Verzeichnis sein kann, Pfad2 ein Verzeichnis innerhalb von Pfad1 oder eine Datei.

Modul random

Das Modul random stellt Funktionen zur Verfügung für die Erzeugung von Pseudozufallszahlen. Ein kleines Beispiel würfelt eine Zahl zwischen 1 und 6:

#!/usr/bin/python from random import randint # (Pseudo-)Zufallszahl ermitteln und als Wuerfelergebnis nehmen.  def print_random(): wuerfel = randint(1, 6) print "Der Wurf ergibt " + str(wuerfel) # 5mal wuerfeln for i in range(0, 5): print_random() 

Ausgabe

user@localhost:~$ ./wuerfeln.py
Der Wurf ergibt 2
Der Wurf ergibt 6
Der Wurf ergibt 5
Der Wurf ergibt 6
Der Wurf ergibt 2

Anmerkung: Dieses Programm gibt jedes mal andere Ergebnisse aus.

Modul readline

Mit dem Modul readline kann eine Autovervollständigung im Stil der Bash in die Texteingabe eingebaut werden. Mit einer geeigneten Funktion zur Vervollständigung angefangener Wörter braucht man nur noch die Tabulatortaste drücken, um bereits eindeutige Eingaben zu vervollständigen.

Modul sys

Hier folgt eine Auswahl interessanter Funktionen und Variablen innerhalb vom Modul sys.

Funktion	Bedeutung
argv	Liste von Kommandozeilen, die dem Skript mitgegeben wurden
exit(Arg)	Der optionale Wert Arg wird ausgegeben, oder, wenn es eine Zahl ist, an den aufrufenden Prozess (zum Beispiel die bash) übergeben.
exitfunc	Diese Variable enthält den Wert einer Funktion, die als letzte vor dem Programmende aufgerufen wird.
path	Liste aller Modulsuchpfade
platform	Ein String, der die Plattform, also das Betriebssystem, identifiziert.
stdin	Eingabekanal (Datei)
version	Die aktuelle Python-Version

Ein Beispielprogramm, wie man mit exit() und exitfunc umgeht:

#!/usr/bin/python import sys def LetzteWorte(): print "Das Gold befindet sich am ..." exitfunc = LetzteWorte() sys.exit(42) 

Ausgabe

user@localhost:~$ ./sys1.py
Das Gold befindet sich am ...

Leider verstarb das Programm, bevor es uns den Ort nennen konnte, wo das Gold liegt. Wir können den Rückgabewert des Skriptes in der bash bestimmen, in dem wir die Shell-Variable $? abfragen:

Ausgabe

user@localhost:~$ echo $?
42

Das folgende Programm benutzt stdin, um einen Filter zu bauen. Mit dessen Hilfe können wir die Ausgabe eines Programmes als Eingabe unseres Programmes benutzen, um zum Beispiel Dateien mit Zeilennummern zu versehen:

#!/usr/bin/python import sys for n, l in enumerate(sys.stdin): print "%d: %s" % (n, l[:-1]) 

Ausgabe

user@localhost:~$ ./sys2.py < sys2.py
0: #!/usr/bin/python
1: import sys
2:
3: for n, l in enumerate(sys.stdin):
4:     print "%d: %s" % (n, l[:-1])

Alternativ hätten wir das Programm auch mit cat sys2.py | ./sys2.py aufrufen können.

Modul tarfile

Das Modul tarfile ermöglicht die Behandlung von \.tar(\.gz|\.bz2)?-Dateien unter Python. Ein Beispiel:

#!/usr/bin/python from sys import argv import tarfile filename=argv[0] tarname=filename+".tar.gz" tar=tarfile.open(tarname, "w:gz") tar.add(filename) tar.close() file=open(filename) file.seek(0, 2) tar=open(tarname) tar.seek(0, 2) print "Original: " + str(file.tell()) + " Bytes" print "Compressed: " + str(tar.tell()) + " Bytes" # Noch ein paar Kommentare, damit die Datei gross genug ist. :-) # Bei zu kleinen Dateien wirkt sich die Kompression negativ aus. 

Ausgabe

user@localhost:~$ ./tar.py
Original: 464 Bytes
Compressed: 403 Bytes

Modul time

Das Modul time stellt Funktionen für das Rechnen mit Zeit zur Verfügung. Es sollte nicht mit der Klasse time im Modul datetime verwechselt werden. Ein Beispielprogramm:

#!/usr/bin/python from time import clock, strftime def do_loop(limit): start_time=clock() for i in range(1,limit): for j in range(1,limit): pass end_time=clock() return end_time - start_time def calibrate(): limit=1 elapsed=0.0 while (elapsed<1.0): limit=limit*2 elapsed=do_loop(limit) return limit print 'Kalibriere Zeitrechnung...' limit = calibrate() print 'Rechne (' + str(limit) + ')^2 Schleifen...' print 'Vorher: ' + strftime('%X') elapsed=do_loop(limit) print 'Nachher: ' + strftime('%X') print "Gemessene Zeit: " + str(elapsed) + "s" 

Ausgabe

user@localhost:~$ ./timing.py
Kalibriere Zeitrechnung...
Rechne (4096)^2 Schleifen...
Vorher: 17:14:57
Nachher: 17:14:58
Gemessene Zeit: 1.16s

Modul uu

Das folgende Programm kodiert und dekodiert sich selbst:

#!/usr/bin/python from sys import argv from uu import encode, decode infile=argv[0] tmpfile=infile+".uu" outfile=tmpfile+".py" encode(infile, tmpfile) decode(tmpfile, outfile) file=open(outfile) data=file.read() lines=data.splitlines() for line in lines: print line 

Die Ausgabe soll hier nicht extra aufgeführt werden, da sie identisch mit dem Programmcode ist. Für die Interessierten hier die dabei erzeugte Datei uudemo.py.uu:

begin 755 uudemo.py M(R$O=7-R+V)I;B]P>71H;VX*9G)O;2!S>7,@:6UP;W)T(&%R9W8*9G)O;2!U M=2!I;7!O<G0@96YC;V1E+"!D96-O9&4*"FEN9FEL93UA<F=V6S!="G1M<&9I M;&4]:6YF:6QE*R(N=74B"F]U=&9I;&4]=&UP9FEL92LB+G!Y(@H*96YC;V1E M*&EN9FEL92P@=&UP9FEL92D*9&5C;V1E*'1M<&9I;&4L(&]U=&9I;&4I"@IF M:6QE/6]P96XH;W5T9FEL92D*9&%T83UF:6QE+G)E860H*0IL:6YE<SUD871A M+G-P;&ET;&EN97,H*0IF;W(@;&EN92!I;B!L:6YE<SH*(" @("!P<FEN="!L $:6YE"@ end 

Allgemeine Informationen über Module

Das folgende Skript zeigt, wie man mehr über ein Modul herausfindet, von dem man nur den Namen kennt.

#!/usr/bin/python import os help(os) print dir(os) 

Die Funktionen help() und dir() geben nützliche Informationen über die Module aus. Es ist recht praktisch, sie im interaktiven Modus (siehe Kapitel Erste Schritte) einzugeben.

---