A Python REPL With IDE-Like Features – Real Python

Syntax Highlighting

As you kind code into bpython, your directions get tokenized into Python keywords, operators, comments, variables, and literal values like strings, numbers, or Booleans. Every token kind has an related shade to allow you to rapidly see what sort of language assemble you’re working with:

This tokenizing and coloring isn’t completed by bpython straight, however by the Pygments library used below the floor. Later, you’ll discover ways to customise the color theme in bpython.

Bracket Matching

Along with offering syntax highlighting, bpython additionally lets you understand if the opening and shutting brackets in your code are appropriately balanced. If you kind a closing bracket, bpython will spotlight the corresponding opening bracket and the opposite manner round:

This works with completely different sorts of brackets in Python, together with spherical brackets (()), sq. brackets ([]), and curly brackets (). You possibly can even nest brackets inside each other, and bpython will spotlight the right pair of brackets whenever you place your cursor on considered one of them.

Code Options

As quickly as you begin typing one thing, bpython will lookup Python key phrases, built-ins, globals, and your present lexical scope in line with the LEGB rule to search out objects with matching names. It matches names that start with a selected sequence of characters, so typing extra characters will slim down the outcomes. It’ll then show a listing of related recommendations in alphabetical order:

On this instance, you’re getting recommendations for the pass statement, a couple of built-in features like print(), and a user-defined variable known as program_variable that was outlined earlier within the present world scope.

You possibly can cycle ahead by means of these recommendations with Tab or cycle backward with Shift+Tab in the event you unintentionally overshoot. This may be particularly useful when there’s an excessive amount of content material to suit in your display.

Code recommendations additionally work elsewhere, a helpful function that you could be use for type introspection to search out out what attributes and strategies can be found in an object. However that’s not all!

Auto-Completion

Code recommendations go hand in hand with auto-completion, which is one other nifty function in lots of code editors, and bpython has it too. Primarily, it could actually write the remaining code for you when there’s no ambiguity about what you’re attempting to kind:

As you cycle by means of the obtainable recommendations with Tab or Shift+Tab, bpython goes forward and inserts the highlighted choice into the Python REPL. Then again, if there’s just one suggestion left and also you haven’t completed typing the entire title, then you’ll be able to press Tab to have bpython routinely full the remaining half.

A lesser-known reality about bpython’s auto-completion mechanism is that it understands your file system. In different phrases, whenever you begin typing a string literal that resembles a file path and also you hit Tab, then bpython will record all of the information and folders that match the string you’ve typed up to now:

It additionally expands particular symbols. For instance, the tilde character (~) is a shorthand notation for the present person’s dwelling listing on macOS and Linux, which bpython will develop into an absolute path, saving you much more typing.

Auto-Indentation

If you write lengthy blocks of code in the usual Python REPL, you need to appropriately indent every line your self. This may be tedious, error-prone, and unnatural in the event you’re used to writing code in a full-fledged editor. Luckily, bpython routinely provides the suitable quantity of indentation to the following line whenever you press the Enter key:

The default indentation in bpython is 4 areas, which complies with the Python model described in a doc known as PEP 8. Nevertheless, you’ll be able to change the corresponding tab-length choice in bpython’s configuration in the event you desire a unique indentation dimension. To exit the present block of code, you’ll be able to hit Enter with out typing something on that line. This may cut back the indentation degree by one.

Contextual Historical past

The usual Python REPL retains a limiteless historical past of the in-line directions that you just typed beforehand, even these from completed interpreter periods. You’ll find your command history in a file named .python_history situated in your person’s dwelling listing. Like many different instruments, the interactive Python interpreter handles the historical past by means of an interface to the GNU Readline library or by emulating it.

Then again, your bpython historical past is saved individually in a file known as .pythonhist and is proscribed to 1 thousand strains by default, though you’ll be able to improve that restrict within the configuration. Regardless of these variations, each the usual Python REPL and bpython conceptually assist the identical fundamental instructions to entry the historical past. That stated, bpython additionally maintains a contextual historical past, with outcomes relying on the place you’re in your code.

You possibly can browse the historical past by repeatedly utilizing the arrow keys in your keyboard. Use the Up arrow to return in time and the Down arrow to go ahead in time, one line of code at a time. You possibly can hit Enter to substantiate your selection and reuse one of many previous directions:

Discover how the historic recommendations supplied by bpython don’t all the time observe their chronological order. As an alternative, bpython filters out recommendations that wouldn’t match the context in your present indentation degree.

