A Python REPL With IDE-Like Options – Actual Python

Syntax Highlighting

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

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

Bracket Matching

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

This works with totally 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 proper pair of brackets whenever you place your cursor on one among them.

Code Solutions

As quickly as you begin typing one thing, bpython will lookup Python key phrases, built-ins, globals, and your present lexical scope in response to the LEGB rule to seek 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 solutions in alphabetical order:

On this instance, you’re getting solutions for the cross assertion, a number of built-in capabilities like print(), and a user-defined variable referred to as program_variable that was outlined earlier within the present international scope.

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

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

Auto-Completion

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

As you cycle by the obtainable solutions 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 identify, then you may press Tab to have bpython mechanically 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 listing all of the information and folders that match the string you’ve typed to date:

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

Auto-Indentation

Whenever 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 case you’re used to writing code in a full-fledged editor. Luckily, bpython mechanically 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 referred to as PEP 8. Nevertheless, you may change the corresponding tab-length choice in bpython’s configuration in case you choose a unique indentation dimension. To exit the present block of code, you may hit Enter with out typing something on that line. This may scale 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 simply typed beforehand, even these from completed interpreter periods. You’ll find your command historical past in a file named .python_history situated in your consumer’s house listing. Like many different instruments, the interactive Python interpreter handles the historical past by an interface to the GNU Readline library or by emulating it.

Then again, your bpython historical past is saved individually in a file referred to as .pythonhist and is restricted to at least one thousand strains by default, though you may improve that restrict within the configuration. Regardless of these variations, each the usual Python REPL and bpython conceptually help the identical primary instructions to entry the historical past. That mentioned, 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 alternative and reuse one of many previous directions:

Discover how the historic solutions supplied by bpython don’t at all times comply with their chronological order. As an alternative, bpython filters out solutions 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 may settle for the suggestion by urgent the Proper arrow in your keyboard to have it auto-completed.

Runtime Sort Introspection

Code solutions in bpython work in lots of locations. One among 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 examine 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 simply’re making a multithreaded software and don’t bear in mind the precise identify of a given technique or attribute within the threading.Thread class. On this state of affairs, you need to use bpython like this:

Be aware 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 inner implementation. Nevertheless, sometimes, it’s possible 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.

Lots of the steered members whose names begin with a double underscore are, in actual fact, particular strategies that permit for operator overloading in Python.

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

Similar to with inspecting object attributes, inner modules don’t present up as solutions in bpython except you explicitly request them by utilizing the main underscore or double underscore. When you import a selected module, you may look at its contents utilizing the acquainted dot operator as earlier than.

Perform Signatures and Docstrings

Whenever you kind a gap parenthesis to name a perform or technique in bpython, it’ll show the corresponding perform signature with its formal parameters and their default values. It’ll additionally present data on which of them are positional, positional-only, key phrase, or keyword-only arguments:

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

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

A docstring is normally a multiline string literal that instantly follows the perform signature and accommodates a human-readable description of the perform. Generally, it could embody particulars concerning the perform arguments or automated doctests to self-test and exhibit the best way to use the perform. Robotically displaying docstrings is extra environment friendly than utilizing Python’s built-in assist() perform or accessing the perform’s .__doc__ attribute.

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

Supply Code Preview

Up to date 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 properly for symbols that you simply’ve outlined in your venture and ones which might be outlined within the Python normal library or a third-party bundle put in with pip. In bpython, you may show a read-only preview of the corresponding supply code by urgent F2 after typing a given image:

You possibly can kind the identify of a module, perform, or class. Relying on the kind of image, you’ll solely see the supply code belonging to that individual scope. Curiously sufficient, you may request the supply code of the capabilities and courses that you simply outlined earlier in the identical REPL session.

Whether or not you employ 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 simply’re interested by is a built-in perform or was carried out as an extension module within the C programming language, you then gained’t have the ability to get any details about it. As an alternative, bpython will show a message that no supply code was discovered.

Rewind One or Extra Strains

Whenever you make a typo in the midst of a code block utilizing the vanilla Python REPL, then it’s important to retype the whole block of code from scratch. In bpython, you may press Ctrl+R to undo just one or simply the previous few strains and change them with new ones:

Beware that every time you rewind even a single line of code, bpython runs the whole REPL session from the start once more, together with unedited strains that you simply’ve already executed. Subsequently, you have to be additional cautious concerning the potential uncomfortable side 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 simply noticed proper after making it, but it surely’s ill-suited for fixing earlier errors or for making main adjustments. For this, bpython has one thing else to supply.

Edit Code in an Exterior Editor

By urgent Ctrl+X in your keyboard, you may 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 could already include some Python instruction that bpython will first save to a short-term file for the exterior editor to load. Be aware that you simply’re allowed so as to add multiple line of code when you’re utilizing the editor—for instance, to outline a brand new perform or a complete 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 may edit your total 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 method to make use of a code editor with bpython, which you’ll study subsequent.

Reload Imported Modules

You should use any code editor along with bpython to switch helper capabilities 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 entire session since beginning the REPL:

Reloading modules retains present 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 may possibly increase your productiveness by reducing down on time spent restarting bpython and retyping the identical directions over again.

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

Keep in mind that whether or not you reload modules manually or let bpython try this mechanically for you, it at all times triggers the entire 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 mechanically reload them within the present REPL session everytime you save one among their information. This can be a dramatic enchancment over handbook module reloading, and it could possibly prevent a ton of time. To disable the auto-reload function, hit F5 once more, which works like a toggle.

