Pycharm interactif de la console ne fonctionne pas

Il dépend de la façon dont vous exécuter le fichier python. Il ya beaucoup de façons de le faire que de l'intérieur pycharm (peut-être même trop).

Je devine ce que vous faites est en appuyant sur le triangle vert. Cela ne veut pas exécuter le fichier dans le même shell qui existe dans la "Console Python" de l'onglet en bas. Au lieu de cela, il donne naissance à un nouveau shell, exécute le fichier, et par défaut, ferme la coque lorsque le fichier est effectuée en cours d'exécution. Vous pouvez voir cette coquille de le faire dans le " Run " de l'onglet en bas. Il semblerait, d'après Shivendra de répondre qu'il y a peut être un moyen d'éviter de tuer le shell script sortie. Si c'est effectivement le cas, vous seriez à l'aide d'un terminal /shell qui reste dans le " Run "de l'onglet et pas l'un dans la "Console Python'.

Ceci est très similaire à ce qui se passe si vous utilisez de Débogage au lieu de l'Exécuter. Il donne naissance à un interprète, s'attache le débogueur, exécute le script, tue tout quand c'est bien fait. Cette vie dans le 'Debug'.

La façon la plus simple d'obtenir ce que vous avez à l'esprit serait d'exécuter le fichier dans le pré-existantes "Python Console', comme suit. Dans ce cas, le script est exécutée comme si elle était __main__, donc si vous avez un if __name__ == "__main__":, il serait évaluée à True et tout le code dans le si le bloc sera exécuté. (Plus sur cela plus tard, si vous ne savez pas ce qu'il est maintenant)

In[2]: dir()
Out[2]: 
['In',
 'Out',
 '_',
 '__',
 '___',
 '__builtin__',
 '__builtins__',
 '__doc__',
 '__name__',
 '__package__',
 '_dh',
 '_i',
 '_i1',
 '_i2',
 '_ih',
 '_ii',
 '_iii',
 '_oh',
 '_sh',
 'exit',
 'get_ipython',
 'quit',
 'sys']
In[3]: run -m conventions.iec60063
In[4]: dir()
Out[4]: 
['Decimal',
 'E12',
 'E24',
 'E3',
 'E6',
 'In',
 'Out',
 '_',
 '_3',
 '__',
 '___',
 '__builtin__',
 '__builtins__',
 '__doc__',
 '__loader__',
 '__name__',
 '__nonzero__',
 '__package__',
 '_dh',
 '_i',
 '_i1',
 '_i2',
 '_i3',
 '_i4',
 '_ih',
 '_ii',
 '_iii',
 '_oh',
 '_sh',
 'cap_ostrs',
 'elem',
 'exit',
 'gen_vals',
 'get_ipython',
 'get_series',
 'idx',
 'ind_ostrs',
 'quit',
 'res_ostrs',
 'sys',
 'zen_ostrs']

Ma manière préférée de "lancer" un fichier est de les importer à partir de l'intérieur de la "Python Shell' (IPython ou autre) lui-même et manuellement exécuter n'importe quel code d'initialisation doit être exécuté. Cela a l'avantage de ne pas trop polluer l'espace de noms et de présenter un environnement qui est beaucoup plus proche de ce que vous attendez si vous utilisez le script en tant que module (qui est l'endroit où pycharm et IPython et l'auto-complétion vraiment commencer à rembourser). Dans les deux méthodes, vous avez la possibilité d'attacher le débogueur 'Python Console interprète à l'aide de la "Attacher le Débogueur' icône à côté de l'interpréteur de commandes (le vert de bug).

Un court exemple est comme suit (dans la Console Python' onglet):

In[2]: dir()
Out[2]: 
['In',
 'Out',
 '_',
 '__',
 '___',
 '__builtin__',
 '__builtins__',
 '__doc__',
 '__name__',
 '__package__',
 '_dh',
 '_i',
 '_i1',
 '_i2',
 '_ih',
 '_ii',
 '_iii',
 '_oh',
 '_sh',
 'exit',
 'get_ipython',
 'quit',
 'sys']
In[3]: import conventions.iec60063
In[4]: dir()
Out[4]: 
['In',
 'Out',
 ... (all the same ones as before)
 'conventions',
 ... (all the same ones as before)
]

En essence, vous ne seriez pas en exécutant le fichier en tant que tel, cependant, de sorte que vous devez être conscient de ce que vous faites.

Lorsque vous exécutez un fichier python, le module pense que c'est __name__ est "__main__", et c'est l'origine de la if __name__ == "__main__": truc (ce qui est quelque chose que vous devriez vraiment regarder jusqu'au début du python processus d'apprentissage). Si vous essayez ensuite de suivre l'exécution du code, l'interprète exécute tout dans le module qui n'est pas une classe ou d'une fonction. Cela comprend la if __name__ == "__main__": condition que vous verrez dans de nombreux scripts python. Le contenu de la if bloc, n'est effectuée que si le script est exécuté par lui-même (ou en utilisant le module m dans IPython)

D'autre part, lors de l'importation d'un module, la même séquence d'exécution se produit, sauf pour le fait que if __name__ == "__main__": donnera des Faux et tout le code qui résident dans ce bloc ne sera pas appelé. Vous devez donc exécuter manuellement ce qui est dans le if __name__ == "__main__": bloc si vous en avez besoin. Un modèle commun pour simplifier la tâche est simplement d'avoir un minimum d'appel de fonction dans le bloc if (ou, si vous vous souciez arguments de ligne de commande, juste la poignée de ceux là), puis les mains de la majorité de l'exécution à celui d'un callable fonction:

def main():
    pass

if __name__ == "__main__":
    main()

Dans le cas où vous ensuite d'importer le module, mais ont besoin pour exécuter ce code, de toute façon, tout ce que vous devez faire est d'appeler la fonction main (). Dans l'exemple ci-dessus, ce que je ferais (si j'avais à exécuter du code lorsque le module "court") ressemblerait à quelque chose comme :

In[2]: import conventions.iec60063
In[3]: conventions.iec60063.main()

Pycharm a quelques autres plus exotiques les moyens de l'exécution de code (pour l'exécution de seulement un petit fragment d'un fichier), je n'en ai pas vraiment besoin, alors je ne sais pas trop comment ils avaient de travail.

OriginalL'auteur Chintalagiri Shashank