modul selbst als paramter übergeben

[hiasl]

Hallo,

gibt es eine Möglichlkeit eine Modulinstanz als Parameter zu übergeben - quasi ein module.self?

Vielen Dank!
Matthias

[CM]

Hoi,

wahrscheinlich (ziemlich sicher sogar): Ja. Was willst Du denn machen? Wo liegt Dein Problem? (Die Frage ist etwas unspezifisch .)

Gruß,
Christian

[Masaru]

So in etwa?

Code: Alles auswählen

>>> import os
>>> def who_is(this_module):
... 	print this_module.__file__
... 	
>>> who_is(os)
C:\_PYTHON_\python23\lib\os.pyc

In Python kannst Du alles mögliche Übergeben , das ist ja gerade eine der feinen (aber manchmal auch gefährlichen) Besonderheiten.

[hiasl]

Ne, so gerade nicht. Ich meine das:

Code: Alles auswählen

module.py:

def class A(object):
   def __init__(self, arg):
      print arg

a = A(module.self)

[Masaru]

Um noch einmal CM zu zitieren "Was willst Du denn machen? Wo liegt Dein Problem?"

Willst Du das eigene Modul in sich selbst, noch einmal übergeben? Achja self funktioniert nur bei "Klassen", nicht bei "Modulen" .

Wobei ... Du solltest bedenken, dass wenn man nicht aufpasst eine never ending Rekursion erzeugt:

Code: Alles auswählen

 ...
RuntimeError: maximum recursion depth exceeded

Der folgende Code würde z.B. so etwas ermöglichen und dabei den RuntimeError (nie endende, immer wieder sich selbst aufrufende Rekursion) vermeiden:

Code: Alles auswählen

#! /usr/bin/env python

import sys

if __name__ == '__main__':
    print "... mained"
    sys.path.insert(0, __file__)
    import mymodule
else:
    print "... imported"

Code: Alles auswählen

C:\Python> mymodule.py
... mained
... imported

C:\Python\> 

Es wäre dennoch hilfreich für uns, wenn Du den genauen Zweck mit ein paar Rahmeninformatiionen beschreiben könntest.

[EyDu]

Egal was du damit lösen möchtest, ein Modul übergeben ist mit höchster Wahrscheinlichkeit keine gute Lösung. Wenn du schon selber von ModulINSTANZEN sprichts, dann werden dir wohl nur Klassen helfen. Die Anzahl der Instanzen von Modulen ist doch recht, ... sagen wir mal: beschränkt...

[EnTeQuAk]

Ich glaube, ich weiß, was er meint.

Ich nehme mal das Beispiel, wo ich so etwas ähnliches gemacht habe.

in dauCMS habe ich auch die Möglichkeit eingebaut, das man via Konfigurationsdatei angeben kann, welchen Markup-Parser man nehmen kann (gut... implementiert nicht... aber vorbereitet ist es).

Ich übergebe einfach einer Funktion den Namen des Importierten Moduls
Ohne es zu instanzieren... gut das kannst du auch machen ... is schnuppe, wie pups

So wird in http://daucms.de/trac/browser/trunk/daucms.py#L139 'WikiSyntaxProcessor' an meinen FileParser übergeben, damit er weiß, mit welchem Markup-Parser er arbeiten darf

und in http://daucms.de/trac/browser/trunk/uti ... ser.py#L37 wird dann die Klasse als Attribut 'lexer' entgegengenommen.
Mit 'self.lexer' kann dann gearbeitet werden :=)


MfG EnTeQuAk

[mitsuhiko]

Das aktuelle Modul bekommst du so:

Code: Alles auswählen

>>> import sys
>>> a = 42
>>> sys.modules[__name__].a
42
>>> sys.modules[__name__]
<module '__main__' (built-in)>

[BlackJack]

Ich würde auch nochmal die Frage wiederholen wollen, welches Problem damit gelöst werden soll. So "umständlich" kommt man ja nur an das Modul heran, in dem die Klasse selbst liegt, die hat aber schon Zugriff auf alles. An andere Module kommt man mit ``import`` bzw. `__import__()` heran.

[hiasl]

Vielen Dank für die Antworten!

Ich brauche das schlicht, weil wir einen Codegenerator zur Einbindung von Gerätetreibern bauen. Die Anbindung erfolgt je nach Gerät über Bibliotheken (mittels ctypes) oder über Dateischnittstellen bzw. Sockets.

Im ersteren Fall übergebe ich einer Klasseninstanz eine Referenz auf die Bibliothek. Da der generierte Code strukturell möglichst gleich sein soll, ist für mich im zweiten Fall die Übergabe einer Modulreferenz von Vorteil.

Natürlich kann man das über Klassen lösen (und manuell ist das auch so geschehen), es passt mir halt nicht.

Ciao
Matthias

[sape]

[...]
Ich brauche das schlicht, weil wir einen Codegenerator zur Einbindung von Gerätetreibern bauen. Die Anbindung erfolgt je nach Gerät über Bibliotheken (mittels ctypes) oder über Dateischnittstellen bzw. Sockets.

Im ersteren Fall übergebe ich einer Klasseninstanz eine Referenz auf die Bibliothek. Da der generierte Code strukturell möglichst gleich sein soll, ist für mich im zweiten Fall die Übergabe einer Modulreferenz von Vorteil.
[...]

Falls ich dein Problem verstanden habe dann...

Würde es den nicht genügen wenn du dir ein Environment-Klasse schreibst, in der du die importierten Module registrierst? Du könntest es so machen das dann alle auf diese Umgebung zugriff haben.

Dynamisch lässt sch ein Modul so importieren.

Code: Alles auswählen

mod = __import__(fullname, globals(), locals(), [])
print mod
print type(mod)

Ablauf:
Sorg dafür das ein festes Verzeichnis existiert, in dem die Module die dynamisch importiert werden sollen drin sind. Mit, ``os.walk``, etc, holst du dir dann aus diesem Verzeichnis zu allen Modulen den absoluten Pfad mit Dateinamen, den du in einer ``list`` speicherst. Im nächste schritt iterierst du über die liste (``for fullname in fullnames:...``) und importierst die Module (``mod = __import__(fullname, ...)). Die kannst du dann zum Environment hinzufügen und kannst dann darauf zurückgreifen.

So, ähnlich habe ich das letzten auch realisiert, bloß das ich da keine Module registriert habe sondern nur geladen. Durch das laden wurde automatisch bestimmte Klassen in einer Umgebung von einer bestimmten Metaklasse registriert...

Den namen des Modules kriegst du nachehr so raus:

Code: Alles auswählen

print mod.__name__

-- Am besten sorgst du gleich für eine saubere Struktur in dem Environment, damit du, bzw. deine Klassen die die verwenden, die einzelnen Module zuordnen kannst/können.

Die Module, wie die anderen schon bereits gezeigt haben, kannst du dann auch als Parameter an eine Funktion/Methode übergeben.

Ansonnten, wäre eine etwas genauer Beschreibung über den Ablauf deines Systems nicht schlecht, da wir alle hier nur raten können was du letzendich erreichen willst.