Befehl in System-Konsole mit subprocess starten

[imho74]

Hallo,

ok, vielleicht ist meine Überschrift etwas wirr. Was ich möchte ist, dass subprocess.Popen eine Shell/Befehlszeile/Terminal etc. öffnet, und zwar die Standard-Befehlszeile des jeweiligen Betriebssystems Windows, Gnu/Linux, MacOS X etc.

Folgender Code wird nur in der Python-Konsole ausgeführt:

Code: Alles auswählen

>>> import subprocess
>>> script = "print 'Hallo Welt!'"
>>> subprocess.Popen(['python', '-c', script])
<subprocess.Popen object at 0xb76a1f6c>
>>> Hallo Welt!

Das hier

Code: Alles auswählen

>>> subprocess.Popen(['python', '-c', script], shell=True)

oder das

Code: Alles auswählen

>>> subprocess.Popen(['python', '-c', script], shell=True, executable="/bin/bash")

öffnen auch keine Konsole, letzteres nicht mal die Bash auf einem Linux-System, sondern führt nur den Befehl "python" aus.

Geht das überhaut, was ich vorhabe, oder was mache ich falsch?

Vielen Dank.

Christian

[cofi]

Begrifflichkeiten: Eine Shell/Befehlszeile ist ein Programm zum Ausfuehren von Befehlen; ein Terminal(emulator) kuemmert sich (grob gesagt) um Ein- und Ausgabe.

Was du also willst ist einen Terminalemulator auszufuehren. Pech gehabt: Dazu gibts in GNU/Linux kein Standardprogramm. Es gibt da zwar einen Freedesktop-Standard mit dem man sein Terminal angeben kann, aber ob man sich darauf, abseits von KDE und Gnome, verlassen kann, weiss ich nicht.

Das `shell=True` heisst, dass eine Shell gestartet wird und diese den Befehl interpretiert und ausfuehrt.

[BlackJack]

@imho74: Die letzten beiden führen nicht Python aus, sondern eine Shell, die dann ihrerseits wieder Python ausführt. Und die letzte tut das auch mit der Bash. Dabei wird allerdings der ``/bin/sh`` als erstes Element in `argv` übergeben, so dass sich die Bash eventuell leicht anders verhält als wenn sie unter ihrem "richtigen" Namen gestartet wurde.

Du willst keine Shell sondern ein Terminal öffnen in dem dann Python läuft. Das wirst Du wahrscheinlich explizit machen müssen.

[Drache]

Hallo imho74,

also unter Windows entscheidet bei mir ob ich die Datei .py oder .pyw nenne, ob die Konsole geöffnet wird.
Unter Linux(Ubuntu) werde ich gefragt ob das Programm im Terminal laufen will.
Keine Ahnung ob dir das hilft.
Was magst du den tun, bzw was hast du vor ?
Ach ja, os.popen und subprocess.popen ist ein unterschied bei der Konsole, versuch mal beides.

Drache

[imho74]

Hi,

vielen Dank für eure Antworten. Ich habe jetzt eine Unterscheidung im Betriebssystem gebastelt, die etwa so aussieht:

Code: Alles auswählen

import os

if os.name == 'posix':
	terminal = os.environ['TERM']
	os.system(terminal)
elif os.name == 'nt':
	terminal = os.environ['ComSpec']
	os.system(terminal)
else:
	pass

Das ist allerdings noch unvollständig. Wenn ich dran bleibe soll irgendwann einmal ein Plugin für Gedit daraus werden, das auf Knopfdruck ein Terminal startet und eventuell Befehle dahin übergibt.

Mal schauen.

[Leonidas]

Ach ja, os.popen und subprocess.popen ist ein unterschied bei der Konsole, versuch mal beides.

Das wird nichts helfen wie cofi bereits meinte will der Threadersteller eigentlich nicht eine Shell-Starten sondern eher einen Terminal-Emulator. Und da gibt es unter Unices idR kein "Standardprogramm".

[Leonidas]

imho74, deine Unterscheidung ist komisch. Bei mir steht in ``$TERM`` ``xterm``, aber ich würde bei meinem GNOME-Desktiop eher erwarten dass ``gnome-terminal`` aufgeht. Ich denke ``$TERM`` ist nicht das, was du suchst.

