Python unter Linux: Überblick

Aus Wikibooks

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[Bearbeiten]

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[1].

Ein Beispiel:

#!/usr/bin/python

import cmath

z=5+4j
print z
print cmath.sqrt(z)
Align=none Ausgabe

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

Modul datetime[Bearbeiten]

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)
Align=none 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[Bearbeiten]

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
Align=none 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[Bearbeiten]

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)
Align=none Ausgabe

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

Modul os[Bearbeiten]

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"
Align=none 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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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()
Align=none 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[Bearbeiten]

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[Bearbeiten]

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)


Align=none 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:

Align=none 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])
Align=none 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[Bearbeiten]

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.
Align=none Ausgabe

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

Modul time[Bearbeiten]

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"
Align=none 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[Bearbeiten]

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[Bearbeiten]

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.

Anmerkungen[Bearbeiten]

  1. In der deutschsprachigen Literatur zu komplexen Zahlen ist das "i" häufig anzutreffen.