Eu apenas comecei com Python. Quando executo um arquivo de script python no Windows, a janela de saída aparece, mas desaparece instantaneamente. Eu preciso que fique lá para que eu possa analisar minha saída. Como posso mantê-lo aberto?

Você tem poucas opções:

1. Execute o programa a partir de um terminal já aberto. Abra um prompt de comando e digite:

   python myscript.py

   Para que isso funcione, você precisa do executável python no seu caminho. Basta verificar como editar variáveis ​​de ambiente no Windows e adicionar C:\PYTHON26(ou qualquer diretório em que você instalou o python).

   Quando o programa terminar, você retornará ao prompt de cmd em vez de fechar a janela.

2. Adicione código para aguardar no final do seu script. Para Python2, adicionando ...

   raw_input()

   ... no final do script, aguarda a Enterchave. Esse método é irritante porque você precisa modificar o script e precisa se lembrar de removê-lo quando terminar. Especialmente irritante ao testar os scripts de outras pessoas. Para Python3, use input().

3. Use um editor que faça uma pausa para você. Alguns editores preparados para python farão uma pausa automaticamente após a execução. Outros editores permitem que você configure a linha de comando usada para executar seu programa. Acho particularmente útil configurá-lo como " python -i myscript.py" ao executar. Isso leva você a um shell python após o final do programa, com o ambiente do programa carregado, para que você possa brincar ainda mais com as variáveis ​​e chamar funções e métodos.

cmd /ké a maneira típica de abrir qualquer aplicativo de console (não apenas Python) com uma janela de console que permanecerá após o fechamento do aplicativo. A maneira mais fácil de pensar em fazer isso é pressionar Win + R, digite cmd /ke arraste e solte o script que você deseja na caixa de diálogo Executar.

Inicie o script a partir da janela cmd já aberta ou, no final do script, adicione algo assim, no Python 2:

 raw_input("Press enter to exit ;)")

Ou, no Python 3:

input("Press enter to exit ;)")

Para manter sua janela aberta em caso de exceção (ainda, ao imprimir a exceção)

Python 2

if __name__ == '__main__':
    try:
        ## your code, typically one function call
    except Exception:
        import sys
        print sys.exc_info()[0]
        import traceback
        print traceback.format_exc()
        print "Press Enter to continue ..." 
        raw_input() 

Para manter a janela aberta em qualquer caso:

if __name__ == '__main__':
    try:
        ## your code, typically one function call
    except Exception:
        import sys
        print sys.exc_info()[0]
        import traceback
        print traceback.format_exc()
    finally:
        print "Press Enter to continue ..." 
        raw_input()

Python 3

Para o Python3, você precisará usar input()no lugar deraw_input() e, é claro, adaptar as printinstruções.

if __name__ == '__main__':
    try:
        ## your code, typically one function call
    except BaseException:
        import sys
        print(sys.exc_info()[0])
        import traceback
        print(traceback.format_exc())
        print("Press Enter to continue ...")
        input() 

Para manter a janela aberta em qualquer caso:

if __name__ == '__main__':
    try:
        ## your code, typically one function call
except BaseException:
    import sys
    print(sys.exc_info()[0])
    import traceback
    print(traceback.format_exc())
finally:
    print("Press Enter to continue ...")
    input()

você pode combinar as respostas antes: (para usuário do Notepad ++)

pressione F5 para executar o script atual e digite o comando:

cmd /k python -i "$(FULL_CURRENT_PATH)"

Dessa forma, você permanece no modo interativo após executar o script python do Notepad ++ e pode brincar com suas variáveis ​​e assim por diante :)

Crie um arquivo em lotes do Windows com estas 2 linhas:

python your-program.py

pause

No python 2, você pode fazer isso com: raw_input ()

>>print("Hello World!")    
>>raw_input('Waiting a key...')

No python 3, você pode fazer isso com: input ()

>>print("Hello world!")    
>>input('Waiting a key...')

Além disso, você pode fazê-lo com o time.sleep (time)

>>import time
>>print("The program will close in 5 seconds")
>>time.sleep(5)

Usando atexit, você pode pausar o programa exatamente quando ele sai. Se um erro / exceção for o motivo da saída, ele será pausado após a impressão do rastreamento de pilha.

import atexit

# Python 2 should use `raw_input` instead of `input`
atexit.register(input, 'Press Enter to continue...')

No meu programa, eu coloquei a chamada atexit.registerna exceptcláusula, para que ela só pause se algo der errado.

if __name__ == "__main__":
    try:
        something_that_may_fail()

    except:
        # Register the pause.
        import atexit
        atexit.register(input, 'Press Enter to continue...')

        raise # Reraise the exception.

Eu tive um problema parecido. Com o Notepad ++, eu costumava usar o comando: C:\Python27\python.exe "$(FULL_CURRENT_PATH)"que fechava a janela do cmd imediatamente após o término do código.
Agora estou usando o cmd /k c:\Python27\python.exe "$(FULL_CURRENT_PATH)"que mantém a janela do cmd aberta.

No Python 3

