Example usage 

Suppose you started to explore your data and you have the following Python script,

import pandas as pd

df = pd.DataFrame({"x": [1, 2, 3], "y": ["a", "a", "b"]})

When integrated to the VS Code terminal, you can run selected lines with Shift + Enter. Running it the first time will start an IPython shell in your terminal. You can also open the Command Palette (Ctrl + Shift + P) and select Python: Start REPL.

In [1]: import pandas as pd
   ...:
   ...: df = pd.DataFrame({"x": [1, 2, 3], "y": ["a", "a", "b"]})

Before writing any more code to your script, you can explore your data set in the IPython console.

In [2]: df
Out[2]:
#    x  y
# 0  1  a
# 1  2  a
# 2  3  b

In [3]: df.describe()
Out[3]:
#          x
# count  3.0
# mean   2.0
# std    1.0
# min    1.0
# 25%    1.5
# 50%    2.0
# 75%    2.5
# max    3.0

In [4]: df["y"].value_counts()
Out[4]:
# a    2
# b    1
# Name: y, dtype: int64

You can also type ? after an object to inspect it.

In [5]: df?

# Type:        DataFrame
# String form:
#    x  y
# 0  1  a
# 1  2  a
# 2  3  b
# Length:      3
# File:        ~/mambaforge/envs/data-science/lib/python3.11/site-packages/pandas/
# core/frame.py
# Docstring:
# Two-dimensional, size-mutable, potentially heterogeneous tabular data.

Figures 1 and 2 show auto-completion features of IPython that allows you to type less.

Figure 1: Command history cache in IPython. You can navigate the history with arrows keys or get completion for previous commands.

Figure 2: Tab completion in IPython. Start typing and press Tab to get options of objects or methods that match the text.

IPython vs Jupyter console 

Yes, JupyterLab console and VS Code’s interactive window are effectively an IPython console. However they share the same flaw: they are associated with a single .py or .ipynb file.

This makes all the difference. It induces you to work on a single file. Even while exploring and testing, you should be thinking how to organize modules at different files.

IPython profiles 

IPython can use multiple profiles, with separate configuration and history. By default, if you don’t specify a profile, IPython always runs in the default profile.

Profiles have a configuration file which you can use to customize IPython options. If you don’t have one yet (usually at ~/.ipython/profile_default/ipython_config.py), you may create it with

# Create an IPython profile by name
# If `profilename` is empty, use the default profile
$ ipython profile create [profilename]

# Check config file's location
$ ipython locate profile [profilename]

Use --profile option in VS Code settings to select a non-default profile.

{
    ...,
    "python.terminal.launchArgs": [
        "-m",
        "IPython",
        "--profile",
        "profilename"
    ],
    ...
}

Auto-reloading modules 

Imagine you have a Python module, bar.py, with some useful functions you will reuse on other script.

# bar.py
def foo():
    return "Hello World"

In [1]: from bar import foo

In [2]: foo()
Out[2]: 'Hello World'

Now suppose that you make some change to foo() function in the bar.py file.

# bar.py
def foo():
    return "Hey, you"

You would like that to be updated in your IPython session too, because you want to be iterative with your code. However, that is not the default behavior.

In [3]: from bar import foo

In [4]: foo()
Out[4]: 'Hello World'

If you are not working at a single gigantic Python file or Jupyter notebook that does everything but instead building a maintainable modular code, it would be too troublesome and time-consuming to close the terminal, reopen IPython and reload functions/classes from modules every time there are changes. When exploring data or models it is even worse, since you have to reload data or maybe re-run a training step.

Fortunately, there is an built-in extension called autoreload to change that behavior (and with some flexibility).

%autoreload 2 Reload all modules (except those excluded by %aimport) every time before executing the Python code typed.

In [5]: %load_ext autoreload

In [6]: %autoreload 2

In [7]: foo()
Out[7]: 'Hey, you'

The argument 2 tells autoreload to reload all modules every time before executing the Python code typed. You can automate this step with your IPython configuration file so you don’t need to repeat the commands at every session start up.

Open your profile’s configuration file (ipython_config.py) and change/add these lines:.

## A list of dotted module names of IPython extensions to load.
#  Default: []
c.InteractiveShellApp.extensions = ["autoreload"]

## lines of code to run at IPython startup.
#  Default: []
c.InteractiveShellApp.exec_lines = ["%autoreload 2"]