Programmieren in Python - Albert-Ludwigs

Programmieren in Python
8. Funktionen, Ausnahmen und Module
Malte Helmert
Albert-Ludwigs-Universität Freiburg
KI-Praktikum, Sommersemester 2009
Malte Helmert
Programmieren in Python
Funktionen, Ausnahmen und Module
In dieser Lektion vertiefen wir das Thema Funktionsdefinitionen
und behandeln mit der Fehlerbehandlung und dem Erstellen und
Verwenden von Modulen zwei weitere essentielle Themen.
Im Überblick:
I
Mehr zu Funktionen
I
Ausnahmen
I
Module
Malte Helmert
Programmieren in Python
Funktionen, Ausnahmen und Module
In dieser Lektion vertiefen wir das Thema Funktionsdefinitionen
und behandeln mit der Fehlerbehandlung und dem Erstellen und
Verwenden von Modulen zwei weitere essentielle Themen.
Im Überblick:
I
Mehr zu Funktionen
I
Ausnahmen
I
Module
Malte Helmert
Programmieren in Python
Mehr zu Funktionen
I
Wir haben mittlerweile viele Funktionen gesehen, die eine
variable Argumentzahl akzeptieren. Solche Funktionen können
wir noch nicht selbst schreiben.
I
Noch viel weniger können wir Funktionen wie den
eigentümlichen dict-Konstruktor selbst schreiben, der
Aufrufe wie dict(spam=10, bar=20) zulässt.
I
Das macht uns neidisch.
I
Daher werden solche Funktionsdefinitionen jetzt erklärt.
I
Außerdem sprechen wir über lokale und globale Variablen.
Malte Helmert
Programmieren in Python
Lokale und globale Variablen
I
Python unterscheidet zwischen lokalen Variablen, die nur in
der aktuellen Funktion gültig sind, und globalen Variablen, die
in der ganzen Datei (im ganzen Modul) gültig sind.
I
Da Python ja Variablen nicht deklariert, fragen wir uns: Wie
wird zwischen lokalen und globalen Variablen unterschieden?
I
Variablen außerhalb von Funktionen sind global (klar).
I
Variablen innerhalb von Funktionen sind lokal, wenn ihnen
innerhalb der Funktion ein Wert zugewiesen wird, und
ansonsten global.
I
Will man globalen Variablen innerhalb einer Funktion einen
neuen Wert zuweisen, markiert man die Variable mit der
Anweisung global var1, var2, ... (innerhalb der
Funktion!) als global.
Malte Helmert
Programmieren in Python
Lokale und globale Variablen: Beispiel
locals and globals.py
debug = False
def set_debug():
global debug
debug = True
def compute_sum(x, y):
if debug:
print "Computing sum of %s and %s" % (x, y)
return x + y
print compute_sum(10, 20)
set_debug()
print compute_sum(20, 10)
Malte Helmert
Programmieren in Python
Die Funktion globals (1)
I
I
I
Python besitzt umfangreiche Möglichkeiten zur Introspektion
(das, was man in Java als Reflection“ bezeichnet).
”
Ein (einfaches) Beispiel dafür sind die Builtins globals und
locals.
globals():
Liefert ein Dictionary, dessen Schlüssel und Werte die Namen
und Inhalte der globalen Variablen im Modul (d.h. in dieser
Datei) sind.
I
I
Das Dictionary kann mit den üblichen Methoden modifiziert
werden. Solche Änderungen haben denselben Effekt wie
tatsächliche Zuweisungen an globale Variablen.
Auf diese Weise können sogar Variablen mit ansonsten
unzulässigen Namen wie "10Mark50" oder "@!$%" erzeugt
werden, auch wenn dies nicht sonderlich nützlich ist.
Malte Helmert
Programmieren in Python
Die Funktion globals (2)
modify globals.py
globals()["egg"] = 2
print egg
spam = 0
mydict = globals()
mydict["spam"] = 10
print spam
y = 0
del mydict["y"]
print y
I
# Ausgabe: 2
# Ausgabe: 10
# NameError: ’y’ is not defined
Nebenbei bemerkt:
Um wie im Beispiel die globale Variable var zu entfernen,
kann man auch einfach die Anweisung del var verwenden.
Malte Helmert
Programmieren in Python
Die Funktion locals
locals():
I
Außerhalb von Funktionen aufgerufen:
Identisch mit globals().
I
Innerhalb einer Funktion aufgerufen:
Liefert analog zu globals() ein Dictionary mit Namen und
Werten der lokalen Variablen.
Allerdings ist dies nur eine Kopie des internen“ Dictionaries,
”
so dass es nicht möglich ist, mithilfe von locals() lokale
Variablen neu einzuführen, zu löschen oder neu zu binden.
Malte Helmert
Programmieren in Python
locals und globals: Beispiel
vars.py
def f(bo, moe):
print locals()
jim = "egg"
locals()["jim"]
print jim
del moe
print locals()
print globals()
# {’bo’: ’parrot’, ’moe’: ’fjord’}
= 111
# egg
# {’jim’: ’egg’, ’bo’: ’parrot’}
# {’f’: <function f at 0x402f0844>,
# ’bo’: ’ham’, ’joe’: ’spam’, ...}
bo = "ham"
joe = "spam"
f("parrot", "fjord")
Malte Helmert
Programmieren in Python
Erweiterte Argumentlisten: Einführung
I
Funktionen wie min und max akzeptieren eine variable Anzahl
an Argumenten.
I
Funktionen wie der dict-Konstruktor oder die sort-Methode
von Listen akzeptieren sogenannte benannte Argumente.
I
Beides können wir auch in selbst definierten Funktionen
verwenden.
I
Bevor wir dazu kommen, wollen wir erst einmal beschreiben,
was benannte Argumente sind.
Malte Helmert
Programmieren in Python
Benannte Argumente (1)
I
Betrachten wir folgende Funktion:
def power(base, exponent):
return base ** exponent
I
Bisher haben wir solche Funktionen immer so aufgerufen:
print power(2, 10)
# 1024.
I
Tatsächlich geht es aber auch anders:
print power(base=2, exponent=10)
print power(2, exponent=10)
print power(exponent=10, base=2)
Malte Helmert
Programmieren in Python
# 1024.
# 1024.
# 1024.
Benannte Argumente (2)
I
Zusätzlich zu normalen“ (sog. positionalen) Argumenten
”
können beim Funktionsaufruf auch benannte Argumente mit
der Notation var=wert übergeben werden.
I
var muss dabei der Name eines Parameters der aufgerufenen
Funktion sein:
Python-Interpreter
>>> def power(base, exponent):
...
return base ** exponent
...
>>> print power(x=2, y=10)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: power() got an unexpected keyword argument
’x’
Malte Helmert
Programmieren in Python
Benannte Argumente (3)
I
Benannte Argumente müssen am Ende der Argumentliste
(also nach positionalen Argumenten) stehen:
Python-Interpreter
>>> def power(base, exponent):
...
return base ** exponent
...
>>> print power(base=2, 10)
SyntaxError: non-keyword arg after keyword arg
Malte Helmert
Programmieren in Python
Benannte Argumente (4)
I
Ansonsten dürfen benannte Argumente beliebig verwendet
werden.
I
Insbesondere ist ihre Reihenfolge vollkommen beliebig.
I
Konvention:
Während man bei Zuweisungen allgemein Leerzeichen vor und
nach das Gleichheitszeichen setzt, tut man dies bei benannten
Argumenten nicht — auch um deutlich zu machen, dass hier
keine Zuweisung im normalen Sinne stattfindet, sondern nur
eine ähnliche Syntax benutzt wird.
Malte Helmert
Programmieren in Python
Default-Argumente
I
Besonders interessant sind benannte Argumente in
Zusammenhang mit Default-Argumenten, die wir jetzt
kennenlernen werden:
def power(base, exponent=2, debug=False):
if debug:
print base, exponent
return base ** exponent
I
Default-Argumente können beim Aufruf weggelassen werden
und bekommen dann einen bestimmten Wert zugewiesen.
I
Zusammen mit benannten Argumenten können wir schreiben:
print power(10)
# 100.
print power(10, 3, False)
# 1000.
print power(10, debug=True)
# 10 2; 1000.
print power(debug=True, base=4)
# 4 2; 16.
Malte Helmert
Programmieren in Python
Achtung bei veränderlichen Default-Argumenten (1)
I
Veränderliche Default-Argumente werden nur einmal
ausgewertet (zum Zeitpunkt der Funktionsdefinition), nicht
bei jedem Aufruf.
I
Mutiert man daher ein Default-Argument, hat das
Auswirkungen auf spätere Funktionsaufrufe:
mutable default arg.py
def test(spam, egg=[]):
egg.append(spam)
print egg
test("parrot")
test("fjord")
# Ausgabe: [’parrot’]
# Ausgabe: [’parrot’, ’fjord’]
Malte Helmert
Programmieren in Python
Achtung bei veränderlichen Default-Argumenten (2)
I
Aus diesem Grund sollte man in der Regel keine
veränderlichen Default-Argumente verwenden.
Das übliche Idiom ist das Folgende:
mutable default arg corrected.py
def test(spam, egg=None):
if egg is None:
egg = []
egg.append(spam)
print egg
test("parrot")
test("fjord")
I
# Ausgabe: [’parrot’]
# Ausgabe: [’fjord’]
Manchmal sind veränderliche Default-Argumente allerdings
gewollt, etwa zur Implementation von memoization.
Malte Helmert
Programmieren in Python
Variable Argumentlisten
I
I
I
Das letzte fehlende Puzzlestück sind variable Argumentlisten.
Mit diesen kann man Funktionen definieren, die beliebig viele
positionale Argumente, beliebig viele benannte Argumente,
oder beides unterstützen.
Die Idee ist ganz einfach: Alle überzähligen“ positionalen
”
Parameter werden in ein Tupel, alle überzähligen benannten
Argumente in ein Dictionary gepackt.
Notation:
I
I
I
def f(x, xy, *spam):
f benötigt mindestens zwei Argumente. Weitere positionale
Argumente werden im Tupel spam übergeben.
def f(x, **egg):
f benötigt mindestens ein Argument. Weitere benannte
Argumente werden im Dictionary egg übergeben.
Gesternte“ Parameter müssen am Ende der Argumentliste
”
stehen. Werden beide verwendet, dann in der Reihenfolge
*spam vor **egg.
Malte Helmert
Programmieren in Python
Variable Argumentlisten: Beispiel (1)
varargs.py
def v(spam, *argtuple, **argdict):
print spam, argtuple, argdict
v(0)
v(1, 2, 3)
v(1, ham=10)
v(ham=1, jam=2, spam=3)
v(1, 2, ham=3, jam=4)
#
#
#
#
#
Malte Helmert
0
1
1
3
1
() {}
(2, 3) {}
() {’ham’: 10}
() {’jam’: 2, ’ham’: 1}
(2,) {’jam’: 4, ’ham’: 3}
Programmieren in Python
Variable Argumentlisten: Beispiel (2)
vararg examples.py
def product(*numbers):
result = 1
for num in numbers:
result *= num
return result
def make_pairs(**argdict):
return argdict.items()
print product(5, 6, 7)
# Ausgabe: 210
print make_pairs(spam="nice", egg="ok")
# Ausgabe: [(’egg’, ’ok’), (’spam’, ’nice’)]
Malte Helmert
Programmieren in Python
list.sort und sorted (1)
Zur sort-Methode der Klasse list und dem Builtin sorted
mussten wir früher sagen, dass wir einige Optionen noch nicht
erklären konnten. Jetzt können wir es:
I
l.sort(cmp=None, key=None, reverse=False):
Sortiert die Liste.
Die optionalen Argumente haben folgende Bedeutung:
I
cmp muss entweder None oder eine Funktion sein, die zwei
Argumente akzeptiert und immer -1, 0 oder +1 zurückliefert.
In letzterem Fall wird cmp(x, y) wie folgt zur Anordnung der
Elemente verwendet:
I
I
I
I
I
x ≺ y, falls cmp(x, y) == -1.
x ∼ y, falls cmp(x, y) == 0.
x y, falls cmp(x, y) == +1.
key sollte entweder None oder eine Funktion sein, die ein
einzelnes Argument akzeptiert. In letzterem Fall werden zum
Anordnen der Elemente x und y nicht die Elemente selbst,
sondern key(x) und key(y) verglichen.
Wenn reverse wahr ist, dann wird absteigend sortiert.
Malte Helmert
Programmieren in Python
list.sort und sorted (2)
I
sorted(seq, cmp=None, key=None, reverse=False):
Erstellt eine Liste aus seq, sortiert diese und liefert sie zurück.
Die Argumente cmp, key und reverse haben dieselbe
Bedeutung wie bei list.sort.
Anmerkungen:
I
Die key-Funktion wird für jedes Listenelement nur einmal
aufgerufen, nicht bei jedem Vergleich erneut.
I
Im Normalfall ist die Verwendung von key einfacher und
effizienter als die Verwendung von cmp.
I
cmp und key werden praktisch nie zusammen verwendet.
Malte Helmert
Programmieren in Python
Sortieren mit key: Beispiel
sort example.py
food = ["Spam", "egg", "Ham", "spam", "baked beans"]
print sorted(food)
# [’Ham’, ’Spam’, ’baked beans’, ’egg’, ’spam’]
def lower(astring):
return astring.lower()
print sorted(food, key=lower)
# [’baked beans’, ’egg’, ’Ham’, ’Spam’, ’spam’]
mynumbers = [10, 2.4, -20, 100, 5j, -7]
mynumbers.sort(key=abs, reverse=True)
print mynumbers
# [100, -20, 10, -7, 5j, 2.3999999999999999]
Malte Helmert
Programmieren in Python
Erweiterte Aufrufsyntax
I
Die Notationen *argtuple und **argdict können nicht nur
in Funktionsdefinitionen verwendet werden, sondern auch in
Funktionsaufrufen.
I
Dabei bedeutet beispielsweise
f(1, x=2, *argtuple, **argdict),
dass als positionale Parameter eine 1 gefolgt von den
Elementen aus argtuple und als benannte Parameter x=2
sowie die Paare aus argdict übergeben werden.
I
Man nennt dies die erweiterte Aufrufsyntax.
Malte Helmert
Programmieren in Python
Erweiterte Aufrufsyntax: Beispiel
I
Eine nützliche Anwendung der erweiterten Aufrufsyntax
besteht darin, die eigenen Argumente an eine andere Funktion
weiterzureichen, ohne deren genaue Signatur zu kennen.
Beispiel:
def my_function(*argtuple, **argdict):
print "Arguments for other_function:",
print argtuple, argdict
result = other_function(*argtuple, **argdict)
print "other_function returns:", result
return result
I
In etwas verfeinerter Form wird diese Idee häufig bei
sogenannten Dekoratoren verwendet, die wir hier aus
Zeitgründen aber nicht diskutieren wollen.
Malte Helmert
Programmieren in Python
Funktionen, Ausnahmen und Module
In dieser Lektion vertiefen wir das Thema Funktionsdefinitionen
und behandeln mit der Fehlerbehandlung und dem Erstellen und
Verwenden von Modulen zwei weitere essentielle Themen.
Im Überblick:
I
Mehr zu Funktionen
I
Ausnahmen
I
Module
Malte Helmert
Programmieren in Python
Ausnahmen (1)
I
In vielen unserer Beispiele sind uns Tracebacks wie der
folgende begegnet:
Python-Interpreter
>>> print {"spam": "egg"}["parrot"]
Traceback (most recent call last):
File "<stdin>", line 1, in ?
KeyError: ’parrot’
I
Bisher konnten wir solchen Fehlern weder abfangen noch
selbst entsprechende Fehler melden. Das wollen wir jetzt
ändern.
Malte Helmert
Programmieren in Python
Ausnahmen (2)
I
Ebenso wie Java und C++ kennt Python das Konzept der
Ausnahmebehandlung (exception handling).
I
Wird eine Funktion mit einer Situation konfrontiert, mit der
sie nichts anfangen kann, kann sie eine Ausnahme
signalisieren.
I
Die Funktion wird dann beendet und es wird solange zur
jeweils aufrufenden Funktion zurückgekehrt, bis sich eine
Funktion findet, die mit der Ausnahmesituation umgehen
kann.
I
Zur Ausnahmebehandlung dienen in Python die Anweisungen
raise, try, except, finally und else.
Malte Helmert
Programmieren in Python
Die raise-Anweisung
I
Mit der raise-Anweisung kann eine Ausnahme signalisiert
werden (entsprechend throw in Java und C++).
I
Dazu verwendet man raise zusammen mit einer Instanz einer
speziellen Ausnahmeklasse (beispielsweise IndexError oder
NameError). Üblicherweise erzeugt man die Ausnahme in
derselben Anweisung, in der man sie auch signalisiert:
raise KeyError("Fehlerbeschreibung")
.
I
Aus den Urzeiten von Python gibt es noch die alternative
Syntax raise KeyError, "Beschreibung", die man
gelegentlich in fremdem Code antrifft.
I
Die Beschreibung kann auch weggelassen werden; die Form
raise KeyError() ist also auch zulässig.
I
Auch die Notation raise KeyError ist erlaubt; in diesem
Fall wird automatisch eine Instanz erzeugt.
Malte Helmert
Programmieren in Python
try-except-Blöcke
I
Funktionen, die Ausnahmen behandeln wollen, verwenden
dafür try-except-Blöcke, die wie in folgendem Beispiel
aufgebaut sind:
try:
call_critical_code()
except NameError, e:
print "Sieh mal einer an:", e
except KeyError:
print "Oops! Ein KeyError!"
except (IOError, OSError):
print "Na sowas!"
except:
print "Ich verschwinde lieber!"
raise
Malte Helmert
Programmieren in Python
except-Spezifikationen (1)
I
Das Beispiel zeigt, dass es verschiedene Arten gibt,
except-Spezifikationen zu schreiben:
I
I
I
I
Die normale Form ist except XYError, e.
Ein solcher Block wird ausgeführt, wenn innerhalb des
try-Blocks eine Ausnahme der Klasse XYError (oder einer
abgeleiteten Klasse) auftritt und weist der Variablen e die
Ausnahme zu.
Interessiert die Ausnahme nicht im Detail, kann die Variable
auch weggelassen werden, also die Notation except XYError
verwendet werden.
Bei beiden Formen kann man auch mehrere Klassen
gemeinsam behandeln, indem man die Klassen in ein Tupel
schreibt, also z.B. except (XYError, YZError), e.
Schließlich gibt es noch die Form except ohne weitere
Angaben, die beliebige Ausnahmen behandelt.
Malte Helmert
Programmieren in Python
except-Spezifikationen (2)
I
except-Blöcke werden wie in anderen Programmiersprachen
der Reihe nach abgearbeitet, bis der erste passende Block
gefunden wird (falls überhaupt einer passt).
I
Die Reihenfolge ist also wichtig; unspezifische except-Blöcke
sind nur als letzter Test sinnvoll.
I
Um beliebige Ausnahmen abzufangen und die Ausnahme an
eine Variable zu binden, ist die Spezifikation except
Exception, e geeignet, da alle üblicherweise abzufangenden
Ausnahmeklassen von Exception abgeleitet sind.
I
Stellt sich innerhalb eines except-Blocks heraus, dass die
Ausnahme nicht vernünftig behandelt werden kann, kann sie
mit einer raise-Anweisung ohne Argument weitergereicht
werden.
Malte Helmert
Programmieren in Python
try – except – else
I
Ein try-except-Block kann mit einem else-Block
abgeschlossen werden, der ausgeführt wird, falls im try-Block
keine Ausnahme ausgelöst wurde:
try:
call_critical_code()
except IOError:
print "IOError!"
else:
print "Keine Ausnahme"
Malte Helmert
Programmieren in Python
try-finally-Blöcke
I
I
Manchmal kann man Ausnahmen nicht behandeln, möchte
aber darauf reagieren – etwa um Netzwerkverbindungen zu
schließen oder andere Ressourcen freizugeben.
Dazu dient der try-finally-Block:
try:
call_critical_code()
finally:
print "Das letzte Wort habe ich!"
I
I
Der finally-Block wird auf jeden Fall ausgeführt, wenn der
try-Block betreten wird, egal ob Ausnahmen auftreten oder
nicht. Auch bei einem return im try-Block wird der
finally-Block vor Rückgabe des Resultats ausgeführt.
Wurde eine Ausnahme signalisiert, wird sie nach Behandlung
des finally-Blocks weitergegeben.
Malte Helmert
Programmieren in Python
Verwendung von Ausnahmen in Python
I
Ausnahmen sind in Python allgegenwärtig. Da
Ausnahmebehandlung im Vergleich zu anderen
Programmiersprachen einen relativ geringen Overhead
erzeugt, wird sie oft in Situationen eingesetzt, in denen man
sie durch zusätzliche Tests vermeiden könnte.
I
Man spricht vom EAFP-Prinzip:
It’s easier to ask forgiveness than permission.“
”
Beispielsweise würde man in Python nicht testen, ob eine
Datei existiert, bevor man sie zum Lesen öffnet, sondern das
Öffnen versuchen und gegebenfalls die Ausnahme abfangen,
die das Fehlen der Datei signalisiert.
I
Malte Helmert
Programmieren in Python
Ausnahmeklassen in den Builtins
I
Pythons Builtins enthalten eine große Zahl an
Ausnahmeklassen, die hier aufzuzählen nicht sehr sinnvoll
wäre. Ein Überblick befindet sich auf der Seite:
http://docs.python.org/library/exceptions.html
Malte Helmert
Programmieren in Python
Eigene Ausnahmeklassen
Als kleiner Vorgriff auf die Diskussion von Klassen hier das
Kochrezept zum Definieren eigener Ausnahmeklassen:
class MyException(BaseClass):
pass
I
MyException kann dann genauso verwendet werden wie
eingebaute Ausnahmeklassen wie IndexError.
I
Für BaseClass wird man oft Exception wählen, aber
natürlich eignen sich auch andere Ausnahmeklassen.
I
Nebenbemerkung: pass ist die Python-Anweisung für tue
”
nichts“.
Malte Helmert
Programmieren in Python
Funktionen, Ausnahmen und Module
In dieser Lektion vertiefen wir das Thema Funktionsdefinitionen
und behandeln mit der Fehlerbehandlung und dem Erstellen und
Verwenden von Modulen zwei weitere essentielle Themen.
I
Mehr zu Funktionen
I
Ausnahmen
I
Module
Malte Helmert
Programmieren in Python
Module
I
Bisher waren unsere Programme auf einzelnen Dateien
beschränkt und haben außer Builtins auch keine Funktionen
oder Klassen benutzt, die außerhalb der Datei definiert sind.
I
Das ist bei richtigen Programmen natürlich fast nie der Fall:
Zum einen will man fast immer externe Bibliotheken
benutzen, zum anderen möchte man umfangreichere
Programme auf mehrere Sinneinheiten verteilen.
I
Solche Sinneinheiten sind in Python typischerweise Module.
I
Neben Modulen gibt es noch Pakete, Sammlungen von
Modulen unter einem gemeinsamen Namen, aber mit denen
werden wir uns nicht beschäftigen – man kommt meist auch
gut ohne aus.
Malte Helmert
Programmieren in Python
Module erstellen und verwenden
I
Wir haben schon die ganze Zeit über Module erstellt: Jede
*.py-Datei ist ein Modul, und jedes Modul ist eine
*.py-Datei.
I
Noch nicht besprochen haben wir, wie man auf externe
Module zugreifen kann. Dafür gibt es zwei Anweisungen, das
(häufigere)
import mymodule
und das seltener verwendete
from mymodule import X.
Malte Helmert
Programmieren in Python
Die import-Anweisung
Die Anweisung import mymodule tut drei Dinge:
I Zunächst wird überprüft, ob das Modul mymodule bereits
früher von unserem Programm geladen wurde (z.B. von einem
anderen Modul aus). Falls ja, wird das damals erzeugte
Modulobjekt verwendet und die folgenden Schritte
übersprungen. Module werden also nicht mehrfach geladen.
I Dann wird die Datei mymodule.py an verschiedenen Stellen
(aktuelles Verzeichnis, Standardbibliothek) gesucht und
ausgeführt, als würde man sie mit python mymodule.py
aufrufen. Die meisten Module enthalten nur (Funktions- und
Klassen-) Definitionen, aber es ist durchaus möglich, in
diesem Initialisierungsschritt beliebigen Code auszuführen.
I Schließlich wird ein neues Modul-Objekt (vom Typ module)
erzeugt und der Variable mymodule zugewiesen. Die globalen
Variablen von mymodule.py sind in dem importierenden
Modul als Attribute von mymodule verfügbar.
Malte Helmert
Programmieren in Python
import: Beispiel
helpers.py
def product(x, y, z):
return x * y * z
food = "spam"
print "helpers ist dran."
import example.py
print "Start"
import helpers
print helpers.food
print helpers
#
#
#
#
#
Ausgabe: Start
Ausgabe: helpers ist dran.
Ausgabe: spam
Ausgabe: <module ’helpers’ from
’/home/helmert/tmp/helpers.pyc’>
del helpers
import helpers
# keine Ausgabe
print helpers.product(2, 3, 4) # Ausgabe: 24
Malte Helmert
Programmieren in Python
Bytecode und *.pyc-Dateien
I
Wir stellen fest, dass Python bei der Ausführungs unserers
Testbeispiels eine Datei namens helpers.pyc angelegt hat.
I
Dabei handelt es sich um Bytecode vergleichbar
class-Dateien in Java.
I
Python-Code wird vor der Ausführung immer in Bytecode für
die Python Virtual Machine übersetzt. Normalerweise merkt
man davon nichts, aber beim Importieren von Modulen wird
der Bytecode für die Module gespeichert, damit er bei
späteren Programmaufrufen sofort verfügbar ist.
I
Ändert sich eine *.py-Datei, wird die zugehörige *.pyc-Datei
automatisch neu generiert — man kann also nichts falsch
machen. Es schadet aber auch nie, *.pyc-Dateien von Hand
zu löschen, um ein Verzeichnis aufzuräumen.
Malte Helmert
Programmieren in Python
Die Anweisung from mymodule import x
Die Anweisung from mymodule import x verhält sich ähnlich wie
import mymodule. Die ersten zwei Schritte (Überprüfen ob
mymodule schon geladen ist und ggf. Ausführen der Datei) sind
identisch.
Der Unterschied liegt im dritten Schritt:
I
Bei from mymodule import x wird keine Variable namens
mymodule angelegt, sondern die Variable x, die der globalen
Variable x aus mymodule entspricht. Es wird also nicht das
ganze Modul, sondern nur ein Objekt verfügbar, und dieses
kann ohne Punkt-Notation verwendet werden.
Malte Helmert
Programmieren in Python
from ... import: Beispiel
helpers.py
def product(x, y, z):
return x * y * z
food = "spam"
print "helpers ist dran."
from import example.py
print "Start"
from helpers import food
print food
from helpers import product
print product(8, 8, 8)
Malte Helmert
#
#
#
#
#
Start
helpers ist dran.
spam
<keine Ausgabe>
512
Programmieren in Python
Allgemeinere Formen von import und from ... import
Es ist möglich, mehrere Module bzw. Objekte gleichzeitig zu
importieren und Module bzw. Objekte unter einem anderen Namen
zu importieren:
I
import spammodule, eggmodule
I
import mymodule as mymod
I
from monty import spam, egg
I
from monty import spam as food
I
from mymodule import *
Malte Helmert
Programmieren in Python
Die Standardbibliothek
I
Python ist von Haus aus mit einer Vielzahl von Modulen
ausgestattet.
I
Die mitgelieferten Module bezeichnet man als Pythons
Standardbibliothek.
I
Es wäre unsinnig zu versuchen, hier einen Überblick über die
Standardbibliothek zu geben; dafür ist sie viel zu umfangreich.
I
Stattdessen ein Link zum Inhaltsverzeichnis:
http://docs.python.org/library/
Malte Helmert
Programmieren in Python