[snafu]

Die Nutzung von ``x-terminal-emulator`` wäre wohl die bessere Wahl. Dies sollte dann auf den "richtigen" Emulator umleiten.

Aber huch, ich glaube das ist nur debianspezifisch. Vielleicht dann erst auf Existenz dieses Links testen und danach ``$TERM`` probieren. Keine Ahnung. Linux kann manchmal echt anstrengend sein. *scnr*

[imho74]

Naja, mir wäre es letztendlich egal, ob das Gnome-Terminal, Konsole, XTerm oder ein beliebig anderer Terminal-Emulator gestartet wird, hauptsache Terminal-Emulator.

Ich habe es jetzt aber geändert:

Code: Alles auswählen

        if os.name == 'posix':
            terminal = "/usr/bin/x-terminal-emulator"
            
        elif os.name == 'nt':
            terminal = "cmd.exe"
            
        else:
            pass
        
        os.system(terminal)

Wenn "x-terminal-emulator" nur Debian-spezifisch ist, wäre das blöd. Ich probiere es mal mit anderen Distributionen aus.

[snafu]

Bei mir steht in ``$TERM`` sinnigerweise nur ``linux``. ^^

Naja, wenn du einfach nur ein Terminal aufmachen willst, dann sollte ``xterm`` so gut wie immer klappen.

[Leonidas]

Am sinnvollsten wäre es x-terminal-emulator zu prüfen sowie dem User die Wahl zu lassen, etwa durch eine Konfigurationsoption.

[snafu]

Nochmal wegen dem ``x-terminal-emulator``: OpenSuse kann das wohl auch. Vielleicht einfach mal ein paar Distris mit dem Linknamen in die Suchmaschine eingeben. Ich würde halt sagen: ``x-terminal-emulator`` -> ``xterm`` -> Schade-Pech ;P

[imho74]

@Leonidas: Konfigurationsoption ist ein guter Vorschlag. Aber ich schau erstmal, wie weit ich überhaupt komme, bevor ich eine Konfigurationsoption implementiere.

@snafu: Leider habe ich keinen Mac zum testen, aber wenn ich das richtig sehe, müsste MacOS X bei

Code: Alles auswählen

if os.name == 'posix':

doch mit "Ja" antworten, und auf dem Mac müsste doch eine XTerm vorhanden sein...

Mit deinem Vorschlag ``x-terminal-emulator`` -> ``xterm`` -> ``Schade-Pech`` dürfte ich ja auch Mac-User abfangen, da der Mac bei erstem sagt "is nicht da", um dann "xterm" zu nehmen. Ebenso sollten sich dann ja auch Linux-Distributionen verhalten, bei denen es kein x-terminal-emulator gibt.

Ich werde das mal probieren...

[snafu]

Vermutlich. Hier tummeln sich aber auch ein paar Leute mit einem Mac rum. Vielleicht melden die sich noch. Dann hätte man da wohl etwas mehr Sicherheit.

[Leonidas]

Würde mich wundern da Mac OS X standardmäßig kein X11 mitbringt, warum dass es dann ein ``xterm`` hätte. Würde eher sagen, dass man in dem Fall ``Terminal.app`` nehmen würde.

[derdon]

Wobei zu beachten ist, dass Terminal.app nicht einfach über /usr/bin o.ä. aufzurufen ist. Für Temrinal.app lautet der Pfad:

Code: Alles auswählen

/Applications/Utilities/Terminal.app/Contents/MacOS/Terminal

Für xterm (wie Leonidas richtig gesagt hat, braucht man dafür X11, was nachinstalliert werden muss) lautet der Pfad wie folgt:

Code: Alles auswählen

/usr/X11/bin/xterm

x-terminal-emulator ist auf dem Mac nicht vorhanden; zumindest konnte ich es nicht finden. $TERM hat bei mir übrigens den Wert "xterm-256color", also nicht gerade hilfreich.

[Rebecca]

$TERM ist der Name des Termcap-Files, das verwendet wird.