Inhaltsverzeichnis[Anzeigen]

 

Module und Packages


Eine Python Sourcedatei wird als Modul bezeichnet. Werden die Dateien darüber hinaus noch in Verzeichnissen organisiert, so wird diese Verzeichnisstruktur Package genannt.

Module

Syntax

  • folgender Code source.py soll als Beispiel dienen
var="Variable"

def function() : print "I'm a function"

class SimpleClass:

    def name(self): return "I'm a methode" 
  • es gibt im wesentlichen zwei Möglichkeiten Python Source einzubinden und eine Namensvariation

Einbinden des ganzen Moduls

durch import module

>>> import source
>>> print source.var

Variable
>>> source.function()
I'm a function
>>> myInst= source.SimpleClass()

>>> myInst.name()
I'm a methode 

Explizites Einbinden einzelner Definitionen des Moduls

durch from module import definition

>>> from source import var
>>> from source import function

>>> from source import SimpleClass
>>> print var
Variable
>>> print function()

I'm a function
>>> function()
I'm a function
>>> myInst= SimpleClass()
>>> myInst.name()

I'm a methode 

 

  • TIP durch from source import * werden alle Definitionen in den globalen Namensraum eingebunden

Einbinden unter einem anderen Namen

durch import module as newSource oder from module import definition as newName

  • Beispiel
    • import source as newSoure erlaubt es, die Funktionalität von source durch newSource aufzurufen
    • mittels from source import var as newVar ist es möglich, die Funktion var durch newVar aufzurufen
  • ALERT! durch das Einbinden des ganzen Moduls oder der Definition unter einem anderen Namen ist es auf einfache Weise möglich, Namenskollisionen zu vermeiden

Empfehlung

  • Module sollten nicht in den globalen Namensraum geladen werden, denn Ausdrücke der From
from source import function

verdeckt vorhandene Attribute

  • das Laden bestehender Funktionalität unter neuem Namen sollte mit Vorsicht verwendet werden, denn einerseits macht es den Code schwerer lesbar und andererseits können gefährliche Seiteneffekte entstehen
  • folgender Code versteckt den built-in Befehl dir
>>> from source import function as dir
>>> dir()
I'm a function
>>> dir ([])

Traceback (most recent call last):
  File "<stdin>", line 1, in ?

TypeError: function() takes no arguments (1 given) 
  • TIP mittels del dir wird die dir Definition im aktuellen Namensraum gelöscht MOVED TO... das built-in dir ist nun wieder sichtbar
  • REFACTORlade das Modul auf verschiedene Arten und nütze es; speicher dazu das Modul ab und rufe den Pythoninterpreter aus dem Modulverzeichnis auf
    • einbinden des ganzen Modules
    • explizite Einbinden einzelner Definition des Moduls
    • einbinden unter einem anderen Namen

 

Besonderheiten

  • während die import Anweisung an jeder Stelle des Codes erscheinen darf, muß die from module import Anweisung am Anfang des Moduls stehen
  • durch Definition der Liste __all__ in dem Modul ist es möglich, festzulegen, welche Definition durch from module import * verfügbar sind
__all__= ["function","var"]

Namen

  • jedes Modul definiert eine Variable __name__, die den Name des Moduls enhält
  • wird das Modul unter einem Alias eingebunden, enthält __name__ den ursprünglichen Namen
>>> import os as dir
>>> dir.__name__
'os'
  • der Name des Top Level Moduls ist __main__
  • daher ist es einfach zu prüfen, ob ein Modul als Hauptprogramm benützt wird
if __name__ == "__main__":
  statements
else:

  statements 
  • der if Zweig wird ausgeführt, falls das Modul als Hauptprogramm genutzt wird, andererseits der else Zweig
  • die built-in Funktion reload()erlaubt ein Modul zur Laufzeit erneut zu laden
    • falls das Modul unter einem Alias geladen wurde, muß der Befehl reload diesen Alias verwenden
import source
...
reload(source) 

Der Suchpfad für Module kann mittels

  • der Modulvariable sys.path
>>> import sys
>>> print sys.path

['', '/usr/local/lib/python23.zip', '/usr/local/lib/python2.3',
 '/usr/local/lib/python2.3/plat-linux2', '/usr/local/lib/python2.3/lib-tk',

 '/usr/local/lib/python2.3/lib-dynload', '/usr/local/lib/python2.3/site-packages']
