Discussion :

[KINENVEU]

bonjour,

voila, je voudrais executer des commandes ms-dos a partir de python.

je fais par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
import os
cmd = "echo toto"
os.system(cmd)

mais si je veux en effectuer plusieurs et garder la fenetre MS-dos ouverte,
comment puis-je faire ?
un peu comme un "batch file" ou je mets une serie de commande et je fini par un 'pause'.
(je n'ai pas trouve le separateur de commande en Ms-dos)

une idee ?

merci.

[miawaw]

Dans l'invite de commande de W. si tu tapes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

start cmd /K file.bat

une nouvelle fenetre s'ouvre, les commandes dans file.bat sont executées et la fenêtre reste ouverte, prete à recevoir de nouvelles commandes.
Je sais plus comment à quel endroit du 'help' j'ai trouvé l'option '/K'. Si la fenêtre reste ouverte, ça doit être à cause du 'start'.

Dans python, il suffit donc d'écrire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
cmd= "start cmd /K file.bat"
os.system(cmd)

[KINENVEU]

merci miawaw pour ta reponse.

en fait, ce n'est pas ca que je veux faire. :-(
je voudrais pouvoir executer plusieurs instructions dans la meme fenetre.

- soit en utilisant un separateur de commande.
- soit avec un genre de fonction "hold" qui maintient la fenetre. (solution que je prefererai)

et je ne voudrais passer par des 'batchs' que si je n'ai pas d'autres solutions.

Par contre, l'option '/K', je ne connaissais pas,
et ca va m'etre utile.
merci.

[PauseKawa]

Bonjour,

C'est cela que tu recherche ?
Il te suffit d'adapter le code.

@+

[KINENVEU]

non, ce n'est pas cela que je cherche.

[miawaw]

Dans la documentation de python, on lit sur la page http://docs.python.org/library/subprocess.html:
The subprocess module allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes. This module intends to replace several other, older modules and functions, such as:
os.system
os.spawn*
os.popen*
popen2.*
commands.*

Mais je ne sais pas si ça resout le problème. On dirait que tu veux être capable d'introduire des commandes dans une console ouverte... Perso, je n'ai pas d'idées dsl.
En tapant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

os.system('cmd')

dans la console python, tu fais apparaitre l'invite de commande:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
>>> system('cmd')
Microsoft Windows XP blablabla
(C) blablabla blablabla
 
C:\Documents and Settings\Propriétaire>

mais je doute que ça soit ce que tu cherche. (on va y arriver)

[PauseKawa]

Bonsoir KINENVEU,

Dans un premier temps désolé pour le lien. Rien à voir avec ta question (multitâche off ).

Dans l'attente d'une réponse plus pro voici ce que j'ai a te proposer : Utiliser subprocess (stdout, stderr... ) pour faire un frontend avec tkinter.
En gros une fenêtre 'console' Tk.

pyconsole.py

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
# -*- coding: utf-8 -*-
#
#
#
from sys import version_info
import string
from subprocess import Popen, PIPE
 
if version_info[0] == 2:
    from Tkinter import *
else:
    from tkinter import *
 
class pyConsole(Tk):
    """ Fenêtre console """
    def __init__(self, width=80, fg='white', bg='black'):
        Tk.__init__(self)
        self.title("pyConsole 0.1")
        self.prompt='\n> '
        self.textconsole=Text(self, width=width, fg=fg, bg=bg, state=NORMAL, wrap=CHAR)
        scrollconsole = Scrollbar(self, command = self.textconsole)
        self.textconsole.configure(yscrollcommand = scrollconsole.set)
        self.textconsole.bind("<Return>", self.traite_Return)
        self.textconsole.bind("<KP_Enter>", self.traite_KP_Enter)
        self.textconsole.bind("<BackSpace>", self.traite_backspace)
        self.textconsole.pack(side=LEFT, fill=BOTH)
        scrollconsole.pack(side=RIGHT, fill=Y)
        self.textconsole.insert(END, self.prompt)
 
    """ Gestions EVENTS """
    def traite_KP_Enter(self, event):
        """ Gestion de KP_Enter """
        self.execute()
        self.textconsole.insert(END, self.prompt)
 
    def traite_Return(self, event):
        """ Gestion de Return. A corriger """
        self.execute()
        self.textconsole.insert(END, self.prompt)
 
    def traite_backspace(self, event):
        """ Gestion backspace. A corriger """
        cindex = self.getindex(CURRENT)
        print cindex
        print type(cindex)
        if int(cindex[1]) > 3:
            self.textconsole.delete("%s-0c" % INSERT, INSERT)
        else:
            nindex = str(cindex[0]) + '.0'
            self.textconsole.delete(nindex, END)
            self.textconsole.insert(END, self.prompt)
 
    """ Traitements """
    def clean(self):
        """ Traitement cls/clear """
        self.textconsole.delete(1.0, END)
        self.textconsole.insert(END, self.prompt)
 
    def quit(self):
        """ Traitement exit/quit """
        self.destroy()
 
    def getindex(self, index):
        return self.textconsole.index(index).split('.')
 
    def execute(self):
        """ A corriger """
        cindex = self.getindex(CURRENT)
        nindexs = str(cindex[0]) + '.0'
        nindexf = str(cindex[0])+'.end'
        commande = self.textconsole.get(nindexs, nindexf)[2:]
        self.traite(commande)
 
    def traite(self, commande):
        if commande == 'cls' or commande == 'clear': self.clean()
        elif commande.lower == 'exit' or commande == 'quit': self.quit()
        else:
            self.textconsole.insert(END, self.prompt)
            p = Popen([commande], shell=True,stdout=PIPE)
            retour = []
            for elems in p.stdout:
                self.textconsole.insert(END, elems)
                elems=elems.replace("\n","")
                retour.append(elems)
            return retour
 
    """ Appels externes """
    def insercmd(self, commande):
        retour = self.traite(commande)
        return retour
 
 
if __name__== '__main__':     
    fen=pyConsole(80, 'white', 'black')    
    fen.mainloop()

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
from pyconsole import pyConsole
pyc=pyConsole()
pyc.insercmd('dir')
# ou encore
retour = pyc.insercmd('dir')
print 'retour', retour

Et cela donne en console:

Python 2.6.4 (r264:75708, Oct 26 2009, 08:23:19) [MSC v.1500 32 bit (Intel)] on
win32
Type "help", "copyright", "credits" or "license" for more information.
>>> from pyconsole import pyConsole
>>> pyc = pyConsole()
>>> pyc.insercmd('dir')
[ blabla ]
>>> retour = pyc.insercmd('dir')

Tu te retrouve donc avec une fenêtre 'pseudo' dos qui te retourne stdin, stdout et stderr et est utilisable en direct.

C'est juste une idée mais chez moi le code marche.

@+

Edit : j'avais foiré mon copier/coller