What Is Python’s Interactive Shell or REPL?

When you run the Python interpreter in interactive mode, you open aninteractive shell, also known as aninteractive session. In thisshell, your keyboard is the input source, and your screen is the output destination.

Here’s how the REPL works: it takes input consisting of Python code, which the interpreter parses and evaluates. Next, the interpreter displays the result on your screen, and the process starts again as a loop.

So, Python’s REPL is an interactive way to talk to your computer using the Python language. It’s like a live chat. The whole process is known as a REPL because it goes through four steps that run under the hood:

1. Reading your input, which consists of Python code asexpressions andstatements
2. Evaluating your Python code, which generates a result or causesside effects
3. Printing any output so that you can check your code’s results and get immediate feedback
4. Looping back to step one to continue the interaction

This feature of Python is a powerful tool that you’ll wind up needing in your Python coding adventure, especially when you’re learning the language or when you’re in the early stages of a development process. That’s because the REPL offers several benefits, which you’ll learn about next.

Why Use a Python REPL?

As a Python programmer, you may spend considerable time in interactive mode. This mode provides a quick way to try out ideas and code snippets. In a REPL session, you can do some or all of the following tasks:

• Explore and learnPython syntax
• Try out and proveideas,concepts, andimplementations
• Quickly evaluate if yourcode snippets work
• Dive into thelanguage behaviors
• Edit andrefactor your code for later use inscript mode
• Perform code andtype introspection
• Get interactivehelp on how to use the language
• Debug code snippets
• Explore standard-library and third-partymodules,libraries, andAPIs
• Inspect the implementation ofclasses,functions, and otherobjects

Clearly, as a Python developer, you’ll have many reasons to spend a lot of time in REPL sessions, working interactively with the interpreter. The most relevant benefit of using a REPL session isgetting immediate feedback on how your code works.

Interactive mode is one of the best features of Python. It allows you to test solutions and experiment with the language in real time. If you want to know how something works, then just try it in an interactive shell.

You should definitely consider the interactive shell a powerfullearning tool, especially if your previous programming experience has been with compiled languages that don’t provide a REPL.

While learning Python or exploring new features and concepts, you’ll notice that many examples in the Pythondocumentation, online tutorials, manuals, and courses are copied and pasted from an interactive session. You’ll recognize them because of the REPL’s characteristicprompts, which you’ll get to know in theRunning thepython Command section.

With this introduction to interpreters and REPLs, you’re ready to get into action. In the following section, you’ll learn how to start and terminate a Python interactive session.

Running thepython Command

Once you’veinstalled Python on your computer, you can immediately begin using the REPL. To start a Python interactive session, open a command-line window and run thepython command without arguments:

$python

This command makes Python enter its interactive mode. The interpreter will run, and you’ll get an output that looks something like this:

Python 3.14.0 (main, Oct 11 2025, 20:47:48) ... on darwinType "help", "copyright", "credits" or "license" for more information.>>>

The first line of this output shows information about your current Python version and the platform on which you’re running the interpreter. The second line shows a message with commands that you can run to get additional information about Python in general.

The last line, which is highlighted in the output, shows theprimary prompt of the standard Python REPL. By default, this prompt consists of three greater-than signs (>>>), also known as chevrons. Its purpose is to communicate that the interpreter is ready to accept input.

The interpreter also has asecondary prompt represented by three dots (...). This prompt appears when you’re entering compound statements or line continuations. You’ll learn more about this prompt in theRunning Compound Statements andDealing With Explicit and Implicit Line Continuations sections.

Passing Command-Line Options to thepython Command

Thepython command can take several command-line options. Some of these can be especially useful when working in a REPL session. One of the most relevant options in this context is the-i flag. This option causes the interpreter to enter interactive mode after running a script or executing a piece of code using the-c option.

You can use the-i option to check the current global variables in your script or to inspect thestack trace when your program raises an exception.

To try this option out, say that you have the following sample script:

defread_data():# Read data from a file or database...return[1,2,3,4,5,6,7,8,9,10]sample=read_data()defmean(data):returnsum(data)/len(data)average=mean(sample)

This script reads sample data from a hypothetical file or database and provides a function to calculate the mean or average of the data.

Go ahead and run the script with the following command:

$python-isample.py

Once you pressEnter, this command runs the code insample.py and takes you directly to an interactive session. You’ll recognize this session because your screen will present the REPL’s primary prompt (>>>).

From this point on, you can inspect, test, and debug the code insample.py as needed:

>>>globals(){    '__name__': '__main__',    ...    'read_data': <function read_data at 0x104dd4860>,    'sample': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],    'mean': <function mean at 0x104fe3ec0>,    'average': 5.5}>>>mean([2,3,3,2])2.5>>>mean([])Traceback (most recent call last):...ZeroDivisionError:division by zero

In these examples, you first call the built-inglobals() function to inspect the global names defined in your script. This function returns adictionary that maps names to their corresponding objects. The second example callsmean() with a new sample of data.

The final example callsmean() with an empty list as an argument. In this case, the function fails with aZeroDivisionError because callinglen() with an empty list returns0.

The-b flag is another command-line option to consider when you run Python in interactive mode. This option comes in handy when you’re running code that comparesbytes objects, and you want to get a warning if astring or integer value gets in the middle of a comparison:

>>># Run python with the -b option>>>b=b"Hello">>>s="Hello">>>b==s<python-input-2>:1: BytesWarning: Comparison between bytes and stringFalse

The-b option in this example makes the interpreter display a warning when it finds operations that comparebytes with either strings orint values. If you don’t use this option, then no warning is shown:

>>># Run python without the -b option>>>b=b"Hello">>>s="Hello">>>b==sFalse

As in the previous example, the comparison returnsFalse because the values are of different data types. However, in this final example, you don’t get any warning that helps you understand why you’re getting this result.

This is just a sampling of the options that may come in handy when you’re using Python in interactive mode. For a complete list of command-line options, check out thePython documentation.

Exiting the Current Python REPL Session

If you’re used to working on your command line or terminal, then you probably don’t like closing and opening terminal windows all the time. Your regular workflow may go through executingCLI tools, closing them when the work is done, and returning to your current shell session.

This may be the case when you’re using Python in interactive mode. Once inside the REPL, you can’t run normal shell commands because you’re inside a different environment. To get back to your normal shell, you need to terminate the REPL session.

There are a few ways to exit an interactive session. You can use either of the following Python options:

• quit() or justquit in Python 3.13 or later
• exit() or justexit in Python 3.13 or later

These options are built into Python, so they’re available at any time during an interactive session. Both allow you to terminate the current session. Note that the command forms are only available in Python 3.13 or later, as this is a feature of theimproved REPL.

Alternatively, you can explicitlyraise theSystemExit exception manually with an exit code of0. You’ll get the same result, and your current REPL session will terminate.

Any of these options will get you out of your current Python interactive session and take you back to the operating system (OS) shell. After this, you can run regular shell commands again.

Another option for terminating a REPL session is to use one of the following keyboard shortcuts, depending on your current operating system:

• Ctrl+D on Unix systems, such as Linux or macOS
• Ctrl+Z and thenEnter on Windows systems

These keystrokes signal the end of input to Python’s standard input (stdin), at which point the REPL terminates.

Evaluating Expressions and Simple Statements

Once you’ve launched a Python interactive session from your command line, you can start entering and executing Python code immediately. To do this, get back to your command-line window and run thepython command.

When the REPL’s primary prompt (>>>) appears on your screen, type in the following expressions, pressing theEnter key after each of them:

>>>5-23>>>sum([1,2,3,4])10>>>42>7True>>>number=42>>>7/0Traceback (most recent call last):...ZeroDivisionError:division by zero

The firstexpression subtracts two numbers and displays the result. The second expression is a call to the built-insum() function, which takes a series of values andreturns their total sum. In the third example, you execute aBoolean expression that compares two numbers.

The fourth example is anassignment statement that defines and initializes avariable callednumber. Becauseassignments don’t return any value, the Python interpreter doesn’t display any output on your screen. Instead, it falls back to the primary prompt immediately. The final example shows how Python displays an error when your code has issues.

While running these examples, note how after executing each expression, the interpreter loops back to the primary prompt (>>>), which lets you introduce a new expression. Now you’ve seen the REPL cycle in action. The Python interpreter has read your expressions, executed them, and printed their corresponding result to finally loop back to the primary prompt.

Running Compound Statements

With the examples in the previous section, you’ve executedsimple statements in a Python interactive session. These expressions are known as simple statements because they don’t have an indented code block.

Python also hascompound statements, such asconditionals,loops, andwith statements. Compound statements require an indented code block. The Python interpreter has a secondary prompt that lets you enter the code block of compound statements.

Consider the following example of a conditional statement:

>>>number=-42>>>ifnumber<0:...print("negative")...elifnumber>0:...print("positive")...else:...print("equal to 0")...negative

In this code snippet, you first define a variable to hold a number. Next up, you start a conditional statement.

Once you type the colon character (:) and pressEnter, you get three dots (...) on your screen. These dots represent the REPL’s secondary prompt. This prompt on your screen means that you can enter the required indented blocks of your current compound statement.

When it comes to entering indented code blocks, keep in mind that the standard REPL supports auto-indentation starting in Python 3.13. In previous versions, you’ll get noindentation:

>>>ifnumber<0:...print("negative")  File"<stdin>", line2print("negative")^IndentationError:expected an indented block after 'if' statement on line 1

If you’re using a Python version earlier than 3.13, then you must provide the appropriateindentation manually for any indented code block that you need to enter. Otherwise, you’ll get anIndentationError, like in the example above.

Dealing With Explicit and Implicit Line Continuations

Another situation where the REPL’s secondary prompt appears is when you need to useline continuations. A line continuation occurs when youexplicitly join multiplephysical lines into a singlelogical line using the backslash (\) character:

>>>number=42>>>assertisinstance(number,int)andnumber>0, \...f"number greater than 0 expected, got:{number}"

Thisassert statement performs two checks onnumber. First, it uses the built-inisinstance() function to check if the value is an integernumber. Then it checks whether the input value is greater than0. If either of these conditions fails, then the statement raises anAssertionError with the provided message as an argument.

Line continuations also happen when you use several physical lines to write an expression delimited by a pair of brackets—for example, when you define alist,tuple, ordictionary:

>>>fruits=[..."apple",..."banana",..."orange",..."grape",..."lemon",...]>>>inventory={..."mouse":120,..."keyboard":50,..."laptop":200,..."headphones":240,...}

Once you open a bracket, such as[],(), or{}, and pressEnter, you get the REPL’s secondary prompt. This is known asimplicit line joining.

You can also use implicit line joining in other contexts, such as math andBoolean expressions,function definitions and calls,list comprehensions, andgenerator expressions. In short, implicit line continuation will appear in all those Python constructs that accept some type of brackets, including[],(), or{}.

Printing vs Evaluating

When you run Python in interactive mode, you’ll notice that the interpreter immediately displays the resulting value of any expression. The interpreter doesn’t display anything for other statements that don’t generate return values. That’s the case with assignment statements, as you already learned.

The Python REPL behaves that way because its primary goal is to provide immediate feedback on how your code works. This behavior makes using the built-inprint() function almost unnecessary when you’re working interactively.

However, there’s at least one use case forprint() in REPL sessions. You need to useprint() when you want to display the result of an expression that can returnNone, which is Python’s null value.

For example, a common error that some Python beginners make when they start to learn about lists is to expect new lists from calls tolist methods, such as.append(),.sort(), and the like:

>>>numbers=[2,4,1,3]>>>numbers.sort()>>>numbers.append(5)

Because these method calls don’t issue any output to the screen, it may seem that they did nothing. Most list methods run their intended transformation or computationin place. In other words, list methods often modify the underlying list object instead of creating a new one. Because of this, most list methods returnNone, which the REPL automatically ignores. As a result, nothing shows up on your screen.

If you ever need to displayNone in a REPL session, then you must use theprint() function:

>>>print(numbers.append(6))None>>>numbers[1, 2, 3, 4, 5, 6]>>>value=None>>>value>>>print(value)None

In this code snippet, you useprint() to show the return value of.append(), which isNone, as you can see.

Note that you can always access the content of a given variable by typing the variable’s name and pressingEnter after it, as you did withnumbers. However, if the variable is currently pointing toNone, then you won’t get anything on your screen. You’ll have to useprint(), as you did withvalue.

Flagging and Understanding Errors

When an error occurs in a REPL session, the interpreter automatically prints the corresponding error message andtraceback. Then, it loops back to the REPL’s primary prompt. In the following examples, you’ll see this behavior in action:

>>>greeting="Hello, World!  File"<python-input-0>", line1greeting="Hello, World!^SyntaxError:unterminated string literal (detected at line 1)>>>42/0Traceback (most recent call last):  File"<python-input-1>", line1, in<module>42/0~~~^~~ZeroDivisionError:division by zero>>>sum()Traceback (most recent call last):  File"<python-input-2>", line1, in<module>sum()~~~^^TypeError:sum() takes at least 1 positional argument (0 given)