Not like within the vanilla Python REPL, in bpython, historical past additionally comes into play whenever you begin typing a line of code that’s already been executed earlier than:

As quickly as bpython finds a historic entry that begins with an identical character sequence, it’ll present a grayed-out completion. You possibly can ignore it by typing one thing else over it, or you’ll be able to settle for the suggestion by urgent the Proper arrow in your keyboard to have it auto-completed.

Runtime Kind Introspection

Code recommendations in bpython work in lots of locations. One in every of them is Python’s dot operator (.) for accessing members of an object. Usually, you should know the names of attributes and strategies outlined in a category up entrance or test the corresponding documentation or supply code to keep away from an attribute error. Luckily, bpython permits you to introspect objects and filter their attributes at runtime with out ever leaving your terminal.

For instance, say that you just’re making a multithreaded software and don’t bear in mind the precise title of a given methodology or attribute within the threading.Thread class. On this scenario, you should use bpython like this:

Word that solely public members are displayed by default as a result of, below regular circumstances, you’re not supposed to the touch the thing’s inside implementation. Nevertheless, sometimes, chances are you’ll need to attain for or modify its internals. To disclose such non-public members in bpython, kind one or two underscore characters (_) proper after the dot operator.

Most of the advised members whose names begin with a double underscore are, in actual fact, special methods that enable for operator overloading in Python.

You can too use bpython’s recommendations to discover Python modules and packages earlier than importing them. The REPL is aware of what modules are importable within the current session, together with the Python standard library, third-party libraries put in with pip, and customized modules situated in your venture folder. To set off these recommendations, kind import adopted by a single house and no less than one character, after which hit the Tab key:

Identical to with inspecting object attributes, inside modules don’t present up as recommendations in bpython until you explicitly request them by utilizing the main underscore or double underscore. When you import a selected module, you’ll be able to study its contents utilizing the acquainted dot operator as earlier than.

Perform Signatures and Docstrings

If you kind a gap parenthesis to name a operate or methodology in bpython, it’ll show the corresponding function signature with its formal parameters and their default values. It’ll additionally present info on which of them are positional, positional-only, keyword, or keyword-only arguments:

As you present values to your operate name, bpython highlights the present parameter title within the operate signature to point what number of are left. This may be very useful when the operate expects a number of arguments.

Perform signatures already present loads of helpful info that may enable you to perceive what a operate or methodology does with out having to lookup its documentation. Nevertheless, bpython goes the additional mile by displaying a docstring from the operate’s physique if it could actually discover and extract one from the supply code. Within the instance above, each your sub() operate and Python’s built-in max() operate have docstrings that bpython exhibits.

A docstring is often a multiline string literal that instantly follows the operate signature and incorporates a human-readable description of the operate. Typically, it might embrace particulars in regards to the operate arguments or automated doctests to self-test and display methods to use the operate. Routinely displaying docstrings is extra environment friendly than utilizing Python’s built-in assist() operate or accessing the operate’s .__doc__ attribute.

If neither the operate signature nor the docstring is sufficient for you, then you should use bpython to disclose the underlying supply code.

Supply Code Preview

Modern code editors allow you to navigate to the definition of an emblem by clicking on it whereas holding a delegated key in your keyboard. This works equally effectively for symbols that you just’ve outlined in your venture and ones which can be outlined within the Python commonplace library or a third-party package deal put in with pip. In bpython, you’ll be able to show a read-only preview of the corresponding supply code by urgent F2 after typing a given image:

You possibly can kind the title of a module, operate, or class. Relying on the kind of image, you’ll solely see the supply code belonging to that specific scope. Apparently sufficient, you’ll be able to request the supply code of the features and courses that you just outlined earlier in the identical REPL session.

Whether or not you utilize a code editor or bpython, this function will solely work so long as there’s pure-Python supply code obtainable. Then again, if the image that you just’re all for is a built-in operate or was carried out as an extension module within the C programming language, you then gained’t be capable to get any details about it. As an alternative, bpython will show a message that no supply code was discovered.

Rewind One or Extra Traces

If you make a typo in the course of a code block utilizing the vanilla Python REPL, then it’s important to retype all the block of code from scratch. In bpython, you’ll be able to press Ctrl+R to undo just one or simply the previous few strains and exchange them with new ones:

