modul selbst als paramter übergeben

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
hiasl
User
Beiträge: 31
Registriert: Donnerstag 20. April 2006, 13:36

modul selbst als paramter übergeben

Beitragvon hiasl » Mittwoch 14. März 2007, 14:58

Hallo,

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

Vielen Dank!
Matthias
CM
User
Beiträge: 2464
Registriert: Sonntag 29. August 2004, 19:47
Kontaktdaten:

Beitragvon CM » Mittwoch 14. März 2007, 15:02

Hoi,

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

Gruß,
Christian
Benutzeravatar
Masaru
User
Beiträge: 425
Registriert: Mittwoch 4. August 2004, 22:17

Beitragvon Masaru » Mittwoch 14. März 2007, 15:04

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
User
Beiträge: 31
Registriert: Donnerstag 20. April 2006, 13:36

Beitragvon hiasl » Mittwoch 14. März 2007, 15:20

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)

Benutzeravatar
Masaru
User
Beiträge: 425
Registriert: Mittwoch 4. August 2004, 22:17

Beitragvon Masaru » Mittwoch 14. März 2007, 15:52

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.
Zuletzt geändert von Masaru am Mittwoch 14. März 2007, 16:01, insgesamt 1-mal geändert.
EyDu
User
Beiträge: 4866
Registriert: Donnerstag 20. Juli 2006, 23:06
Wohnort: Berlin

Beitragvon EyDu » Mittwoch 14. März 2007, 15:59

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
User
Beiträge: 986
Registriert: Freitag 21. Juli 2006, 15:03
Wohnort: Berlin
Kontaktdaten:

Beitragvon EnTeQuAk » Mittwoch 14. März 2007, 16:33

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
Benutzeravatar
mitsuhiko
User
Beiträge: 1790
Registriert: Donnerstag 28. Oktober 2004, 16:33
Wohnort: Graz, Steiermark - Österreich
Kontaktdaten:

Beitragvon mitsuhiko » Mittwoch 14. März 2007, 16:52

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)>
TUFKAB – the user formerly known as blackbird
BlackJack

Beitragvon BlackJack » Mittwoch 14. März 2007, 18:02

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
User
Beiträge: 31
Registriert: Donnerstag 20. April 2006, 13:36

Beitragvon hiasl » Mittwoch 14. März 2007, 18:28

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
User
Beiträge: 1157
Registriert: Sonntag 3. September 2006, 12:52

Beitragvon sape » Donnerstag 15. März 2007, 07:41

hiasl hat geschrieben:[...]
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.

Wer ist online?

Mitglieder in diesem Forum: r.barrios