As you may see, bpython gives a number of code modifying options which might be lacking from the vanilla Python REPL, serving to you repair errors and refactor your code extra shortly. However there’s extra that you are able to do with bpython! If you happen to’re a trainer, you then’re going to like the truth that it enables you to export your REPL session and share it with others in a number 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 useful for sharing code snippets with others or pasting them right into a Stack Overflow or Actual Python Slack Neighborhood query. Be aware, nonetheless, 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 atmosphere 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 improbable approach to share working code examples with others, particularly if you wish to embody 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 carry 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 laptop.

Save to File

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

It’ll ask you to kind the identify of the file to be created in your present working listing or a complete 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 good factor about saving code written in bpython to a file is that it gained’t embody 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 method of sharing code in bpython is to add your REPL session to a pastebin, or an internet textual content storage service. The bpython REPL helps bpa.st by default, which is an occasion of pinnwand, however you may change the default pastebin to a different service if you wish to. Whenever you hit F8 and ensure your alternative with Y, then after a number 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 need to use to delete the paste in case you now not need it on the server. If you happen to don’t delete your paste your self, then the corresponding URL will mechanically 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 power to toggle the darkish mode:

You possibly can click on one of many hyperlinks beneath 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 decode utilizing Python’s binascii.unhexlify() perform. This might be useful for debugging invalid characters. Be aware that your REPL session will embody the prompts.

Common Settings

One of many first issues that you simply 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 adjustments in your session to use.

You may additionally improve the variety of strains to retailer within the historical past file by bumping up the hist_length choice, which is often restricted to at least one 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 feature. You should use 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 = /house/realpython/github_gist.py

By specifying this feature, you may take management over what occurs with the REPL session in bpython in case you’re involved about your privateness. For instance, as an alternative of importing your code to bpa.st for everybody to see, you may 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 primary() -> 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-Sort": "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    strive:
37        primary()
38    besides Exception as ex:
39        print(ex)

The script reads the REPL session from the normal enter (stdin) stream and writes the ensuing URL onto the normal 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 embody the shebang (#!) interpreter directive in the beginning of the file, which factors to the Python interpreter. You will need to additionally bear in mind to set the file mode to executable (x)—for instance, with the chmod +x custom_pastebin.py command.

When all the things works high quality, you need to have the ability to run the script from bpython by urgent F8. Then, you’ll see the URL of the GitHub gist that it creates:

>>> def greet(identify: str = "stranger") -> str:
...     return f"Good day, {identify} N{waving hand signal}"
...
>>> greet()
'Good day, stranger 👋'
>>> greet("world")
'Good day, world 👋'
>>>
Pastebin URL: https://gist.github.com/01313aafa8ae3d2f5635a179e963ab42

If this doesn’t give you the results you want, then strive restarting bpython to make sure that it has loaded the configuration with the proper path to your script. Make the script executable by setting the proper file mode, as you noticed earlier than. Lastly, bear in mind to outline the atmosphere 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 simply 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, take a look at the configuration web page within the official documentation.

Keyboard Shortcuts

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

How have you learnt the names of choices that correspond to the obtainable actions in bpython? Luckily, the generated configuration file accommodates commented-out mappings of actions and their default keyboard shortcuts. You possibly can uncomment and replace a number of of them. For instance, to keep away from a battle with a standard international sizzling key for pausing your terminal, you may 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 adjustments efficient. The configuration file is learn solely as soon as, when bpython begins.

Coloration Themes

Many code editors mean you can change the colour theme. This can assist scale back eyestrain by letting you turn between gentle and darkish themes to adapt to the lighting circumstances in your atmosphere. Additionally, in case you get uninterested in the default colour theme or require larger distinction, then you may at all times 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 case you’d prefer to create a light-weight theme, then you might 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, you need to set the color_scheme choice within the configuration file:

# ~/.config/bpython/config

# ...

[general]
color_scheme = customized

Be aware that you simply shouldn’t embody the .theme suffix right here as a result of bpython at all times appends it to the required file stem.

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

# ~/.config/bpython/customized.theme

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

[interface]
background = d
output = b
primary = b
immediate = r
prompt_more = g
right_arrow_suggestion = Ok

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 simply’ve outlined above:

Sadly, there’s solely a small set of mounted colour markers which you can 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 custom-made 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 may 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 consumer to enter two numbers, that are then divided one by the opposite:

# adder.py

strive:
    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 consumer gives a non-integer worth for both of the 2 variables, then Python will increase a ValueError. When each values entered by the consumer 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 appear to be:

(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: identify 'z' will not be outlined

Keep in mind that you need to run the script from inside a digital atmosphere with bpython put in. In any other case, you gained’t have the ability 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 examine and manipulate to realize extra perception into the difficulty.

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 your code and manipulate the native variables at any level within the execution of your script, then you need to use the bpdb debugger that comes with bpython. It’s practically similar to Python’s pdb debugger however has an extra BPython or B command that begins bpython on the present stack body.

To reap the benefits of bpdb, you may modify your present adder.py script within the following method:

# adder.py

strive:
    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. Be aware that since Python 3.7, you may name the built-in breakpoint() comfort perform to have the identical impact. Sadly, the perform is hardwired to the traditional pdb debugger by default. So, if you wish to reap the benefits of bpdb as an alternative, then you need 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 the code line by line. Sort the lowercase letter n and ensure with Enter to advance to the following line. At any given level, you may kind the uppercase letter B to embed the bpython REPL:

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

The highlighted strains point out bpdb’s immediate the place you may kind its instructions. You possibly can exit the debugger in the identical method 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 which you can reap the benefits of for functions apart from debugging. As an illustration, you might leverage its wonderful code introspection mechanism in case you have been writing a static code evaluation device or one thing comparable.