Beware that every time you rewind even a single line of code, bpython runs all the REPL session from the start once more, together with unedited strains that you just’ve already executed. Due to this fact, you ought to be additional cautious in regards to the potential unintended effects of mutating an exterior state—for instance, when writing to a file, database, or community connection.

The rewind function is an effective way to repair a mistake that you just noticed proper after making it, nevertheless it’s ill-suited for fixing earlier errors or for making main modifications. For this, bpython has one thing else to supply.

Edit Code in an Exterior Editor

By urgent Ctrl+X in your keyboard, you’ll be able to add or modify code situated on the present line in your bpython REPL utilizing an exterior code editor:

The road chosen for modifying could also be empty, or it might already include some Python instruction that bpython will first save to a temporary file for the exterior editor to load. Word that you just’re allowed so as to add multiple line of code when you’re utilizing the editor—for instance, to outline a brand new operate or a whole class. When you’ve completed making modifications, save the file and exit your editor to return to bpython.

The bpython REPL will detect whenever you shut the editor. Then, it’ll inject your new code from the short-term file again into the present session and reevaluate it, simply as with the rewind function earlier than.

Along with modifying a single line or a block of code, you’ll be able to edit your whole REPL session utilizing an exterior code editor in bpython. Press F7 to open your present session in an editor:

This time, you’ll see all of the contents of your REPL session, together with outputs of the earlier directions within the type of feedback. They’ll be ignored, as bpython will finally reevaluate your session whenever you shut the editor.

There’s one other manner to make use of a code editor with bpython, which you’ll study subsequent.

Reload Imported Modules

You should utilize any code editor at the side of bpython to switch helper features and courses outlined in your native modules or packages and have them reloaded within the present REPL session on demand. It’s an effective way to check and debug code with out restarting bpython whenever you change some imported code.

After saving your up to date modules in a code editor, press F6 in bpython to reload them and reevaluate the whole session since beginning the REPL:

Reloading modules retains current directions in your present REPL session intact and reruns them, leading to up to date outputs. This function is a useful device for exploratory testing. It will possibly increase your productiveness by slicing down on time spent restarting bpython and retyping the identical directions another time.

The bpython REPL additionally helps automated module reloading so that you just don’t need to manually hit a button each time you make some modifications to the code in an exterior editor.

Do not forget that whether or not you reload modules manually or let bpython try this routinely for you, it all the time triggers the whole session reevaluation. To allow the auto-reload function, hit F5 when you’re in bpython:

It’ll begin monitoring your imported modules and packages and routinely reload them within the present REPL session everytime you save considered one of their information. It is a dramatic enchancment over guide module reloading, and it could actually prevent a ton of time. To disable the auto-reload function, hit F5 once more, which works like a toggle.

As you’ll be able to see, bpython offers a number of code modifying options which can be lacking from the vanilla Python REPL, serving to you repair errors and refactor your code extra rapidly. However there’s extra that you are able to do with bpython! In case you’re a instructor, you then’re going to like the truth that it enables you to export your REPL session and share it with others in a couple of handy methods.

Copy to Clipboard

You possibly can copy the contents of your REPL session to the clipboard with a single keystroke, which may be helpful for sharing code snippets with others or pasting them right into a Stack Overflow or Real Python Slack Community query. Word, nevertheless, that the copy-to-clipboard function doesn’t work by default in bpython. To allow it, you need to first set up the pyperclip library into the digital surroundings in order that bpython can import it.

As soon as it’s put in, press F10, which is the default shortcut, to seize your REPL session:

That’s a incredible approach to share working code examples with others, particularly if you wish to embrace the output of your code. Nevertheless, it’ll be copied in plain textual content with none syntax coloring, so be sure that to stick it into one thing that may perceive Python to convey the colours again.

Alternatively, as an alternative of pasting the code by hand right into a messaging software or a textual content editor, it can save you your present REPL session on to an area file in your pc.

Save to File

The default keyboard shortcut to save lots of your bpython REPL session to a file is the acquainted Ctrl+S key mixture, which most Home windows PC packages use for this goal:

It’ll ask you to kind the title of the file to be created in your present working listing or a whole path indicating the place you need it to be saved. If the file already exists, you then’ll have the choice to overwrite it, append to it, or cancel the operation.

The great factor about saving code written in bpython to a file is that it gained’t embrace the REPL prompts, such because the triple chevron (>>>) or the ellipsis (...), making the code simpler to run. Nevertheless, you continue to need to ship the file as an attachment your self if you wish to share the code with others. That’s the place sending your REPL session to a pastebin is useful.