In the first example, the string literal isn’t properly closed with a double quote ("). This raises aSyntaxError. The second example raises aZeroDivisionError exception because you’re trying to divide42 by0. In the final example, you call the built-insum() function without arguments, which raises aTypeError.

All these errors are immediately printed on the screen. This behavior allows you to quickly and carefully inspect the error message and traceback in order to track the underlying issue and fix your code.

Using the_ Implicit Variable

Every time you run an expression, the REPL internally stores the resulting value in an internalvariable whose name is a singleunderscore (_). You can access and use this variable like any other variable in Python.

Here are a couple of examples that show the implicit_ variable in action:

>>>42<7False>>>_False>>>12+3042>>>_42

In these examples, you evaluate expressions that produce a return value, which is automatically assigned to the_ variable every time.

When it comes to function calls, if the target function returns a value different fromNone, then_ will hold that value. In contrast, if the function returnsNone, then the_ variable will keep the value of the preceding operation:

>>>pow(4,2)16>>>_16>>>print("Hello, World!")Hello, World!>>>_16

The built-inpow() function computes the power of a number to a given exponent, returning the result. Because the function’s result differs fromNone, the_ variable is automatically reassigned. In contrast, if you call a function that returnsNone, likeprint(), then the_ variable remains unchanged.

In the example below, you use anassignment statement to create and initialize acounter variable:

>>>counter=0>>>_16>>>counter0>>>_0

Assignments aren’t expressions, so they don’t return any value. Instead, they store a reference to a value in a variable. In this case, the_ variable isn’t updated after running the assignment. That’s why this variable still contains the number16 from the previous examples.

Note that accessing a variable in an interactive session returns the value referenced by the variable. In this case, that value is also assigned to the_ variable.

Because_ is a regular Python variable, you can use it in expressions and statements:

>>>numbers=[1,2,3,4]>>>len(numbers)4>>>sum(numbers)/_2.5

In this example, you first create a list of values. Then, you calllen() to get the number of values in the list. Python automatically stores this value in the_ variable. Finally, you use_ to compute the average of your list of values.

Keep in mind that the_ variable is only implicitly defined in interactive mode. If you run your code in script mode, then you won’t get this implicit behavior, and trying to use_ without a manual definition will cause aNameError exception.

Reloading Imported Modules

Say that you’re writing a Pythonmodule with some functions for one of your projects. At the same time, you’re using Python in interactive mode to test the module’s code in real time. For example, say that you have the followingmodule:

defgreet(name="World"):print(f"Hello,{name}!")

In this file, you define agreet() function that prints a greeting message on the screen. Here’s how to load and use this code from a REPL session:

>>>importgreeting>>>greeting.greet()Hello, World!>>>greeting.greet("Pythonista")Hello, Pythonista!

Now say that you want to add a newargument to your function. The argument will be aBoolean flag that allows printing the greeting message in uppercase letters. To do this, you modify the function to look something like this:

defgreet(name="World",upper=False):greeting=f"Hello,{name}!"ifupper:greeting=greeting.upper()print(greeting)

This update allows you to callgreet() with anupper argument. If you set the argument toTrue, then the message will be in uppercase letters. Now you’re eager to try your changes in your REPL session. So, you import the module again, hoping to run the new version ofgreet() as follows:

>>>importgreeting>>>greeting.greet("Pythonista",upper=True)Traceback (most recent call last):  File"<python-input-4>", line1, in<module>greeting.greet("Pythonista",upper=True)~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^TypeError:greet() got an unexpected keyword argument 'upper'

What? An unexpected argument? Forefficiency reasons, running the import again after updating something ingreeting.py doesn’t reload the module.

If you want to work around this behavior without terminating your current REPL session and starting a new one, then you can use thereload() function from theimportlib module:

>>>importimportlib>>>importlib.reload(greeting)<module 'greeting' from '.../greeting.py'>>>>greeting.greet("Pythonista",upper=True)HELLO, PYTHONISTA!

Now your function works! Thereload() function has taken care of loading the new version of yourgreeting.py module. You can use this trick whenever you’re working on a module in yourcode editor and testing your changes in a REPL session.

Now that you’ve learned the basics of entering and executing code in a Python interactive shell, it’s time to explore and learn about a few editing features that the standard REPL provides.

Code History and Navigation

The standard REPL logs a complete history of all the code that you’ve typed and run while working in interactive mode. This history is saved to a file called.python_history, typically located in your home directory.

While in interactive mode, you can browse this history by using the arrow keys on your keyboard. With theUp key, you can go back in history. WithDown, you can go forward in history. The navigation starts from the end of the history file and goes up. Every time you press theUp key, you jump to the previous line of code in your history.

Once you find the line or block you want, edit it as needed and pressEnter to accept it.

Before Python 3.13, you could only navigate the history one line at a time. This is counterintuitive when you want to reuse a compound statement with an indented block because you don’t get the entire statement—only individual lines that keep their indentation.

Starting with Python 3.13, you can use the arrow keys on the primary prompt to navigate the history. If the REPL finds a compound statement with an associated code block, then you’ll get the whole code snippet. Here’s a quick example of a function definition:

PressingUp will recall the most recent single-line or multiline block. You can modify a multiline block by navigating it with the arrow keys. Once updated, you can accept the code by pressingEnter at the last line in the block.

Finally, in Python 3.13, you can pressF2 in a REPL session to open a pager that shows your input history without prompts and outputs. This tool allows you to browse your code history to find a specific piece of code. Once you locate the desired snippet, you can select and copy it to reuse in a program or module.

You can use the up and down arrow keys to navigate the history, and press theQ key to leave the code history pager.

Auto-Indentation

Before Python 3.13, entering compound statements in the REPL required manual indentation. Forgetting to indent would raise an error, as you’ve seen:

>>>x=1>>>ifx>0:...print("positive")  File"<stdin>", line2print("positive")^IndentationError:expected an indented block after 'if' statement on line 1

Starting with Python 3.13, after typing the colon in a compound statement’s header, the next line will automatically indent to the next level:

>>>x=1>>>ifx>0:...print("positive")...else:...print("non‑positive")...positive

The standard REPL in Python 3.13 and later manages indentation automatically for you, which is a great productivity booster. It also helps you avoid accidentalIndentationError exceptions.

Safe Multiline Paste and Paste Mode

Pasting multiline or indented code is more reliable in Python 3.13 and later:

>>>defgreet(name="World"):...print(f"Hello,{name}!")......name=input("What is your name? ")......greet(name)...What is your name? JohnHello, John!

If you have issues pasting large or complex code blocks, then you can pressF3 to activate thepaste mode. In this mode, the prompt changes to(paste). Any pasted code is then accepted exactly as written:

(paste) def greet(name="World"):(paste)     print(f"Hello, {name}!")(paste)(paste)(paste) name = input("What is your name? ")(paste)(paste) greet(name)...What is your name? JaneHello, Jane!

You can exit paste mode by pressingF3 again. In some situations, pasting code that contains indentation or blank lines, or pasting without activating paste mode, may cause unexpected errors.

Quick REPL Commands

In Python 3.13 and later, certain REPL commands no longer require you to call them as functions with parentheses. These commands include the following:

• exit orquit: Exit the interpreter
• help: Access the help system
• clear: Clear the screen

Now you can type any of these commands and pressEnter to run the associated action. You can still use parentheses and type something likeexit() if you prefer. Additionally, you can pressF1 to open the Python help system directly.

Note that these commands aren’t reserved. That means you can shadow them with a variable assignment:

>>>exit=True>>>exitTrue>>>exit()Traceback (most recent call last):...TypeError:'bool' object is not callable>>>delexit>>>exit

Here, you create a variable namedexit, effectively disabling theexit command. To terminate your REPL session, you can either delete theexit variable or use one of the alternative ways to exit the interpreter.

Code Autocompletion

The standard Python REPL supportsTab completion to help you write code with fewer keystrokes. When you type the beginning of a name and pressTab, the REPL will try to complete it automatically or show a list of possible matches.

Before Python 3.13, autocompletion acted on the following contexts:

• Keywords
• Built-in functions, data types, and exceptions
• Names defined in your current namespace
• Names of imported objects, modules, and packages
• Object, attribute, and method names when using dot notation

For example, when you start to type a Python keyword, you can pressTab to trigger autocompletion. Python will search in its list of keywords and complete your input as expected. This works similarly for the rest of the names in your current namespace.

When you type the name of an object and type a dot to access an attribute or method (member) on that object, you can also pressTab twice to display a list of members:

>>>list.<Tab><Tab>list.append(   list.copy(     list.extend(   list.insert(list.pop(      list.reverse( list.clear(    list.count(list.index(    list.mro()     list.remove(   list.sort(>>>list.

The resulting list gives you a complete context of the current object’s capabilities so that you can use the right tool. If you start typing the name of a member and pressTab, then Python will complete the name for you.

If there are several names that start with the entered text, then you’ll get a filtered list by pressingTab again:

>>>list.re<Tab><Tab>list.remove(   list.reverse(>>>list.re

Python 3.13 refined autocompletions to improve your user experience:

>>>list.<Tab>[ not unique ]

Now, when you pressTab after the dot, you get a message indicating that the object has several members. You can pressTab again to get the list of members:

>>>list.<Tab><Tab>list.append(   list.copy(     list.extend(   list.insert(list.pop(      list.reverse(   list.clear(    list.count(list.index(    list.mro()     list.remove(   list.sort(

Once you have this list displayed, Python filters suggestions more smoothly as you type extra characters, and there’s no need to pressTab again. For example, if you start to type.re, you’ll see how the REPL filters the names:

>>>list.relist.remove(   list.reverse(

Python 3.14 extends the autocompletion logic to recognizeimport contexts and suggestmodule orpackage names accordingly. Now, when you type animport orfrom ... import statement and pressTab, the REPL will search theimport path for available module names matching the partial text.

For example, if you typeimport and then pressTab twice, you’ll get the complete list of currently available modules and packages:

>>>import<Tab><Tab>abc              curses           hmac             pickle           shlex...

If you start typing a module’s name likepat and pressTab, the REPL will automatically complete thepathlib name because it matches uniquely with the partial text.

Similarly, if you type something likeimport lo and pressTab afterlo, then you’ll get a message saying that the match isn’t unique. Once there, you can pressTab again to get the complete list of matching names or continue typing to make the search pattern more specific:

>>>importlo<Tab><Tab>locale   logging

In this example, the REPL filters the names so you only get the modules that start withlo. Now you can quickly pick which one you want to use.

Syntax Highlighting

Python 3.14 introduced live syntax highlighting in the standard REPL. This means that as you type, keywords, strings, numbers, operators, and other syntax tokens are colored in terminals that support ANSI escape codes. This makes interactive sessions easier to scan and closer to an editor or IDE experience.

Here’s a quick example of how the syntax highlighting works:

In a supporting terminal, keywords, strings, built-in names, comments, and other tokens are nicely colored. Tracebacks are also highlighted, with filenames, line numbers, and error types emphasized for better readability.

In thePython 3.14 Preview: REPL Autocompletion and Highlighting tutorial, you can learn how the syntax highlighting feature works and how to customize it.

Using Python’s Built-in Help System

The built-inhelp() function gives you access to Python’shelp system. You can use this function in two main ways:

1. Withno arguments to enter Python’s help system
2. With anobject or its name as a string to access the object’s help page

In Python 3.13 and later, you can also enter the help system using thehelp command or by pressingF1, as you already learned:

>>>help()# Or help or press F1

Once you run this, you’ll immediately notice that the prompt changes from>>> tohelp>. This new prompt reminds you that you’re in the interactive help system.

In help mode, you can enter keywords, module names, function names, or any other name. The help system will search for the target name and present the associated documentation page. To try this functionality out, go ahead and typesys at thehelp> prompt, then pressEnter. You’ll get an output like the following:

Help on built-in module sys:NAME    sysMODULE REFERENCE    https://docs.python.org/3.14/library/sys.html    The following documentation is automatically generated from the Python    source files.  It may be incomplete, incorrect or include features that    are considered implementation detail and may vary between Python    implementations.  When in doubt, consult the module reference at the    location listed above....

To navigate the page, you can use theUp andDown keys or theEnter key to move down. To exit the page, press theQ key on your keyboard.

The help system allows you to search for different topics. You can get the whole list of available topics by typingtopics and pressing theEnter key:

help> topicsHere is a list of available topics.  Enter any topic name to get more help.ASSERTION                 EXCEPTIONS                PACKAGESASSIGNMENT                EXECUTION                 POWERASSIGNMENTEXPRESSIONS     EXPRESSIONS               PRECEDENCEATTRIBUTEMETHODS          FLOAT                     PRIVATENAMES...

Next, you can just type the desired topic name and pressEnter. For example, here’s the page for theASSERTION topic:

The "assert" statement**********************Assert statements are a convenient way to insert debugging assertionsinto a program:   assert_stmt: "assert" expression ["," expression]...

In this example, you first search for theASSERTION topic. This search finds and shows the corresponding help page. You can also search for keywords, built-in names,standard-library modules, and more.

Once you’ve found the required information, you can exit the help system by typingq orquit and then pressingEnter. This will return you to your REPL session.

When you callhelp() with an object as an argument, you get its associated help page, which typically displays information from the object’sdocstrings. It may also include a list of methods and attributes.

For example, here’s a fragment from the page of thestr class that you can access by typinghelp(str) in your REPL session:

>>>help(str)Help on class str in module builtins:class str(object) |  str(object='') -> str |  str(bytes_or_buffer[, encoding[, errors]]) -> str | |  Create a new string object from the given object. If encoding or |  errors is specified, then the object must expose a data buffer |  that will be decoded using the given encoding and error handler. |  Otherwise, returns the result of object.__str__() (if defined) |  or repr(object). |  encoding defaults to 'utf-8'. |  errors defaults to 'strict'. | |  Methods defined here: | |  __add__(self, value, /) |      Return self+value. | |  __contains__(self, key, /) |      Return bool(key in self)....

In this example, you use thestr class object as an argument tohelp(). Again, you can use theUp andDown keys to move through the page. When you reach the desired information, you can press theQ key to exit the page viewer.

If you use a string as an argument tohelp(), then the help system looks for it as the name of a module, function, class, method, keyword, or documentation topic. The corresponding help page is then displayed on the screen.

For example, say that you want to get help on thepathlib module, but you haven’t imported it yet. You can then runhelp() with the string"pathlib" as an argument. You’ll get something like the following:

>>>help("pathlib")Help on package pathlib:NAME    pathlib - Object-oriented filesystem paths.MODULE REFERENCE    https://docs.python.org/3.14/library/pathlib.html    The following documentation is automatically generated from the Python    source files.  It may be incomplete, incorrect or include features that    are considered implementation detail and may vary between Python    implementations.  When in doubt, consult the module reference at the    location listed above....

The call tohelp() with the"pathlib" string as an argument displays the module’s help page. Note that if you callhelp() with thepathlib name as an argument, then you’ll get aNameError because you haven’t imported the module into your current namespace.

Introspecting Your Code Dynamically

When you’re working in a REPL session, you have direct access to some Python built-in tools that you can use to introspect your code and obtain more information and context on the objects that you’re working with.

Some of these built-in tools include the following:

You can use any of these built-in functions to introspect your code and retrieve useful information that you can later use in yourdebugging process.

For example, say that you’re working withdictionaries and want to get a list of all the methods and attributes in this data type. You can do something like this:

>>>dir(dict)['__class__', ..., 'popitem', 'setdefault', 'update', 'values']

The output in this example shows a list of names as strings. This list includes the attributes and methods defined in thedict class.

Thevars() function works similarly todir() but returns a dictionary of name-object pairs instead of a list.

Thelocals() andglobals() functions can also be useful when you want to know the names defined in a given scope in your code. Finally, thetype() function helps you determine the data type or class of a given object in your code.

Providing a Startup File

The standard REPL accepts a startup file that you can use to tweak some features or add new features to your interactive sessions. This file only runs for interactive sessions. It doesn’t run when you execute a program as an executable script. So, you don’t have to worry about corrupting important programs.

The startup file may contain any executable Python code. This code will run before the first prompt is displayed in interactive mode.

It’s important to note that the startup file runs in the samenamespace where you’ll be running your interactive code. So, objects defined or imported in this file will be available in your interactive session. This behavior is useful when you want to load tools and customize the features of your interactive shell.

Before doing some cool stuff with a startup file, you need to learn how to tell the interpreter which file you want to use as your startup file. You do this by setting thePYTHONSTARTUP environment variable in your system’s shell.

If you’re on Linux or macOS, then you can go to your home folder and run the following commands:

• Linux
• macOS

$echo"export PYTHONSTARTUP=~/.pythonstartup">>.bashrc&&exec"$SHELL"

$echo"export PYTHONSTARTUP=~/.pythonstartup">>.zshrc&&exec"$SHELL"

Linux and macOS shells automatically load their corresponding configuration file whenever you fire up a terminal or command-line window. This way, you ensure that thePYTHONSTARTUP variable is always available on your system.

In this example, you set thePYTHONSTARTUP variable to~/.pythonstartup, which is the path to your target startup file. The file will live in your home directory, and its filename will be.pythonstartup.

Note that the filename isn’t important. You can name it whatever you want. You can also put the file in whatever directory you want. Just make sure that yourPYTHONSTARTUP environment variable points to the right file path.

If you’re on Windows, then check out theConfiguring Environment Variables section inYour Python Coding Environment on Windows: Setup Guide for a complete guide to creating system variables. Follow the instructions and add aPYTHONSTARTUP system variable with a suitable path.

Once you’ve set thePYTHONSTARTUP variable, go ahead and create the.pythonstartup file in the selected folder. Open the file in your code editor and get ready to add some code. To kick things off with your custom startup file, you’ll start by adding some imports:

fromimportlibimportreloadfrompprintimportpp

As you already learned, theimportlib.reload() function allows you to reload modules when you modify their content so that you can test your changes. Having this function always available in your interactive sessions will save you from an additional import.

Thepp() function from thepprint module allows you to print pretty-formatted data structures, such as lists and dictionaries. This function can be of great help when you’re trying to debug some interactive code.

To try these features, open a new terminal window. Then, run Python in interactive mode. Once there, run the following code:

>>>pp(globals()){'__name__': '__main__', ... '__builtins__': <module 'builtins' (built-in)>, 'reload': <function reload at 0x101455c60>, 'pp': <function pp at 0x1014f3380>}

Cool! Thepp() function is already available for use. Note thatreload() also appears as an entry in your current global namespace.

You can add whatever imports you want to your REPL’s startup file. This is a nice, quick way to have useful tools at your disposal whenever you run an interactive session.

You’ll find many other interesting tweaks and customizations to add to your REPL’s startup file. Don’t be shy! Go ahead and experiment to improve your user experience and your productivity when you work in interactive mode.

Colorizing REPL Output for Python Before 3.13

TheRich library allows you to userich text and pretty formatting in the terminal. Rich includes highlighted or colorized pretty printing. You can use this feature to colorize the standard REPL’s output if you’re using a Python version earlier than 3.13.

To take advantage of Rich, you first need topip install it from thePython Package Index (PyPI) using the following command:

$python-mpipinstallrich

Once you’ve run this command, you’re ready to colorize your REPL’s output. Here’s how you do it in an interactive session:

>>>fromrichimportpretty,traceback>>>pretty.install()>>>traceback.install(show_locals=False)

From this point on, every time you get an output message in your current REPL session, that output will be colorized and formatted:

Note that this added capability is temporary. It only applies to the interactive session where you ran the code above. If you want this feature to be available in every session, then use your startup file:

fromimportlibimportreloadfrompprintimportpptry:fromrichimportpretty,tracebackexceptModuleNotFoundError:passelse:pretty.install()traceback.install(show_locals=False)

With this update to your REPL’s startup file, you replicate the output colorizing and formatting behavior in all the interactive sessions with access to the Rich library. Thetry …except …else blocks guarantee that your startup file won’t throw an error if Rich isn’t available in the Python environment you’re using.

Customizing the Color Theme in Python 3.14 and Later

As you already learned, Python 3.14 incorporated syntax highlighting in the new standard REPL. The default colors and font formatting settings for the syntax highlighting feature are as follows:

You can customize these colors by using_colorize.set_theme(). You can invoke this function during a session or use your custom startup file to tweak the colors to use for every syntax element.

You already know how to create a.pythonstartup file in your home folder and how to set up thePYTHONSTARTUP variable. In the example below, you’ll reuse the startup file from the sectionProviding a Startup File. Here’s how you need to modify the file to tweak the REPL’s color theme:

fromimportlibimportreloadfrompprintimportpptry:fromdataclassesimportreplacefrom_colorizeimportANSIColors,default_theme,set_themeexceptImportError:passelse:theme=default_theme.copy_with(syntax=replace(default_theme.syntax,keyword=ANSIColors.BOLD_YELLOW,string=ANSIColors.INTENSE_BLUE,number=ANSIColors.RED,comment=ANSIColors.GREY,),)set_theme(theme)

Here’s a quick summary of what the startup script does:

• Importsreplace() fromdataclasses and the_colorize API, includingANSIColors,default_theme, andset_theme()
• Uses atry …except block to skip Python versions without_colorize, avoiding errors
• Creates a new theme by copyingdefault_theme and overriding selected syntax colors:keyword,string,number,comment
• Callsset_theme() so the custom colors are applied before the first prompt

With this file in place, go ahead and open a new terminal window. Below is a visual comparison of the default theme and your custom one:

On the left, you have the default color theme, and on the right, you have your custom color theme. You can play around with other color combinations and create your own theme using your favorite colors and font formatting. Go ahead and give it a try!