Importierte Funktion funktioniert nicht

[graphicsH]

Hi,
ich schreibe gerade einen interpreter mit dem Modul cmd.
in diesem möchte ich nun ein neues modul auf befehl importieren,und dann die befehle von diesem verwenden,
das importieren haut schon hin,jedoch kann ich die befehle des moduls nicht verwenden:

Auschnitt vom Interpreter:

Code: Alles auswählen

    def do_import(self,line):
        try:
            from GUI import module
            from Python import module
            from EXT_1 import module
            from EXT_2 import module
            from EXT_3 import module
        except ImportError:
            print ''

und hier z.B Auschnitt von shutdownI:

Code: Alles auswählen

    def do_shutdownI(self,line):
        sdroot = Tk()
        sdbut = Button(sdroot,text='Shutdown',command=os.system('shutdown -s'))
        sdbut.pack(side=LEFT)
        rsbut = Button(sdroot,text='Restart',command=os.system('shutdown -g'))
        rsbut.pack(side=LEFT)
        lobut = Button(sdroot,text='Logout',commmand=os.system('shutdown -l'))
        lobut.pack(side=LEFT)
        spbut = Button(sdroot,text='Idle state',command=os.system('shutdown -h'))
        spbut.pack(side=LEFT)
        qtbut = Button(sdroot,text='Quit',command=sdroot.destroy)
        qtbut.pack(side=RIGHT)
        sdroot.mainloop()

Jedoch kann ich wie gesagt nach dem importieren den Befehl shutdownI sowie alle anderen nicht verwenden.

[Zap]

Hallo graphicsH.

Ohne zu verstehen was du da versuchst zu erreichen:

• Ein try-except über n Ausdrücke und dann einfach den Fehler zu verschlucken kann nur Probleme bereiten.
• Alle imports binden den Namen "module" neu. Somit ist nur der letzte (funktionierende) import über module zugreifbar.

Das sieht auf den ersten Blick nicht danach aus, als wenn du dir die Grundlagen zum import verinnerlicht hättest.

[graphicsH]

Ich habe jetzt die Klassennamen geändert,und zum test alle anderen module außer GUI entfernd.
Wenn ich nun den Befehl importieren benutze gibt es keine Fehlermeldung mehr (habe try/except entfernt),jedoch
funktionieren die importierten Befehle immer noch nicht :K

umgeändert:

Code: Alles auswählen

 def do_import(self,line):
            from GUI import gui

[derdon]

Ich bin mir nicht sicher, ob du wirklich verstanden hast, was "import" überhaupt tut. Verstehst du die folgende Session, also warum nach dem ersten import etwas ausgegeben wird aber nicht nach dem zweiten oder dritten?

Code: Alles auswählen

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
>>> import this
>>> import this
>>> 

[EyDu]

Hallo.

Beschreibe am besten das eigentliche Problem, welches du mit deinem Code zu lösen versuchst. Es scheint mir, dass das Problem ein ganz anderes ist und du glaubst, dass dein Ansatz eine gute Lösung sei.

Sebastian

[graphicsH]

@derdon
soweit ich es versanden habe importiert 'import' Befehle aus einem Modul,um diese nutzten zu können,wodurch man die Standart-Befehlbibliothek erweitern kann.
Wieso er nach einem import Befehl in deinem Beispiel Text ausgibt ist mir aber ein Rätsel (ich programiere erst seit ein paar monaten und hab mein wissen aus mehreren kleineen Tutorials sowie google zusammengekratz,und verstehe daher manche ziemlich banalen sachen immer noch nicht)

@Sebastian
Ich möchte die Befehls-Bibliothek in meinem cmd-Interpreter durch import aus einem anderen Modul erweitern.Das Importieren funktioniert bereits,anwenden kann ich die Befehle jedoch nicht!

[bords0]

"funktioniert" ist keine hilfreiche Fehlerbeschreibung. Kopiere doch die, die Python dir zeigt - die ist hilfreich.

Und prüfe mal, ob import Namen global oder lokal bindet.

[Darii]

Ich möchte die Befehls-Bibliothek in meinem cmd-Interpreter durch import aus einem anderen Modul erweitern.Das Importieren funktioniert bereits,anwenden kann ich die Befehle jedoch nicht!

Wenn du willst, dass dir wer hilft dann poste bitte mehr als ein paar völlig unzusammenhängende, aus dem Zusammenhang gerissene Codefetzen. Ein Minimalbeispiel von dem was nicht funktioniert wäre ideal.