Ship to Pastebin

The third manner of sharing code in bpython is to add your REPL session to a pastebin, or a web based textual content storage service. The bpython REPL helps bpa.st by default, which is an occasion of pinnwand, however you’ll be able to change the default pastebin to a different service if you wish to. If you hit F8 and ensure your selection with Y, then after a couple of moments, you’ll be introduced with a publicly obtainable URL to share:

As an proprietor, you’ll additionally get one other URL, which you should use to delete the paste in the event you now not need it on the server. In case you don’t delete your paste your self, then the corresponding URL will routinely expire after one week. You possibly can change this default setting in bpython’s configuration, although.

When somebody navigates to your paste on bpa.st, they’ll see a properly formatted snapshot of your bpython REPL session with syntax highlighting and the flexibility to toggle the darkish mode:

You possibly can click on one of many hyperlinks under the uploaded REPL session to view the code in plain textual content with none colours, copy it to the clipboard, or obtain it as a file. There’s additionally an choice to encode the REPL session utilizing hexadecimal characters, which you’ll be able to decode utilizing Python’s binascii.unhexlify() operate. This may very well be helpful for debugging invalid characters. Word that your REPL session will embrace the prompts.

Common Settings

One of many first issues that you just would possibly need to change to enhance your bpython expertise is the exterior code editor, which defaults to the text-based vi. For instance, to make bpython open Visible Studio Code as an alternative, discover the editor choice below the [general] part tag and set it to the next worth:

# ~/.config/bpython/config

# ...

[general]
editor = code --wait

The --wait flag is critical to make VS Code anticipate the information to shut earlier than returning. In any other case, bpython wouldn’t see any modifications in your session to use.

You might also improve the variety of strains to retailer within the historical past file by bumping up the hist_length choice, which is often restricted to 1 thousand:

# ~/.config/bpython/config

# ...

[general]
hist_length = 999_999_999_999

As a result of bpython expects the configuration values to be legitimate Python literals, just remember to kind an integer literal for this selection. You should utilize the underscore character (_) to visually separate teams of digits.

One other attention-grabbing choice is pastebin_helper, which helps you to specify the trail to a program that bpython will name whenever you request that the REPL session be uploaded to a pastebin:

# ~/.config/bpython/config

# ...

[general]
pastebin_helper = /dwelling/realpython/github_gist.py

By specifying this selection, you’ll be able to take management over what occurs with the REPL session in bpython in the event you’re involved about your privateness. For instance, as an alternative of importing your code to bpa.st for everybody to see, you’ll be able to create a secret gist in your GitHub profile whereas stripping out the REPL prompts.

Right here’s the content material of a pattern github_gist.py script, which creates a personal gist in your GitHub profile utilizing the GitHub REST API:

 1#!/usr/bin/env python
 2
 3import json
 4import os
 5import sys
 6from urllib.request import Request, urlopen
 7
 8def important() -> None:
 9    """Print the URL of a GitHub gist created from the usual enter."""
10    print(create_gist(sys.stdin.learn()))
11
12def create_gist(content material: str) -> str:
13    """Return the URL of the created GitHub gist."""
14    response = post_json(
15        url="https://api.github.com/gists",
16        information=
17            "description": "bpython REPL",
18            "public": False,
19            "information": "repl.py": "content material": content material,
20        ,
21        headers=
22            "Settle for": "software/vnd.github+json",
23            "Authorization": f"Bearer os.getenv('GITHUB_TOKEN')",
24            "Content material-Kind": "software/json",
25        ,
26    )
27    return response["html_url"]
28
29def post_json(url: str, information: dict, headers: dict = None) -> dict:
30    """Return the JSON response from the server."""
31    payload = json.dumps(information).encode("utf-8")
32    with urlopen(Request(url, payload, headers or )) as response:
33        return json.hundreds(response.learn().decode("utf-8"))
34
35if __name__ == "__main__":
36    attempt:
37        important()
38    besides Exception as ex:
39        print(ex)

The script reads the REPL session from the standard input (stdin) stream and writes the ensuing URL onto the standard output (stdout) stream, which bpython can intercept and show. Because of the urllib.request module from the usual library, you may make HTTP requests in Python with out putting in any exterior libraries.

$ export GITHUB_TOKEN="your token goes right here"

