This code,
https://i.stack.imgur.com/E39QL.png
It opens the shell but as I fill the input fields, It closes without showing the output after creating its exe file.
main.py file,
https://i.stack.imgur.com/fKKTq.png
What can I do so that the shell remains visible after the code is completed?
The answer of a * b is shown so quickly that I can't even see the output and the shell closes.
Your problem is that the Python code exit with code 0 correctly and, consequently, the shell closes.
A solution could be adding a "press any key to exit" command at the end of your code. To do that you can use readchar as below. You can put it at the end of your code so when you click something, the shell closes. You also need to isntall it via pip install readchar
import readchar
print("Press Any Key To Exit")
k = readchar.readchar()
I am trying to write a program that will run when my raspberry pi starts up and will allow me to immediately begin typing things with my keyboard and have it be picked up by the program. I don't want to have to manually start the program when the pi starts. I need to use curses (or a similar unbuffered keyboard input library) because I display what I am typing on a 2x16 I2C LCD, but I also need everything that I am typing to be recorded to a text file.
Right now, I am auto-starting the program at boot by putting a line in rc.local. This works, and the I2C display is correctly showing program output, but it does not respond to keyboard input, and the keyboard input is instead displayed (when I connect the pie to a screen, the goal is to run headless) on an odd console layout that exits when I press enter and says -bash: 'whatever I just typed' command not found.
I have already tried:
Setting a timer at the beginning of the program to wait until the pi has fully booted before initializing the curses window and keyboard capture
Creating a seperate python program to wait until the pi has fully booted and then running the main script by importing it
Neither of these methods works though, I get the same problem with slight differences.
To be clear, the program works flawlessly if I run it manually from the command line. But there is no keyboard input to the program (or at least not where it is supposed to be inputted) when I autostart the script with rc.local.
My code:
#!/usr/bin/python
import I2C_LCD_driver, datetime, sys
from time import *
from subprocess import call
mylcd = I2C_LCD_driver.lcd()
for x in range(30): #waits for raspberry pi to boot up
mylcd.lcd_display_string("Booting Up: "+str(x), 1)
sleep(1)
import curses
key = curses.initscr()
curses.cbreak()
curses.noecho()
key.keypad(1)
key.nodelay(1)
escape=0
while escape==0:
#variable initialization
while 1:
k=key.getch()
if k>-1: #runs when you hit any key. getch() returns -1 until a key is pressed
if k==27: #exits the program when you hit Esc
break
elif k==269:
# a couple other special Function key cases are here
else:
inpt=chr(k)
mylcd.lcd_display_string(inpt,2,step) #writes the last character to the display
#some more code that handles writing the text to the LCD, which works flawlessly when run manually.
file.write("%s\r\n" % entry)
file.close()
mylcd.lcd_display_string("Saved ",2)
mylcd.lcd_display_string("F1 New F2 PwrOff",1)
while 1:
k=key.getch()
if k>-1:
if k==265: #do it again! with F1
mylcd.lcd_clear()
break
elif k==266: #shut down with F2
escape=1
break
curses.nocbreak()
key.keypad(0)
curses.echo()
curses.endwin()
call("sudo shutdown -h now", shell=True)
The line that I have in /etc/rc.local is as follows if that is important:
sudo python3 journal.py &
and it is followed by the 'exit 0' line.
Thanks for any help you can provide. I know this is a very specific problem and will be tedious to reproduce, but if anyone knows anything about autostarting functions I would be very appreciative of any tips.
Ok, literally all I had to do (which I did find after some more research on stackexchange, this is the thread that contained the answer I was looking for) was run my program from ~/.bashrc instead of /etc/rc.local. This method works perfectly, exactly what I wanted.
This should be because of how you called the program:
python3 journal.py &
You may want to check out JOB CONTROL of bash (or your shell) man page:
Only foreground
processes are allowed to read from ... the terminal. Background processes which
attempt to read from ... the
terminal are sent a SIGTTIN ... signal by the kernel's terminal
driver, which, unless caught, suspends the process.
In short, once curses (or anything for that matter) try to read from stdin your process is likely stopped (after it may have already written to your display). Keep it in the foreground to be able to have it use stdin (and by extension keyboard).
Side note: Not sure about distro and details of implementation of rc.local in your case, but aren't init scripts normally run with uid/gid 0 already (without wrapping individual calls through sudo?)
I am a beginner and wrote the following in Python 3.4.3 using Wing IDE 1.0.1
sidea = float( input ( " eerste rechtshoekzijde:") )
sideb= float ( input ( "tweede rechtshoekzijde:") )
tussenstap= sidea *sidea + sideb * sideb
print( int( tussenstap))
sidec= int( tussenstap **0.5)
print("de lengte van de lange zijde is", sidec)
In the IDE environment it works just fine. But when I double click on the program after saving it does not work. I can enter variable 1 and variable 2, but when I press Enter, it shows the answer in a split second and the screen disappears.
It is configured well, so there is no problem with version 2 on one hand en 3 on the other hand. Can someone please help me?
it shows the answer in a split second and the screen disappears.
That’s because when you double-click the .py file in Windows, a new console application running your Python script is launched. And that console application terminates as soon as your script is done doing whatever it does.
So in your case, it asks for input, and then prints something; and then it’s done doing things. So the Python process terminates and the window disappears.
A very common solution to this “problem” is to ask for some final input at the end of your script:
print("de lengte van de lange zijde is", sidec)
input('Press enter to quit this application')
So now, we’re just asking the user to press enter, and only then the script is done doing things and the window may disappear.
Another solution would be to simply launch your script inside an existing console application, so that when the Python process terminates, the window returns to your console instead of closing itself. To do this, launch the Windows command line, e.g. by starting cmd from the Run-window (WinKey + R), and then typing python myscript.py. This will launch the myscript.py in the current directory, without terminating the console process after the script finishes.
Just open a console and run the program with the following command:
python
By doing that the console won't close right after the program finishes
This question already has answers here:
How to keep a Python script output window open?
(27 answers)
Closed 9 years ago.
I am trying to learn python and for that purpose i made a simple addition program using python 2.7.3
print("Enter two Numbers\n")
a = int(raw_input('A='))
b = int(raw_input('B='))
c=a+b
print ('C= %s' %c)
i saved the file as add.py and when i double click and run it;the program run and exits instantenously without showing answer.
Then i tried code of this question Simple addition calculator in python it accepts user inputs but after entering both numbers the python exits with out showing answer.
Any suggestions for the above code. Advance thanks for the help
add an empty raw_input() at the end to pause until you press Enter
print("Enter two Numbers\n")
a = int(raw_input('A='))
b = int(raw_input('B='))
c=a+b
print ('C= %s' %c)
raw_input() # waits for you to press enter
Alternatively run it from IDLE, command line, or whichever editor you use.
It's exiting because you're not telling the interpreter to pause at any moment after printing the results. The program itself works. I recommend running it directly in the terminal/command line window like so:
Alternatively, you could write:
import time
print("Enter two Numbers\n")
a = int(raw_input('A='))
b = int(raw_input('B='))
c=a+b
print ('C= %s' %c)
time.sleep(3.0) #pause for 3 seconds
Or you can just add another raw_input() at the end of your code so that it waits for input (at which point the user will type something and nothing will happen to their input data).
Run your file from the command line. This way you can see exceptions.
Execute cmd than in the "dos box" type:
python myfile.py
Or on Windows likley just:
myfile.py
I have just started with Python. When I execute a python script file on Windows, the output window appears but instantaneously goes away. I need it to stay there so I can analyze my output. How can I keep it open?
You have a few options:
Run the program from an already-open terminal. Open a command prompt and type:
python myscript.py
For that to work you need the python executable in your path. Just check on how to edit environment variables on Windows, and add C:\PYTHON26 (or whatever directory you installed python to).
When the program ends, it'll drop you back to the cmd prompt instead of closing the window.
Add code to wait at the end of your script. For Python2, adding ...
raw_input()
... at the end of the script makes it wait for the Enter key. That method is annoying because you have to modify the script, and have to remember removing it when you're done. Specially annoying when testing other people's scripts. For Python3, use input().
Use an editor that pauses for you. Some editors prepared for python will automatically pause for you after execution. Other editors allow you to configure the command line it uses to run your program. I find it particularly useful to configure it as "python -i myscript.py" when running. That drops you to a python shell after the end of the program, with the program environment loaded, so you may further play with the variables and call functions and methods.
cmd /k is the typical way to open any console application (not only Python) with a console window that will remain after the application closes. The easiest way I can think to do that, is to press Win+R, type cmd /k and then drag&drop the script you want to the Run dialog.
Start the script from an already open cmd window or
at the end of the script add something like this, in Python 2:
raw_input("Press enter to exit;")
Or, in Python 3:
input("Press enter to exit;")
To keep your window open in case of exception (yet, while printing the exception)
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()
To keep the window open in any case:
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
For Python3 you'll have to use input() in place of raw_input(), and of course adapt the print statements.
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()
To keep the window open in any case:
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()
you can combine the answers before: (for Notepad++ User)
press F5 to run current script and type in command:
cmd /k python -i "$(FULL_CURRENT_PATH)"
in this way you stay in interactive mode after executing your Notepad++ python script and you are able to play around with your variables and so on :)
Create a Windows batch file with these 2 lines:
python your-program.py
pause
Using atexit, you can pause the program right when it exits. If an error/exception is the reason for the exit, it will pause after printing the stacktrace.
import atexit
# Python 2 should use `raw_input` instead of `input`
atexit.register(input, 'Press Enter to continue...')
In my program, I put the call to atexit.register in the except clause, so that it will only pause if something went wrong.
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.
In python 2 you can do it with: raw_input()
>>print("Hello World!")
>>raw_input('Waiting a key...')
In python 3 you can do it with: input()
>>print("Hello world!")
>>input('Waiting a key...')
Also, you can do it with the time.sleep(time)
>>import time
>>print("The program will close in 5 seconds")
>>time.sleep(5)
On Python 3
input('Press Enter to Exit...')
Will do the trick.
You can just write
input()
at the end of your code
therefore when you run you script it will wait for you to enter something
{ENTER for example}
I had a similar problem. With Notepad++ I used to use the command : C:\Python27\python.exe "$(FULL_CURRENT_PATH)" which closed the cmd window immediately after the code terminated.
Now I am using cmd /k c:\Python27\python.exe "$(FULL_CURRENT_PATH)" which keeps the cmd window open.
To just keep the window open I agree with Anurag and this is what I did to keep my windows open for short little calculation type programs.
This would just show a cursor with no text:
raw_input()
This next example would give you a clear message that the program is done and not waiting on another input prompt within the program:
print('You have reached the end and the "raw_input()" function is keeping the window open')
raw_input()
Note!
(1) In python 3, there is no raw_input(), just
input().
(2) Use single quotes to indicate a string; otherwise if you type doubles around anything, such as
"raw_input()", it will think it is a function, variable, etc, and not text.
In this next example, I use double quotes and it won't work because it thinks there is a break in the quotes between "the" and "function" even though when you read it, your own mind can make perfect sense of it:
print("You have reached the end and the "input()" function is keeping the window open")
input()
Hopefully this helps others who might be starting out and still haven't figured out how the computer thinks yet. It can take a while. :o)
If you want to run your script from a desktop shortcut, right click your python file and select Send to|Desktop (create shortcut). Then right click the shortcut and select Properties. On the Shortcut tab select the Target: text box and add cmd /k in front of the path and click OK. The shortcut should now run your script without closing and you don't need the input('Hit enter to close')
Note, if you have more than one version of python on your machine, add the name of the required python executable between cmd /k and the scipt path like this:
cmd /k python3 "C:\Users\<yourname>\Documents\your_scipt.py"
Apart from input and raw_input, you could also use an infinite while loop, like this:
while True: pass (Python 2.5+/3) or while 1: pass (all versions of Python 2/3). This might use computing power, though.
You could also run the program from the command line. Type python into the command line (Mac OS X Terminal) and it should say Python 3.?.? (Your Python version) It it does not show your Python version, or says python: command not found, look into changing PATH values (enviromentl values, listed above)/type C:\(Python folder\python.exe. If that is successful, type python or C:\(Python installation)\python.exe and the full directory of your program.
A very belated answer, but I created a Windows Batch file called pythonbat.bat containing the following:
python.exe %1
#echo off
echo.
pause
and then specified pythonbat.bat as the default handler for .py files.
Now, when I double-click a .py file in File Explorer, it opens a new console window, runs the Python script and then pauses (remains open), until I press any key...
No changes required to any Python scripts.
I can still open a console window and specify python myscript.py if I want to...
(I just noticed #maurizio already posted this exact answer)
If you want to stay cmd-window open AND be in running-file directory this works at Windows 10:
cmd /k cd /d $(CURRENT_DIRECTORY) && python $(FULL_CURRENT_PATH)
I found the solution on my py3 enviroment at win10 is just run cmd or powershell as Administrator,and the output would stay at the same console window,any other type of user run python command would cause python to open a new console window.
The simplest way:
your_code()
while True:
pass
When you open the window it doesn't close until you close the prompt.
`import sys,traceback
sys.exc_info()[0]
traceback.format_exc()
print("Press Enter to exit ...")
input()`
simply write the above code after your actual code. for eg. am taking input from user and print on console hence my code will be look like this -->
`import sys,traceback
nam=input("enter your name:")
print("your name is:-{}".format(nam)) #here all my actual working is done
sys.exc_info()[0]
traceback.format_exc()
print("Press Enter to exit ...")
input()`
Try this,
import sys
stat='idlelib' in sys.modules
if stat==False:
input()
This will only stop console window, not the IDLE.
You can launch python with the -i option or set the environment variable PYTHONINSPECT=x. From the docs:
inspect interactively after running script; forces a prompt even
if stdin does not appear to be a terminal; also PYTHONINSPECT=x
So when your script crashes or finishes, you'll get a python prompt and your window will not close.
Create a function like dontClose() or something with a while loop:
import time
def dontClose():
n = 1
while n > 0:
n += 1
time.sleep(n)
then run the function after your code. for e.g.:
print("Hello, World!")
dontClose()
Go here and download and install Notepad++
Go here and download and install Python 2.7 not 3.
Start, Run Powershell. Enter the following. [Environment]::SetEnvironmentVariable("Path", "$env:Path;C:\Python27", "User")
Close Powershell and reopen it.
Make a directory for your programs. mkdir scripts
Open that directory cd scripts
In Notepad++, in a new file type: print "hello world"
Save the file as hello.py
Go back to powershell and make sure you are in the right directory by typing dir. You should see your file hello.py there.
At the Powershell prompt type: python hello.py
On windows 10 insert at beggining this:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
Strange, but it work for me!(Together with input() at the end, of course)
You can open PowerShell and type "python".
After Python has been imported, you can copy paste the source code from your favourite text-editor to run the code.
The window won't close.
A simple hack to keep the window open:
counter = 0
While (True):
If (counter == 0):
# Code goes here
counter += 1
The counter is so the code won’t repeat itself.
The simplest way:
import time
#Your code here
time.sleep(60)
#end of code (and console shut down)
this will leave the code up for 1 minute then close it.