Und wie bords0 schon schrieb: „Geht nicht“ war noch nie und ist auch keine Fehlerbeschreibung.

[snafu]

Kann es sein, dass du das Importieren in Python mit dem Inkludieren, wie man es von Sprachen wie C oder C++ kennt, verwechselst? Nach einem `import mod_x` ist die Funktion `func_y` nämlich nicht direkt über den globalen Namensraum erreichbar. Vielmehr ist dafür ein Aufruf mittels `mod_x.func_y()` nötig, nachdem man importiert hat. Oder aber, man macht das direkt über `from mod_x import func_y` - dann funktioniert `func_y()` natürlich.

Sofern du ein Package hast (also ein Verzeichnis mit mehreren .py-Dateien und einer `__init__.py`) und dein Package `mypkg` heißt, dann hieße das für dich:

Code: Alles auswählen

from mypkg import gui
gui.func_y()

[graphicsH]

@bords0
Es gibt beim importieren keine Fehlermeldung,aber beim aufrufen:

Code: Alles auswählen

*** Unknown syntax: gui.copyI

ich habe auch schon alle möglichen schreibvarianten für den Aufruf getestet(gui.copyI,gui.do_copyI,usw.)

@snatu
mit C oder C++ verwchsel ich es sicher nicht,weil die kann ich nicht.
hab wie oben geschrieben auch alle möglichen schreibvarianten ausprobiert.
Immer die obrige Fehlermeldung

[snafu]

Das ist allerdings keine reine Python-Fehlermeldung. Da muss noch irgendetwas zwischengeschaltet sein. Verwendest du den normalen Python-Interpreter?

[graphicsH]

@sanfu
wie oben steht ist das nicht der python interpreter,sondern der interpreter des cmd Moduls für python

[BlackJack]

@graphicsH: Eine Eingabe wie ``gui.copyI`` kann nicht funktionieren, solange es auf dem `Cmd`-Objekt keine `do_gui()`-Methode gibt. So funktioniert das `Cmd`-Objekt schliesslich — für dass vom Benutzer eingegebene Kommando `k` wird auf dem Objekt eine entsprechende `do_k()`-Methode aufgerufen. Das impliziert zum einen, dass in dem Kommando nur Zeichen vorkommen dürfen, die auch in Python-Namen zulässig sind, und zum anderen, dass es eine solche Methode auf dem Objekt geben muss. Die entstehen allerdings auch nicht auf magische Weise nur weil man irgend ein Modul importiert. Wenn Du die dynamisch von irgend wo holen willst, dann musst Du die auch explizit auf dem Objekt setzen.

[snafu]

Ich fasse nochmal zusammen: Du führst aus dem Loop eines `Cmd()`-Exemplars diverse Befehle aus, deren Ergebnis natürlich ein Aufruf der entsprechenden `do_*`-Methode des Exemplars ist. Innerhalb der Methode importierst du ein Modul und gehst davon aus, dass der Namensraum des Moduls auf magische Weise quasi der `cmd`-Shell übergeben wird und du die in dem importierten Modul enthaltenen Funktionen plötzlich als Befehle aufrufen kannst, oder wie? Zeig doch einfach mal den exakt von dir verwendeten Code und insbesondere die Stelle, an welcher der Fehler auftritt. Das würde IMHO eine Menge an Nachfragen und möglichen Missverständnissen vermeiden.

[snafu]

Vielleicht noch etwas als Anmerkung, da ich allmählich das Vorhaben des TE zu erahnen glaube: Die durch das Modul `cmd` als Framework bereitgestellte Shell-Funktionalität hat nicht die Intention, eine Art anpassbare Python-Shell zu sein. Falls es nämlich darum gehen sollte, dann empfiehlt sich eher ein Blick auf das Projekt IPython. Dort werden Möglichkeiten für eine "eigene" Shell bereitgestellt, welche im Namenraum bestimmter vorher importierter Module arbeiten kann und durch beliebige "Spezial-Befehle" erweiterbar ist.

Aber letztlich gilt nach wie vor das, was schon vorher gesagt wurde: Was ist dein eigentliches Vorhaben? Wenn du das nicht benennst, dann bleibt dieser Thread weiterhin ein munteres Ratespiel für potenzielle Helfer.

[BlackJack]