>>> sys.path.append( "/home/grimm")

>>> print sys.path
['', '/usr/local/lib/python23.zip', '/usr/local/lib/python2.3',
 '/usr/local/lib/python2.3/plat-linux2', '/usr/local/lib/python2.3/lib-tk',

 '/usr/local/lib/python2.3/lib-dynload', '/usr/local/lib/python2.3/site-packages',
 '/home/grimm'] 

angesehen und modifiziert werden

  • der Environmentvariablen PYTHONPATH editiert werden

Module lassen sich in vier Gruppen unterteilen.

  • Python Programme
  • C oder C++ Erweiterung in shared libraries
  • Packages von Modulen
  • built-in Module in C, die in den Python Interpreter gelinkt sind

sys.modules gibt alle Module aus, die der Python Interpreter geladen hat
REFACTORLade das Modul aus einem anderen Verzeichnis.

  • passe den Modulsuchpfad mittels sys.pathoder der Umgebungsvariablen PYTHONPATH an
    • den Wert der Umgebungsvariablen PYTHONPATH erhälts du mittels os.getenv("PYTHONPATH")

REFACTORLade das Modul nochmals, nachdem du das Modul um die Einschränkung

__all__= ["function","var"] 

erweitert hast

Packages

  • Packages sind Verallgemeinerungen von Modulen, den ein Package zeichnet sich durch die folgenden Punkte aus
    1. ein Packages wird durch ein gleichnamiges Verzeichnis repräsentiert
    2. das Packages besteht aus ein oder mehrern Modulen
    3. es muß eine Datei __init__.py je Package/Verzeichnis geben
  • folgendes Package soll der Veranschaulichung dienen
Graphik/
    __init__.py
    Primitive/

        __init__.py
        lines.py
        fill.py
    2DGraph/
        __init___.py
        plot2d.py

Einbinden

  1. import Graphik.Primitive.fill
    • das Untermodul Graphik.Primitive.fill wird geladen und kann explizt über Graphik.Primitive.fill.floodfill(image,x,y,color) angesprochen werden
  2. from Graphik.Primitive import fill
    • das Untermodul fill wird geladen und kann mittel fill.floodfill(image,x,y,color) angesprochen werden
  3. from Graphik.Primitive.fill import floodfill
    • lädt das Untermodul fill, macht aber die Funktion floodfill bekannt, so daß direkt mittels floodfill(image,x,y,color) angesprochen werden kann

Besonderheiten

  • __init__.py
    • immer wenn ein Teil eines Packages importiert wird, wird die Initialisierungsdatei __init__.py des entsprechenden Packages prozessiert
      MOVED TO... im Fall import Graphik.Primitive, wird sowohl __init__.py im Graphik als auch im Primitive Verzeichnis abgearbeitet
    • durch Setzen der Variable __all__ in __init__.py kann man festlegen, welche Module des Packages durch die Anweisung from module import * geladen werden
  • import verhält sich nicht rekursiv
    • durch import Graphik werden nicht automatische alle Untermodule wie Graphik.Primitive.fill geladen, so daß folgender Aufruf scheitert
import Graphik
Graphik.Primitive.fill.flood(img,x,y,color)
  • um das Importieren zu erleichtern, bietet es sich daher an, die Untermodule über die Datei __init__.py zu laden
# Graphik/__init__.py
import Primitive, 2DGraph

# Graphik/Primitive/__init__.py
import lines, fill 

Importieren

  • Module im selben Verzeichnis können ohne voll qualifizierten Namen angesprochen werden
# in Graphik/Primitive
import lines         
  • Module eines Packages in anderen Verzeichnis müssen ( einschließlich Python 2.4 ) über den voll qualifizierten Namen angesprochen werden
# in plot2d.py
import Graphik.Primitive.fill

Graphik.Primitive.fill.floodfill(image,x,y,color)
  • REFACTOR Python besitzt eine light-weight implementation of the Document Object Model
    • diese Schnittstelle um xml Dateien zu bearbeiten ist in dem Modul minidom.py definiert. right lade diese

 


Abonniere den Newsletter (+ pdf Päckchen)

Beiträge-Archiv

Sourcecode