input('Press Enter to Exit...')

Vai fazer o truque.

Para manter a janela aberta, concordo com o Anurag e foi isso que fiz para manter minhas janelas abertas para pequenos programas do tipo cálculo.

Isso mostraria apenas um cursor sem texto:

raw_input() 

O próximo exemplo forneceria uma mensagem clara de que o programa foi concluído e não aguardava outro prompt de entrada no programa:

print('You have reached the end and the "raw_input()" function is keeping the window open') 
raw_input()

Nota!
(1) No python 3, não há raw_input () , apenas input () .
(2) Use aspas simples para indicar uma string; caso contrário, se você digitar dobros em torno de qualquer coisa, como "raw_input ()", ele achará que é uma função, variável, etc, e não texto.

Neste próximo exemplo, eu uso aspas duplas e não funcionará porque acha que há uma quebra nas aspas entre "a" e "função", mesmo quando você a lê, sua própria mente pode entender perfeitamente:

print("You have reached the end and the "input()" function is keeping the window open")
input()

Espero que isso ajude outras pessoas que podem estar começando e ainda não descobriram como o computador pensa ainda. Isso pode levar um tempo. : o)

Se você deseja executar seu script a partir de um atalho na área de trabalho, clique com o botão direito do mouse no arquivo python e selecione Send to|Desktop (create shortcut). Em seguida, clique com o botão direito do mouse no atalho e selecione Propriedades. Na guia Atalho, selecione a caixa de texto Destino: adicione-a cmd /k na frente do caminho e clique em OK. O atalho agora deve executar seu script sem fechar e você não precisa doinput('Hit enter to close')

Observe que, se você tiver mais de uma versão do python em sua máquina, adicione o nome do executável python necessário entre cmd / k e o caminho do scipt como este:

cmd /k python3 "C:\Users\<yourname>\Documents\your_scipt.py"

Além de inpute raw_input, você também pode usar um whileloop infinito , como este: while True: pass(Python 2.5 + / 3) ouwhile 1: pass (todas as versões do Python 2/3). Isso pode usar o poder da computação, no entanto.

Você também pode executar o programa na linha de comando. Digite pythonna linha de comando (Mac OS X Terminal) e deve dizer Python 3.?.?(Sua versão do Python). Ele não mostra a sua versão do Python, ou diz python: command not found, procure alterar os valores PATH (valores ambientais listados acima) / tipo C:\(Python folder\python.exe. Se for bem-sucedido, digite pythonou C:\(Python installation)\python.exee o diretório completo do seu programa.

Uma resposta muito tardia, mas eu criei um arquivo de lote do Windows chamado pythonbat.batcontendo o seguinte:

python.exe %1
@echo off
echo.
pause

e, em seguida, especificado pythonbat.batcomo o manipulador padrão para.py arquivos.

Agora, quando clico duas vezes em um .py arquivo no Explorador de Arquivos, ele abre uma nova janela do console, executa o script Python e faz uma pausa (permanece aberta), até eu pressionar qualquer tecla ...

Nenhuma alteração é necessária em nenhum script Python.

Ainda posso abrir uma janela do console e especificar python myscript.py se quero ...

(Acabei de perceber que @maurizio já postou esta resposta exata)

Você pode abrir o PowerShell e digitar "python". Após a importação do Python, você pode copiar e colar o código-fonte do seu editor de texto favorito para executar o código.

A janela não fecha.

Se você deseja manter a janela de cmd aberta E estar no diretório de arquivos em execução, isso funciona no Windows 10:

cmd /k cd /d $(CURRENT_DIRECTORY) && python $(FULL_CURRENT_PATH)

Encontrei que a solução no meu ambiente py3 no win10 é apenas executar cmd ou powershell como Administrador, e a saída permaneceria na mesma janela do console, qualquer outro tipo de comando python de execução do usuário faria com que o python abrisse uma nova janela do console.

1. Vá aqui download e instale o Notepad ++
2. Vá aqui, faça o download e instale o Python 2.7 e não 3.
3. Iniciar, execute o PowerShell. Digite o seguinte. [Environment]::SetEnvironmentVariable("Path", "$env:Path;C:\Python27", "User")
4. Feche o Powershell e reabra-o.
5. Faça um diretório para seus programas. scripts mkdir
6. Abra os scripts de CD do diretório
7. No Notepad ++, em um novo tipo de arquivo: print "hello world"
8. Salve o arquivo como hello.py
9. Volte ao PowerShell e verifique se você está no diretório certo digitando dir. Você deve ver seu arquivo hello.py lá.
10. No prompt do Powershell, digite: python hello.py

Um truque simples para manter a janela aberta:

counter = 0

While (True):

    If (counter == 0):

        # Code goes here

    counter += 1

O contador é para que o código não se repita.

A maneira mais simples:

import time

#Your code here
time.sleep(60)
#end of code (and console shut down)

isso deixará o código ativo por 1 minuto e depois fechá-lo.

No Windows 10, insira no início:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

Estranho, mas funciona para mim! (Juntamente com input () no final, é claro)