come creare un'interfaccia a riga di comando o un interprete in python

Question

ragazzi. Ho visto alcune domande CLI qui, ma voglio ancora fare questa domanda per risposte più dettagliate.

Ho già sviluppato class1.py, class2.py, ecc. Con funzioni implementate all'interno di ogni classe. per esempio. Operator.py ha funzioni add, meno, time, devide. come posso costruire un'interfaccia a riga di comando per queste classi?

anche per questa CLI, è un ciclo infinito all'interno del main() per l'interazione?

E come può la CLI fornire un feedback come, suggerendo all'utente per l'operazione successiva o per immettere il comando right o digitare --help e controllare tutti i comandi disponibili. come le shell di Bash.

anche sembra che ci sia il modulo optparse da python. ci sono dei buoni, completi o campioni di alta qualità che mostrano come viene costruita una CLI? Vorrei cogliere questa occasione per imparare come scrivere un programma CLI.

quello che voglio è: ho già sviluppato diverse classi e anche una GUI per chiamare i metodi di queste classi. Ora voglio avere una CLI, come la GUI, per utilizzare queste classi. per esempio. Ho lezioni come CDContainer (con metodo come addCD, removeCD, etc), CD (con metodo come play, stop, pause), e ho una GUI che potrebbe essere interagita. Ora voglio avere una CLI, che sotto la bash, potrei eseguire questa CLI e chiamare createCDContainer, addCD, removeCD commands.

Se uso cmd,

class CDContainerCLI(cmd.Cmd): 

    def do_CDContainer(self, line): 
     print "create CD container" 

    def do_addcd(self, line): 
     print "add cd into the container" 

Come faccio ad aggiungere alcune opzioni qui? ad es., voglio aggiungere --track 3 --cdname thriller Penso che "--track 3 --cdname thriller" siano i 4 argomenti per la funzione addcd. come implementarlo?

Answer 1

Deriva da cmd.Cmd, sovrascrivendo i vari metodi necessari.

Answer 2

utilizzare il modulo cmd:

• Riferimento: Custom (interactive) shell with Python

Altri pacchetti

È inoltre possibile utilizzare diversi moduli ospitati presso PyPI che è costruito in cima al modulo cmd

• http://pypi.python.org/pypi/Custom%20Interactive%20Console/1.0

Answer 3

StackOverflow - How to write a shell in Python

Answer 4

io non sono sicuro di quello che stai cercando: sembra si vuole costruire una shell interattiva, ma anche menziona optparse, che è stato progettato per semplificare la creazione di un'interfaccia modulo che può essere eseguita dalla shell di sistema anziché fornire una shell in sé.

Sembra che tu voglia che il tuo modulo implementa la propria shell interattiva, ma forse vuoi anche avere alcuni comandi accessibili dalla riga di comando, ad es.chiamando lo your_script the_command --argument value --other-argument direttamente da bash o cosa avete. Questo è il tipo di cosa che lo scopo di fornire è optparse, ma è stato deprecato a favore di argparse. argparse si trova nella libreria standard di Python 2.7 e può essere installato nel modo standard (ad esempio come dipendenza del modulo, o mediante installazione separata tramite PyPI, ecc.) Per Python precedenti.

argparse rende relativamente semplice collegare specifiche opzioni o sottocomandi a punti di ingresso (ad esempio chiamate di funzione) nel codice. La documentazione è abbastanza dettagliata e merita una lettura approfondita se è probabile che si desideri creare alcune di queste interfacce. Per l'utilizzo avanzato puoi fare alcune cose interessanti e rendere il tuo codice un po 'più gestibile, creando uno custom action.

Answer 5

Penso che quello che sta chiedendo è come trattare facilmente con argomenti opzionali all'interno la shell interattiva, in modo che quando si utilizza il programma che sarà simile a questo:

$ myprogram 
(Cmd) addcd --track 3 --cdname thriller 

Così myprogram esecuzione apre il proprio prompt dei comandi, al quale possono essere impartiti comandi come addcd, insieme a argomenti opzionali, e quindi elaborati.

Il modo migliore per farlo, penso, sarebbe quello di utilizzare argparse insieme a cmd. Invece di analizzare sys.argv, il metodo parse_args può essere passato un elenco di stringhe. Quindi, qualcosa come qui di seguito:

def do_addcd(self, line): 
    parser = argparse.ArgumentParser(prog='addcd') 
    parser.add_argument('--track', type=int) 
    parser.add_argument('--cdname') 

    args = parser.parse_args(line.split()) 
    newcd = CD(args.track, args.cdname) 

Il problema di fare qualcosa di simile, come ho scoperto me stesso, cercando di fare esattamente questo genere di cose, è che parse_args tende a chiudere l'intero programma se si fornisce con il numero sbagliato di argomenti, tra gli altri errori. Il comportamento desiderato in questo caso d'uso sarebbe semplicemente tornare alla shell interattiva personalizzata, ma ciò non sarà facile senza una soluzione hacky o sottoclasse ArgumentParser e sostituendo parse_args.