I am using iPython notebook, with the %%debug command.
My code performs a loop, in which I set some break point.
Now I can't seem to stop the loop with 'CTRL+C' (works in the regular ipython).
For example, let's say I have some loop with an ipdb.set_trace() inside. Now if I hit the 'C' key the loop continues to the ipdb.set_trace(), with no option from the user the exit the loop with 'CTRL+D/C'.
How can I exit such a loop?
You can write exit() to quit debug mode.
you can use "ctrl+d" to delete the cell..
or to quit the debug mode just do exit()
note: it is not recommended to delete the cell if there is importent code
Related
I debugging in PyCharm.
I insert a breakpoint at the line:
p_result = input('Who will win: ')
Now usually the debugger stops without executing the line where the breakpoint is. However this time I have to make an input before the thread is suspended.
from os.path import join
string=" Congratulations, you are about to embark upon one of life’s "
path=r"C:\Users\Nord.Kind\Desktop"
file="test.txt"
quit()
# This should not execute, but it does!!
with open(join(path,file),"w")as wfile:
wfile.write(string)
wfile.close()
In the above code example the code still executes the write in file command, even though its after a quit.
The same behavious occures when I use exit.
I am using Spyder 3.6
Also the kernel restarts each time I use exit or quit.
Any help?
(Spyder maintainer here) Your question contains this comment:
Also the kernel restarts each time I use exit or quit.
That's the behavior of the IPython kernel we use as a backend to execute users code. Those commands kill the kernel and that forces a kernel restart to maintain its associated console active. I'm afraid there's nothing you can do about it.
Note: The same happens in the Jupyter notebook.
One way is to use sys.exit() in lieu of quit()
import sys
... # code that executes
sys.exit()
... # this code won't execute
However, as noted by #AranFey in the comments, your code will throw an error if it attempts to execute the last part where the variable read is not defined.
You can use SystemExit:
# Code that will run
raise SystemExit
# Code that will not run
sys.exit() also raises this error but this doesn't require importing sys.
My Python try/except loop does not seem to trigger a keyboard interrupt when Ctrl + C is pressed while debugging my code in PyCharm. (The same issue occurs when using Ctrl + C while running the program, but not in the PyCharm Python console.)
My code look like this:
try:
while loop:
print("busy")
except KeyboardInterrupt:
exit()
The full code can be viewed here. The code above produces the same error.
I know this is an old question, but I ran into the same problem and think there's an easier solution:
In PyCharm go to "Run"/"Edit Configurations" and check "Emulate terminal in output console".
PyCharm now accepts keyboard interrupts (make sure the console is focused).
Tested on:
PyCharm 2019.1 (Community Edition)
From your screen shot it appears that you are running this code in an IDE. The thing about IDEs is that they are not quite the same as running normally, especially when it comes to handling of keyboard characters. The way you press ctrl-c, your IDE thinks you want to copy text. The python program never sees the character. Pehaps it brings up a separate window when running? Then you would select that window before ctrl-c.
PyCharm's Python Console raises the exception console_thrift.KeyboardInterruptException on Ctrl-C instead of KeyboardInterrupt. The exception console_thrift.KeyboardInterruptException is not a subclass of KeyboardInterrupt, therefore not caught by the line except KeyboardInterrupt.
Adding the following lines would make your script compatible with PyCharm.
try:
from console_thrift import KeyboardInterruptException as KeyboardInterrupt
except ImportError:
pass
This would not break compatibility with running the script in a terminal, or other IDE, like IDLE or Spyder, since the module console_thrift is found only within PyCharm.
If that comment doesn't solve your problem, (from #tdelaney) you need to have your shell window focused (meaning you've clicked on it when the program is running.) and then you can use Control+C
You can also use PyCharm's Python console and use Ctrl + C, if you catch the exception that PyCharm raises when Ctrl + C is pressed. I wrote a short function below called is_keyboard_interrupt that tells you whether the exception is KeyboardInterrupt, including PyCharm's. If it is not, simply re-raise it. I paste a simplified version of the code below.
When it is run:
type 'help' and press Enter to repeat the loop.
type anything else and press Enter to check that ValueError is handled properly.
Press Ctrl + C to check that KeyboardInterrupt is caught, including in PyCharm's python console.
Note: This doesn't work with PyCharm's debugger console (the one invoked by "Debug" rather than "Run"), but there the need for Ctrl + C is less because you can simply press the pause button.
I also put this on my Gist where I may make updates: https://gist.github.com/yulkang/14da861b271576a9eb1fa0f905351b97
def is_keyboard_interrupt(exception):
# The second condition is necessary for it to work with the stop button
# in PyCharm Python console.
return (type(exception) is KeyboardInterrupt
or type(exception).__name__ == 'KeyboardInterruptException')
try:
def print_help():
print("To exit type exit or Ctrl + c can be used at any time")
print_help()
while True:
task = input("What do you want to do? Type \"help\" for help:- ")
if task == 'help':
print_help()
else:
print("Invalid input.")
# to check that ValueError is handled separately
raise ValueError()
except Exception as ex:
try:
# Catch all exceptions and test if it is KeyboardInterrupt, native or
# PyCharm's.
if not is_keyboard_interrupt(ex):
raise ex
print('KeyboardInterrupt caught as expected.')
print('Exception type: %s' % type(ex).__name__)
exit()
except ValueError:
print('ValueError!')
Here is working normally, since i put a variable "x" in your code and i use tabs instead spaces.
try:
def help():
print("Help.")
def doStuff():
print("Doing Stuff")
while True:
x = int(input())
if x == 1:
help()
elif x == 2:
doStuff()
else:
exit()
except KeyboardInterrupt:
exit()
Try shift + control + C. It worked for me.
Make sure the window is selected when you press ctrl+c. I just ran your program in IDLE and it worked perfectly for me.
One possible reason if <Strg+C> does not stop the program:
When a text is marked in the shell, <Strg+C> is interpreted as "copy the marked text to clipboard".
Just unmark the text and press <Strg+C> again.
I run the following code in SublimeREPL:
while(True):
a = raw_input()
print a
How do I stop input when this is running? Ctrl+C, Ctlr+D, or Ctrl+Z don't seem to work like they do in a terminal.
You have to do ctrl+break or ctrl+space to break the infinite recursion and abort the program
I am running command-line Python scripts from the Windows taskbar by having a shortcut pointing to the Python interpreter with the actual script as a parameter.
After the script has been processed, the interpreter terminates and the output window is closed which makes it impossible to read script output.
What is the most straightforward way to keep the interpreter window open until any key is pressed?
In batch files, one can end the script with pause. The closest thing to this I found in python is raw_input() which is sub-optimal because it requires pressing the return key (instead of any key).
One way is to leave a raw_input() at the end so the script waits for you to press Enter before it terminates.
Try os.system("pause") — I used it and it worked for me.
Make sure to include import os at the top of your script.
There's no need to wait for input before closing, just change your command like so:
cmd /K python <script>
The /K switch will execute the command that follows, but leave the command interpreter window open, in contrast to /C, which executes and then closes.
The best option: os.system('pause') <-- this will actually display a message saying 'press any key to continue' whereas adding just raw_input('') will print no message, just the cursor will be available.
not related to answer:
os.system("some cmd command") is a really great command as the command can execute any batch file/cmd commands.
One way is to leave a raw_input() at the end so the script waits for you to press enter before it terminates.
The advantage of using raw_input() instead of msvcrt.* stuff is that the former is a part of standard Python (i.e. absolutely cross-platform). This also means that the script window will be alive after double-clicking on the script file icon, without the need to do
cmd /K python <script>
On Windows you can use the msvcrt module.
msvcrt.kbhit()
Return True if a keypress is waiting to be read.
msvcrt.getch()
Read a keypress and return the resulting character as a byte string. Nothing is echoed to the console. This call will block if a keypress is not already available, but will not wait for Enter to be pressed. If the pressed key was a special function key, this will return '\000' or '\xe0'; the next call will return the keycode. The Control-C keypress cannot be read with this function.
If you want it to also work on Unix-like systems you can try this solution using the termios and fcntl modules.
As to the "problem" of what key to press to close it, I (and thousands of others, I'm sure) simply use input("Press Enter to close").
There's a simple way to do this, you can use keyboard module's wait function. For example, you can do:
import keyboard
print("things before the pause")
keyboard.wait("esc") # esc is just an example, you can obviously put every key you want
print("things after the pause")
Getting python to read a single character from the terminal in an unbuffered manner is a little bit tricky, but here's a recipe that'll do it:
Recipe 134892: getch()-like unbuffered character reading from stdin on both Windows and Unix (Python)
On Windows 10 insert at beggining this:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
Strange, but it works for me! (Together with input() at the end, of course)
An external WConio module can help here: http://newcenturycomputers.net/projects/wconio.html
import WConio
WConio.getch()
import pdb
pdb.debug()
This is used to debug the script. Should be useful to break also.
If you type
input("")
It will wait for them to press any button then it will continue. Also you can put text between the quotes.