68

I'm running my Python program and have a point where it would be useful to jump in and see what's going on, and then step out again. Sort of like a temporary console mode.

In Matlab, I'd use the keyboard command to do this, but I'm not sure what the command is in python.

Is there a way to do this?

For instance:

for thing in set_of_things:
    enter_interactive_mode_here()
    do_stuff_to(thing)

When enter_interactive_mode() calls, I'd like to go there, look around, and then leave and have the program continue running.

Richard
  • 56,349
  • 34
  • 180
  • 251

7 Answers7

71

code.interact() seems to work somehow:

>>> import code
>>> def foo():
...     a = 10
...     code.interact(local=locals())
...     return a
... 
>>> foo()
Python 3.6.5 (default, Apr  1 2018, 05:46:30) 
[GCC 7.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> a
10

Ctrl+Z returns to the "main" interpreter.

You can read the locals, but modifying them doesn't seem to work this way.

Kos
  • 70,399
  • 25
  • 169
  • 233
  • In IDLE, since Ctrl+Z returns to the main interpreter instead of the program, this doesn't really work any better than sys.exit(). – Noumenon Jul 12 '15 at 15:15
  • Another answer has an example with code.InteractiveConsole.interact() which seems to work better - it uses readline and has tab-completion. ( https://stackoverflow.com/questions/50917938/enabling-console-features-with-code-interact ). Ctrl+D exits the interactive session. – HKOB Aug 05 '20 at 09:21
  • `CTRL-Z` puts the job to the background – wsdzbm Nov 22 '21 at 13:55
64
python -i myapp.py

This will execute myapp.py and drop you in the interactive shell. From there you can execute functions and check their output, with the whole environment (imports, etc.) of myapp.py loaded.

For something more sophisticated - it would be better to use a debugger like pdb, setting a breakpoint. Also, most IDEs (PyDev, PyCharm, Komodo...) have graphical debuggers.

Emil Ivanov
  • 37,300
  • 12
  • 75
  • 90
  • 5
    I'm afraid this doesn't answer my question. This drops to an interactive mode after "myapp.py" finishes executing; I would like to enter an interactive mode during the exeuction of "myapp.py". – Richard Nov 17 '12 at 17:10
  • 1
    You're options are either using a debugger, or creating a script that will execute up to the point you are interested. From there on you can invoke a function to "resume" your program. – Emil Ivanov Nov 17 '12 at 17:12
19

I use pdb for this purpose. I realize Emil already mentioned this in his answer, but he did not include an example or elaborate on why it answers your question.

for thing in set_of_things:
    import pdb; pdb.set_trace()
    do_stuff_to(thing)

You can read and set variables by starting your command with an exclamation point. You can also move up and down the stack (commands u and d), which InteractiveConsole does not have built-in mechanisms to do.

To have the program continue executing, use the c command. In the above example it will enter the debugger every loop iteration, so you might want to wrap the set_trace() call in an if sentence.

Lauritz V. Thaulow
  • 49,139
  • 12
  • 73
  • 92
14

You have options -- Python standard library or IPython.

The Python standard library has a code module which has an InteractiveConsole class whose purpose is to "Closely emulate the behavior of the interactive Python interpreter." This would probably be able to do what you want, but the documentation doesn't have any examples on how to use this, and I don't have any suggestions on where to go.

IPython, which is a more advanced Python terminal, has the option to embed a console at any point in your program built in. According to their documentation, you can simply do 

from IPython import embed

for thing in set_of_things:
  embed()
  do_stuff_to(thing)
Sam Mussmann
  • 5,883
  • 2
  • 29
  • 43
7

From Python 3.7 onwards, you can also use breakpoint() to get into the debugger, e.g.:

for thing in set_of_things:
    breakpoint()
    do_stuff_to(thing)

This is a little easier to remember and write, and will open your code in pdb by default.

However, it's also possible to set the PYTHONBREAKPOINT environment to the name of a callable, which could be another debugger such as pudb or ipdb, or it could be IPython's embed, or anything else.

Tom Carrick
  • 6,349
  • 13
  • 54
  • 78
4

Most comfortable tool for me is ipdb.

ipdb exports functions to access the IPython debugger, which features tab completion, syntax highlighting, better tracebacks, better introspection with the same interface as the pdb module.

Completion and handy introspection is especially useful for debugging.

g1zmo
  • 487
  • 3
  • 7
4

You can use ipdb.

To set your breakpoints, add import ipdb; ipdb.set_trace() where you want to jump into the debugger. Once you reach a breakpoint, you’ll be given an interactive shell and a few lines of code around your breakpoint for context.

https://www.safaribooksonline.com/blog/2014/11/18/intro-python-debugger/

fredrik
  • 9,631
  • 16
  • 72
  • 132