Sollte es um eine interaktive Python-Shell gehen, gibt es auch noch das `code`-Modul in der Standardbibliothek. Und man kann vielleicht auch beides kombinieren, in dem man zum Beispiel die `Cmd`-Unterklasse so implementiert, dass die Befehle einen Präfix bekommen und alles was `Cmd` nicht „versteht” an ein `code.InteractiveInterpreter`-Exemplar weiter gereicht wird.

[graphicsH]

@blackJack
wieso muss es eine do_gui Methode geben.das 'gui' ist der klassenname der importierten klasse

@snafu
der fehler tritt bei jedem befehl aus importierten files auf
hier code-ausschnitte aus dem hauptfile:

Code: Alles auswählen

import cmd
import sys
import string
import os
import shutil
import math

class CIT(cmd.Cmd):
    print '---CommandInterpreterTool v.Alpha---'
    print 'Type "help" or "credits" for more Information'

    def __init__(self):
        cmd.Cmd.__init__(self)
        self.prompt = '>>>> '
        self.nohelp = '*** No help on %s ***'
        self.ruler = '-'
        os.system('title CommandInterpreterTool')
# .
# .
# .
 
    def do_import(self,line):
        try:
            from GUI import gui
            from Python import py
            from EXT_1 import ext1
            from EXT_2 import ext2
            from EXT_3 import ext3
    def help_import(self):
        print 'syntax: >>>> import'
        print ''
        print '--imports all installed modules'

und hier z.B ein Befehl aus dem Modul gui:

Code: Alles auswählen

    def do_shutdownI(self,line):
        sdroot = Tk()
        sdbut = Button(sdroot,text='Shutdown',command=os.system('shutdown -s'))
        sdbut.pack(side=LEFT)
        rsbut = Button(sdroot,text='Restart',command=os.system('shutdown -g'))
        rsbut.pack(side=LEFT)
        lobut = Button(sdroot,text='Logout',commmand=os.system('shutdown -l'))
        lobut.pack(side=LEFT)
        spbut = Button(sdroot,text='Idle state',command=os.system('shutdown -h'))
        spbut.pack(side=LEFT)
        qtbut = Button(sdroot,text='Quit',command=sdroot.destroy)
        qtbut.pack(side=RIGHT)
        sdroot.mainloop()
    def help_shutdownI(self,line):
        print 'syntax: >>>> shutdownI'
        print ''
        print '--runs the commands >shutdown< >restart< >logout< and'
        print '>sleep< with a GraphicsUserInterface'

@snafu
ich versuche einen eigenen Commando-Interpreter für meinen Computer zu schreiben.
Da ich nacher den file mit py2exe in eine exe transforiere möchte ich mit der funktion do_import
fix benannte module importieren,da,falls mir im nachhinein noch praktische befehle einfallen,
ich diese auf diese art noch verwenden kann.

[BlackJack]

@graphicsH: Wenn Du ``gui.irgendwas`` eingibst, dann ist ``gui`` das Kommando und der Rest wird von `Cmd` als Argument interpretiert. `gui.irgendwas` kann kein Kommandoname sein, weil es dann ja eine Methode mit dem Namen ``do_gui.irgendwas`` geben müssten, aber der Punkt kann kein Bestandteil eines Namens in Python sein, da er schon als Operator eine syntaktische Bedeutung hat.

Alles was ein `Cmd`-Exemplar kann/macht ist den ersten Teil der Eingabe als Kommandoname zu verwenden um auf sich selbst nach einer entsprechenden `do_*`-Methode zu suchen und die auszuführen.

Wenn Du dem `Cmd`-Exemplar dynamisch Methoden hinzufügen möchtest, musst Du das explizit *tun*. Irgendwelche Objekte aus anderen Modulen importieren, und dazu noch nur *lokal* in einer Methode, fügt deren Methoden nicht auf magische Weise dem `Cmd`-Exemplar hinzu. Dazu sollte man die Grundlagen von Python, die Namensräume, den ``import``-Mechanismus, das Objektmodell, usw. verstanden haben. Dann könnte man mit `setattr()` und dem `types`-Modul dynamisch dem `Cmd`-Exemplar gebundene Methoden hinzufügen.

Bei Klassennamen wie `CIT` und `gui` solltest Du vielleicht auch mal einen Blick in PEP 8 -- Style Guide for Python Code werfen.

[graphicsH]

@BlackJack
Ich hab das stattr() und type modul angeschaut,
jedoch keine anhung wie ich mit denen die importierten befehle einbinden soll :K :K :K

[graphicsH]

kann mir da einer helfen