As a result of it’s a Python script, to make it executable, you need to embrace the shebang (#!) interpreter directive at the start of the file, which factors to the Python interpreter. You should additionally bear in mind to set the file mode to executable (x)—for instance, with the chmod +x custom_pastebin.py command.

When every part works effective, it is best to be capable to run the script from bpython by urgent F8. Then, you’ll see the URL of the GitHub gist that it creates:

>>> def greet(title: str = "stranger") -> str:
...     return f"Howdy, title Nwaving hand signal"
...
>>> greet()
'Howdy, stranger 👋'
>>> greet("world")
'Howdy, world 👋'
>>>
Pastebin URL: https://gist.github.com/01313aafa8ae3d2f5635a179e963ab42

If this doesn’t give you the results you want, then attempt restarting bpython to make sure that it has loaded the configuration with the best path to your script. Make the script executable by setting the right file mode, as you noticed earlier than. Lastly, bear in mind to outline the surroundings variable along with your private entry token with the required scope.

Now your secret gist will resemble the snapshot of a REPL session that you just shared on bpa.st earlier than:

For different configurable choices obtainable in bpython, together with those who bpython could not generate whenever you first edit the configuration file, try the configuration page within the official documentation.

Keyboard Shortcuts

The subsequent part that you just’ll discover in bpython’s configuration file is tagged as [keyboard]. It represents keyboard shortcuts sure to particular actions, comparable to clearing the display or displaying the supply code preview. You possibly can outline customized key bindings utilizing the next syntax:

How are you aware the names of choices that correspond to the obtainable actions in bpython? Luckily, the generated configuration file incorporates commented-out mappings of actions and their default keyboard shortcuts. You possibly can uncomment and replace a couple of of them. For instance, to keep away from a battle with a typical world sizzling key for pausing your terminal, you’ll be able to remap the shortcut for the save motion to F4:

# ~/.config/bpython/config

# ...

[keyboard]

# All key bindings are proven commented out with their default binding

# pastebin = F8
# last_output = F9
# reimport = F6
# assist = F1
# toggle_file_watch = F5
save = F4
# undo = C-r
# redo = C-g
# up_one_line = C-p
# down_one_line = C-n
# cut_to_buffer = C-k
# search = C-o
# yank_from_buffer = C-y
# backspace = C-h
# clear_word = C-w
# clear_line = C-u
# clear_screen = C-l
# show_source = F2
# exit = C-d
# external_editor = F7
# edit_config = F3
# reverse_incremental_search = M-r
# incremental_search = M-s

Don’t neglect to restart bpython after saving the configuration file to make your modifications efficient. The configuration file is learn solely as soon as, when bpython begins.

Colour Themes

Many code editors will let you change the colour theme. This will help cut back eyestrain by letting you turn between mild and darkish themes to adapt to the lighting circumstances in your surroundings. Additionally, in the event you get uninterested in the default color theme or require higher distinction, then you’ll be able to all the time select a theme that higher fits your wants.

To customise the colours for syntax highlighting in bpython, you need to create a .theme file positioned subsequent to the configuration file in your user-specific configuration listing. For instance, in the event you’d wish to create a lightweight theme, then you can create a customized.theme file like so:

~/.config/
│
└── bpython/
    ├── config
    └── customized.theme

To inform bpython which theme file to make use of when it begins, it is best to set the color_scheme choice within the configuration file:

# ~/.config/bpython/config

# ...

[general]
color_scheme = customized

Word that you just shouldn’t embrace the .theme suffix right here as a result of bpython all the time appends it to the required file stem.

Now, you’ll be able to return to your customized theme file, which can have the next contents impressed by the pattern light theme obtainable on bpython’s GitHub repository:

# ~/.config/bpython/customized.theme

[syntax]
key phrase = M
title = r
remark = b
string = g
error = r
quantity = B
operator = c
paren = b
punctuation = b
token = g

[interface]
background = d
output = b
important = b
immediate = r
prompt_more = g
right_arrow_suggestion = Okay

The one distinction from the linked theme file is within the highlighted line, which makes use of the letter d for a clear background as an alternative of w for white, which some terminals render incorrectly.

Right here’s how the bpython REPL will look whenever you apply the customized theme that you just’ve outlined above:

Sadly, there’s solely a small set of mounted shade markers that you may select from:

On the upside, you may make the font daring by utilizing uppercase letters, so there’s a tiny little bit of room for selection and creativity. For instance, the uppercase letter Y will make your textual content yellow and daring.

Now that bpython is personalized to your liking, you can begin utilizing it as your debugging device.

Embed the REPL in a Script

Say you needed to carry out postmortem debugging after intercepting an exception. In such a case, you’ll be able to embed and begin the bpython REPL proper in your script after it crashes to introspect native variables utilizing the dynamic nature of Python.

The next script expects the person to enter two numbers, that are then divided one by the opposite:

# adder.py

attempt:
    x = int(enter("x = "))
    y = int(enter("y = "))
    z = x / y
besides (ValueError, ZeroDivisionError) as ex:
    import bpython
    bpython.embed(locals(), banner="Put up-Mortem Debugging:")
else:
    print(z)

If the person offers a non-integer worth for both of the 2 variables, then Python will increase a ValueError. When each values entered by the person are legitimate integers however the second is the same as zero, you then’ll find yourself with a ZeroDivisionError as an alternative. The script catches each exception sorts and embeds a bpython REPL with the native variables in response.

Right here’s what a pattern execution of that script can seem like:

(bpython-venv) $ python adder.py
x = 42
y = 0
Put up-Mortem Debugging:
>>> ex
ZeroDivisionError('division by zero')
>>> ex.args[0]
'division by zero'
>>> x
42
>>> y
0
>>> z
Traceback (most up-to-date name final):
  File "<enter>", line 1, in <module>
    z
NameError: title 'z' will not be outlined

Do not forget that you need to run the script from inside a digital surroundings with bpython put in. In any other case, you gained’t be capable to import its modules. As quickly as there’s an exception, you’re dropped into an interactive bpython session with entry to all of your native variables, together with ex, x, and y, which you’ll be able to examine and manipulate to realize further perception into the problem.

Embedding a bpython REPL will not be sufficient, although. Within the subsequent part, you’ll study combining the facility of a REPL with a text-based debugger.

Add a Breakpoint Utilizing bpdb

If you wish to use a correct debugger to step by means of your code and manipulate the native variables at any level within the execution of your script, then you should use the bpdb debugger that comes with bpython. It’s practically an identical to Python’s pdb debugger however has a further BPython or B command that begins bpython on the present stack body.

To reap the benefits of bpdb, you’ll be able to modify your current adder.py script within the following manner:

# adder.py

attempt:
    x = int(enter("x = "))
    y = int(enter("y = "))
    import bpdb; bpdb.set_trace()
    z = x / y
besides (ValueError, ZeroDivisionError) as ex:
    import bpython
    bpython.embed(locals(), banner="Put up-Mortem Debugging:")
else:
    print(z)

The decision to bpdb.set_trace() creates a breakpoint that’ll interrupt the execution of your Python program and begin the interactive debugger. Word that since Python 3.7, you’ll be able to name the built-in breakpoint() comfort operate to have the identical impact. Sadly, the operate is hardwired to the basic pdb debugger by default. So, if you wish to reap the benefits of bpdb as an alternative, then it is best to import it explicitly, as within the instance above.

Now, when your program reaches that breakpoint, it’ll pause its regular execution and drop you into the debugger. You possibly can step by means of the code line by line. Kind the lowercase letter n and ensure with Enter to advance to the following line. At any given level, you’ll be able to kind the uppercase letter B to embed the bpython REPL:

(bpython-venv) $ python adder.py
x = 42
y = 0
> /dwelling/realpython/adder.py(7)<module>()
-> z = x / y
Use "B" to enter bpython, Ctrl-d to exit it.
(BPdb) n
ZeroDivisionError: division by zero
> /dwelling/realpython/adder.py(7)<module>()
-> z = x / y
(BPdb) n
> /dwelling/realpython/adder.py(8)<module>()
-> besides (ValueError, ZeroDivisionError) as ex:
(BPdb) B
bpython model 0.23 on high of Python 3.11.0
 ⮑ /dwelling/realpython/.pyenv/variations/3.11.0/bin/python
>>> x
42
>>> y
0

The highlighted strains point out bpdb’s immediate the place you’ll be able to kind its instructions. You possibly can exit the debugger in the identical manner you sometimes exit the REPL—that’s, by hitting Ctrl+D to ship the end-of-file (EOF) character.

Naturally, bpython comes with many extra helpful modules that you may reap the benefits of for functions aside from debugging. As an example, you can leverage its wonderful code introspection mechanism in the event you have been writing a static code analysis device or one thing comparable.