Comment faire pour déterminer si Python script a été exécuté via la ligne de commande?

Si vous êtes en cours d'exécution sans un terminal, comme lorsque vous cliquez sur "Exécuter" dans Nautilus, vous pouvez simplement vérifier si il est attaché à un ats:

import sys
if sys.stdin.isatty():
    # running interactively
    print "running interactively"
else:
    with open('output','w') as f:
        f.write("running in the background!\n")

Mais, comme ThomasK points, vous semblez faire allusion à l'exécuter dans un terminal qui se ferme juste après la fin du programme. Je pense qu'il n'y a aucun moyen de faire ce que vous voulez sans solution de contournement; le programme est en cours d'exécution dans un shell et attaché à un terminal. La décision de quitter immédiatement se fait juste après avoir fini avec les infos qui n'ont pas facilement disponibles (les paramètres passés à l'exécution de l'interpréteur ou un terminal).

Vous pouvez aller sur en examinant le processus parent d'informations et de détecter les différences entre les deux types d'invocations, mais c'est probablement pas la peine dans la plupart des cas. Avez-vous pensé à l'ajout d'un paramètre de ligne de commande de votre script (pensez --interactive)?

Cette opération est généralement effectuée manuellement/, je ne pense pas qu'il y est une manière automatique à faire ce qui fonctionne pour tous les cas.

Vous devez ajouter un --pause argument au script qui ne l'invite pour une touche à la fin.

Lorsque le script est invoqué à partir d'une ligne de commande à la main, puis l'utilisateur peut ajouter --pause si vous le souhaitez, mais par défaut, il n'y aura pas d'attente.

Lorsque le script est lancé à partir d'une icône, les arguments de l'icône devrait inclure la --pause, de sorte qu'il y a une attente. Malheureusement, vous devrez soit le document de l'utilisation de cette option afin que l'utilisateur sache qu'il doit être ajouté lors de la création d'une icône ou d'autre, de fournir une icône de la fonction de création dans votre script qui fonctionne pour votre système d'exploitation.

Je crois que cela PEUT être fait. Au moins, ici, est de savoir comment je l'ai eu à travailler dans Python 2.7 sous Ubuntu 14.04:

#!/usr/bin/env python
import os, psutil

# do stuff here

if psutil.Process(os.getpid()).parent.name == 'gnome-terminal':
    raw_input("Press enter to close...")

Note que, dans Ubuntu 14 avec l'environnement de bureau Gnome (aka Nautilus) -- vous pourriez avoir besoin pour ce faire:

• à partir d'une fenêtre Nautilus (le navigateur de fichiers), sélectionnez Modifier dans le menu->Préférences(item), puis de Comportement(onglet)->fichier Exécutable des Fichiers Texte(article)->Demander à Chaque Fois(à la radio).
• chmod votre script exécutable, ou dans une fenêtre Nautilus (le navigateur de fichiers) -- clic droit sur le fichier->Propriétés(point) alors les Permissions(onglet)->Execute:Autoriser l'exécution du fichier comme programme(case à cocher)
• double-cliquez sur votre fichier. Si vous sélectionnez "Exécuter dans un Terminal", vous devriez voir le "Type d'entrée pour fermer..." invite de commandes.
• maintenant, essayez à partir d'une invite bash; vous ne devriez PAS voir l'invite du système.

Pour voir comment cela fonctionne, vous pouvez jouer avec ce (basé sur la réponse de @EduardoIvanec):

#!/usr/bin/env python
import os
import sys
import psutil

def parent_list(proc=None, indent=0):
    if not proc:
        proc = psutil.Process(os.getpid())
    pid = proc.pid
    name = proc.name
    pad = " " * indent
    s = "{0}{1:5d} {2:s}".format(pad, pid, name)
    parent = proc.parent
    if parent:
        s += "\n" + parent_list(parent, indent+1)
    return s

def invoked_from_bash_cmdline():
    return psutil.Process(os.getpid()).parent.name == "bash"

def invoked_as_run_in_terminal():
    return psutil.Process(os.getpid()).parent.name == "gnome-terminal"

def invoked_as_run():
    return psutil.Process(os.getpid()).parent.name == "init"


if sys.stdin.isatty():
    print "running interactively"
    print parent_list()
    if invoked_as_run_in_terminal():
        raw_input("Type enter to close...")

else:
    with open('output','w') as f:
        f.write("running in the background!\n")
        f.write("parent list:\n")
        f.write(parent_list())

Bien, la façon la plus simple que j'ai trouvé et fait a été de simplement exécuter le programme en ligne de commande, même si elle avait couru en Python IDLE.

exist = lambda x: os.path.exists(x)    ## Doesn't matter

if __name__ == '__main__':

    fname = "SomeRandomFileName"    ## Random default file name

    if exist(fname)==False:         ## exist() is a pre-defined lambda function
        jot(fname)                  ## jot() is a function that creates a blank file
        os.system('start YourProgram.py')    ## << Insert your program name here
        os.system('exit'); sys.exit()   ## Exits current shell (Either IDLE or CMD)

    os.system('color a')            ## Makes it look cool! :p
    main()                          ## Runs your code
    os.system("del %s" % fname)     ## Deletes file name for next time

Ajoutez à cela le fond de votre script, et, une fois couru à partir soit d'INACTIVITÉ ou de l'Invite de Commande, il va créer un fichier, exécutez de nouveau le programme dans le CMD, et sort de la première instance.
Espérons que ça aide! 🙂

J'ai aussi eu cette question et, pour moi, la meilleure solution est de définir une variable d'environnement dans mon IDE (PyCharm) et de vérifier si cette variable existe pour savoir si le script est exécuté soit via la ligne de commande ou via l'IDE.

Pour définir une variable d'environnement dans PyCharm vérifier:
Comment définir des variables d'environnement dans PyCharm?

Exemple de code (variable d'environnement: RUNNING_PYCHARM = True):

import os

# The script is being executed via the command line
if not("RUNNING_PYCHARM" in os.environ):
    raw_input("Press enter to close.")

J'espère que cela fonctionne pour vous.