Convert Jupyter Notebook to Python Script in 3 Ways

Files are saved in the .ipynb format in Jupyter Notebook. It's a Markdown, code-filled JSON document with outputs. We would want to convert Jupyter Notebook to ordinary Python script in a number of situations. For instance, you could want to make your notebook an independent package or maintain Python code in the repository. ere are three methods you can use to export a Jupyter Notebook file as a Python script:

1. Save the Code as a .py file Using the GUI

It combines Python programming with Markdown. The outputs are the Pandas DataFrame and Figure. The following image displays the notebook:

Convert Jupyter Notebook to Python Script in 3 Ways

The notebook is kept in an ipynb file format. The contents of the notebook.ipynb file are shown below.

 
{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "intro-section",
   "metadata": {},
   "source": [
    "## Sample Jupyter Notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "import-libraries",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary libraries for plotting and data manipulation\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "plot-graph",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoA... (output truncated)",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a simple plot with some data points\n",
    "_ = plt.plot([1, 3, 2, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "create-dataframe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>col1</th>\n",
       "      <th>col2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>20</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</td>\n",
       "      <td>30</td>\n",
       "      <td>60</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   col1  col2\n",
       "0    10    40\n",
       "1    20    50\n",
       "2    30    60"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a simple DataFrame with two columns\n",
    "pd.DataFrame({\"col1\": [10, 20, 30], \"col2\": [40, 50, 60]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "empty-cell",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python-env",
   "language": "python",
   "name": "python-env"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}   

The notebook is made up of many cell types. Information about the source and outputs is contained in each cell (in many forms). Base64 is used to encode images.

To export the notebook to a Python.py file, we may utilise the Jupyter Notebook's User Interface. Please choose Python (.py) under File->Download as.

The web browser will download the file notebook.py, which contains the following content:

 
#!/usr/bin/env python
# coding: utf-8
# ## Example notebook
# In[1]:
import matplotlib.pyplot as plt
import pandas as pd
# In[3]:
_ = plt.plot([5, 3, 2, 4])
# In[4]:
pd.DataFrame({"x": [7, 8, 9], "y": [10, 11, 12]})
# In[ ]:   

There are no outputs. Additional remarks are included with details regarding cells: # In [1]. There are comments on the Markdown text. The beginning of the file now includes the Python shebang.

2. To Convert a Jupyter Notebook to a Python file, Open the Command Line Interface

Use the command to export the notebook as a .py file. A utility called nbconvert is accessible. Because it is utilised internally (in the Download as feature), it is installed with Jupyter Notebook.

Example output:

 
[NbConvertApp] Converting notebook notebook.ipynb to python
[NbConvertApp] Writing 233 bytes to notebook.py

The content of the generated Python file is identical to that of the User Interface file.

3. Use jupytext to Link the Jupyter Notebook with a Python Script

To keep a Jupyter Notebook and a Python script in sync, use the jupytext package. This makes sure that both files contain the same code .py and pynb. Moreover, a command line version is accessible.

You may use the following instructions to install Jupytext:

 
pip install jupytext
# or 
conda install jupytext -c conda-forge   

Following installation, a new menu under File will be accessible. You may choose how the Python script and your notebook are paired:

Below is the light-formatted Python script from the sample notebook:

 
# ## Example notebook
import matplotlib.pyplot as plt
import pandas as pd
_ = plt.plot([5, 3, 2, 4])
pd.DataFrame({"x": [7, 8, 9], "y": [10, 11, 12]})   

Below is the same script shown in percentage terms. Cell boundaries are shown as #%%. Numerous IDEs (including PyCharm, Spyder, and VS Code) support this format.

 
# %% [markdown]
# ## Example notebook
# %%
import matplotlib.pyplot as plt
import pandas as pd
# %%
_ = plt.plot([5, 3, 2, 4])
# %%
pd.DataFrame({"x": [7, 8, 9], "y": [10, 11, 12]})
# %%   

The Python script will be updated each time a notebook file is saved.

 
jupytext --to py notebook.ipynb             
jupytext --to py:percent notebook.ipynb   

Summary:

One excellent tool for experimenting with programming and sharing it with others is the Jupyter Notebook. It stores code, Markdown, and outputs as JSON in an ipynb file. The command line or the user interface can be used to do it. The two packages jupytext and nbconvert are important to keep in mind.

Next TopicFind elements of a list by indices in python

← prev next →