How to drop into REPL (Read, Eval, Print, Loop) from Python code

I frequently use this:

def interact():
    import code
    code.InteractiveConsole(locals=globals()).interact()

Here's how you should do it (IPython > v0.11):

import IPython
IPython.embed()

For IPython <= v0.11:

from IPython.Shell import IPShellEmbed

ipshell = IPShellEmbed()

ipshell() # this call anywhere in your program will start IPython

You should use IPython, the Cadillac of Python REPLs. See http://ipython.org/ipython-doc/stable/interactive/reference.html#embedding-ipython

From the documentation:

It can also be useful in scientific computing situations where it is common to need to do some automatic, computationally intensive part and then stop to look at data, plots, etc. Opening an IPython instance will give you full access to your data and functions, and you can resume program execution once you are done with the interactive part (perhaps to stop again later, as many times as needed).

You can launch the debugger:

import pdb;pdb.set_trace() 

Not sure what you want the REPL for, but the debugger is very similar.

To get use of iPython and functionality of debugger you should use ipdb,

You can use it in the same way as pdb, with the addition of :

import ipdb
ipdb.set_trace()

I just did this in one of my own scripts (it runs inside an automation framework that is a huge PITA to instrument):

x = 0 # exit loop counter
while x == 0:
    user_input = raw_input("Please enter a command, or press q to quit: ")
    if user_input[0] == "q":
        x = 1
    else:
        try:
            print eval(user_input)
        except:
            print "I can't do that, Dave."
            continue

Just place this wherever you want a breakpoint, and you can check the state using the same syntax as the python interpreter (although it doesn't seem to let you do module imports). It's not very elegant, but it doesn't require any other setup.

This function calls code.interact with the locals and globals of the caller:

def repl():
    """This starts a REPL with the callers globals and locals available

    Raises:
        RuntimeError: Is raised when the callers frame is not available
    """
    import code
    import inspect

    frame = inspect.currentframe()
    if not frame:
        raise RuntimeError('No caller frame')

    code.interact(local=dict(frame.f_back.f_globals, **frame.f_back.f_locals))

Great answers above, but if you would like this functionality in your IDE. Using Visual Studio Code (v1.5.*) with Python Setup:

1. Highlight the lines you would like to run and

• right click and select Run Selection/Line in Interactive Window from the drop down.
• Press shift + enter on your keyboard.

2. Right click on the Python file you want to execute in the file explorer and select Run Current File in Interactive Window

This will launch an interactive session, with linting, code completion and syntax highlighting:

Enter the code you would like to evaluate, and hit shift + enter on your keyboard to execute.

Enjoy Python!

If you wish completion in the interactive console, you can use this function to start REPL from anywhere.

import code
import readline
import rlcompleter

def repl(namespace):
    readline.set_completer(rlcompleter.Completer(namespace).complete)
    readline.parse_and_bind("tab: complete")
    code.interact(local=namespace)

Use it as follows:

1. call repl(locals()) where you need a breakpoint;
2. in the opened console press Tab to complete variable or attribute names.

code module doesn't provide colored output (Python 3.14) and arrow keys don't work there. You can use this instead:

from _pyrepl.main import interactive_console
interactive_console()