session3/notebooks/2_functions_from_modules.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using functions from Python modules\n",
    "\n",
    "Placing all your functions directly in a notebook can lead to clutter and complexity, particularly as your project expands, making it harder to navigate and maintain. Also, we probably want to use some of these functions in other notebooks too. Organizing functions into modules is a smarter approach, offering clarity, structure, and reusability.\n",
    "\n",
    "### What are Python modules?\n",
    "Python modules are python files (i.e. with a `.py` extension) where we store our python code that we tend to re-use (e.g. python functions) in other places (notebooks, CLIs, etc.). Python modules are usually stored in a folder called `src` (which stands for *source*). Once we store our functions in Python modules, we can then import them and use them. \n",
    "\n",
    "In this notebook, instead of defining the functions here, we are going to store them inside Python modules and import them inside the notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example**: Create a Python module called `stats.py` in the folder `src`. Move the `calculate_mean` function in it. Import the function from the module and make sure it works by testing a couple of different cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First we need to make sure our python environment knows about the folder \"src\" (we only need to do this once)\n",
    "import sys\n",
    "sys.path.append('../src')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from stats import calculate_mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [1, 4, 7]\n",
    "mean = calculate_mean(data)\n",
    "\n",
    "mean == 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [3, 3, 5, 7, 7]\n",
    "mean = calculate_mean(data)\n",
    "\n",
    "mean == 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**: Add a function called `calcualte_std` to the `stats.py` module such that following code runs. Compare the result of this function with Numpy's `std` method. Do they yield the same value?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from stats import calculate_std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [-8, -4, 0, 4, 8]\n",
    "std = calculate_std(data)\n",
    "\n",
    "std == np.std(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**: Add a function called `calcualte_median` to the `stats.py` module such that following code runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from stats import calculate_median"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [1, 4, 2, 2, 3, 4, 5]\n",
    "\n",
    "median = calculate_median(data)\n",
    "\n",
    "median == 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**: Create a new Python module called `transformations.py`. Add a function called `normalize` to the `transformations.py` module such that following code runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformations import normalize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_normalized = normalize(data)\n",
    "\n",
    "data_normalized.min() == 0, data_normalized.max() == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**: Let's use a function to plot and compare the original data vs the standardized and the normalized version. Create a new Python module called `visualizations.py`. Add a function called `plot_histogram` to the `visualizations.py` module. Import the function and use it to plot `data`, `data_standardized`, and `data_normalized`, each in a different cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from visualizations import plot_histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_histogram(data)\n",
    "plt.xlim(-5, 15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_histogram(data_standardized)\n",
    "plt.xlim(-5, 15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_histogram(data_normalized)\n",
    "plt.xlim(-5, 15)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}