08-functions-and-modules-in-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Data Visualization with Modern Data Science\n",
    "\n",
    "> Functions and modules in Python\n",
    "\n",
    "Yao-Jen Kuo <yaojenkuo@ntu.edu.tw> from [DATAINPOINT](https://www.datainpoint.com/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Structuring codes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is structuring codes?\n",
    "\n",
    ">  By \"structure\" we mean the decisions you make concerning how your codes best meet their objectives. We need to consider how to best leverage Python's features to create clean, effective code. In practical terms, \"structure\" means making clean code whose logic and dependencies are clear as well as how the files and folders are organized in the file system.\n",
    "\n",
    "Source: [The Hitchhiker’s Guide to Python](https://docs.python-guide.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Why structuring codes?\n",
    "\n",
    "As our codes piled up, we need a mechanism making them:\n",
    "\n",
    "- more reusable\n",
    "- more scalable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python provides several tools for programmers organizing their codes\n",
    "\n",
    "- Functions\n",
    "- Classes\n",
    "- Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## How do we decide which tool to adopt?\n",
    "\n",
    "Simply put, that depends on **scale** and project spec."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## These components are mixed and matched with great flexibility\n",
    "\n",
    "- A couple lines of code assembles a function\n",
    "    - A couple of functions assembles a class\n",
    "        - A couple of classes assembles a module\n",
    "            - A couple of modules assembles a larger module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is a function\n",
    "\n",
    "> A function is a named sequence of statements that performs a computation, either mathematical, symbolic, or graphical. When we define a function, we specify the name and the sequence of statements. Later, we can call the function by name."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Besides built-in functions or library-powered functions, we sometimes need to self-define our own functions\n",
    "\n",
    "- `def` the name of our function\n",
    "- `return` the output of our function\n",
    "\n",
    "```python\n",
    "def function_name(INPUTS, ARGUMENTS, ...):\n",
    "    \"\"\"\n",
    "    docstring: print documentation when help() is called\n",
    "    \"\"\"\n",
    "    # sequence of statements\n",
    "    return OUTPUTS\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Various source of functions\n",
    "\n",
    "- Built-in functions: <https://docs.python.org/3/library/functions.html>\n",
    "- Functions defined in standard libraries: <https://docs.python.org/3/library>\n",
    "- Functions defined in third-party libraries.\n",
    "- Functions defined by ourselves."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Built-in functions\n",
    "\n",
    "<https://docs.python.org/3/library/functions.html>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pow(5, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Functions defined in standard libraries\n",
    "\n",
    "<https://docs.python.org/3/library>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "randint(1, 11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Functions defined in third-party libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 6, 2, 8, 7])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy.random import randint\n",
    "\n",
    "randint(1, 10, size=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Functions defined by ourselves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def power(x, n):\n",
    "    out = x**n\n",
    "    return out\n",
    "\n",
    "power(5, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The use of `def` and `return` keywords\n",
    "\n",
    "- `def` a name tag for a code block.\n",
    "- `return` the expected outputs.\n",
    "- `return` marks the end of a code block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# def a name tag for a code block\n",
    "def power(x, n):\n",
    "    pass\n",
    "\n",
    "power(5, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# return the expected outputs\n",
    "def power(x, n):\n",
    "    print(x)\n",
    "    print(n)\n",
    "    out = x**n\n",
    "    return out\n",
    "\n",
    "power(5, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# return marks the end of a code block.\n",
    "def power(x, n):\n",
    "    out = x**n\n",
    "    return out\n",
    "    print(x)\n",
    "    print(n)\n",
    "\n",
    "power(5, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## When it comes to defining functions, it is vital to understand the scope of an object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is scope?\n",
    "\n",
    "> In computer programming, the scope of a name binding, an association of a name to an entity, such as a variable, is the region of a computer program where the binding is valid.\n",
    "\n",
    "Source: <https://en.wikipedia.org/wiki/Scope_(computer_science)>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Simply put, now we have a self-defined function, so the programming environment is now split into 2:\n",
    "\n",
    "- Global\n",
    "- Local"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## An object declared within the indented block of a function is a local object, it is only valid inside the `def` block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 is a even number.\n",
      "name 'x' is not defined\n"
     ]
    }
   ],
   "source": [
    "def check_odd_even(x):\n",
    "    mod = x % 2 # local object, declared inside def block\n",
    "    if mod == 0:\n",
    "        return '{} is a even number.'.format(x)\n",
    "    else:\n",
    "        return '{} is a odd number.'.format(x)\n",
    "\n",
    "print(check_odd_even(0))\n",
    "try:\n",
    "    print(x)\n",
    "except NameError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name 'mod' is not defined\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(mod)\n",
    "except NameError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## An object declared outside of the indented block of a function is a global object, it is valid everywhere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 is a even number.\n",
      "0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "mod = x % 2\n",
    "def check_odd_even():\n",
    "    if mod == 0:\n",
    "        return '{} is a even number.'.format(x)\n",
    "    else:\n",
    "        return '{} is a odd number.'.format(x)\n",
    "\n",
    "print(check_odd_even())\n",
    "print(x)\n",
    "print(mod)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Although global object looks quite convenient, it is HIGHLY recommended NOT using global object directly in a indented function block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using global objects in functions results in naming ambiguity between parameters versus arguments\n",
    "\n",
    "- Objects used in `def` code block: parameters.\n",
    "- Objects used in calling functions: arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "125\n"
     ]
    }
   ],
   "source": [
    "def power(x, n):\n",
    "    out = x**n # Parameters\n",
    "    return out\n",
    "\n",
    "a = 5 # Argument\n",
    "b = 3 # Argument\n",
    "print(power(a, b)) # Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Mapping relationship"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The principle of designing of a function is about mapping the relationship between inputs and outputs\n",
    "\n",
    "- The one-on-one relationship\n",
    "- The many-on-one relationship\n",
    "- The one-on-many relationship"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The one-on-one relationship\n",
    "\n",
    "Using scalar as input and output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def absolute(x):\n",
    "    \"\"\"\n",
    "    Return the absolute value of the x.\n",
    "    \"\"\"\n",
    "    if x >= 0:\n",
    "        return x\n",
    "    else:\n",
    "        return -x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Once the function is defined, call as if it is a built-in function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function absolute in module __main__:\n",
      "\n",
      "absolute(x)\n",
      "    Return the absolute value of the x.\n",
      "\n",
      "5566\n",
      "5566\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "help(absolute)\n",
    "print(absolute(-5566))\n",
    "print(absolute(5566))\n",
    "print(absolute(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The many-on-one relationship relationship\n",
    "\n",
    "- Using scalars or structures for fixed inputs\n",
    "- Using `*args` or `**kwargs` for flexible inputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using scalars for fixed inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "def product(x, y):\n",
    "    \"\"\"\n",
    "    Return the product values of x and y.\n",
    "    \"\"\"\n",
    "    return x*y\n",
    "\n",
    "print(product(5, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using structures for fixed inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "900\n"
     ]
    }
   ],
   "source": [
    "def product(x):\n",
    "    \"\"\"\n",
    "    x: an iterable.\n",
    "    Return the product values of x.\n",
    "    \"\"\"\n",
    "    prod = 1\n",
    "    for i in x:\n",
    "        prod *= i\n",
    "    return prod\n",
    "\n",
    "print(product([5, 5, 6, 6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using `*args` for flexible inputs\n",
    "\n",
    "- As in flexible arguments\n",
    "- Getting flexible `*args` as a `tuple`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 5, 6, 6)\n"
     ]
    }
   ],
   "source": [
    "def plain_return(*args):\n",
    "    \"\"\"\n",
    "    Return args.\n",
    "    \"\"\"\n",
    "    return args\n",
    "\n",
    "print(plain_return(5, 5, 6, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using `**kwargs` for flexible inputs\n",
    "\n",
    "- AS in keyword arguments\n",
    "- Getting flexible `**kwargs` as a `dict`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'district': 'Da-an', 'city': 'Taipei', 'country': 'Taiwan'}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def plain_return(**kwargs):\n",
    "    \"\"\"\n",
    "    Retrun kwargs.\n",
    "    \"\"\"\n",
    "    return kwargs\n",
    "\n",
    "plain_return(district='Da-an', city='Taipei', country='Taiwan')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The one-on-many relationship\n",
    "\n",
    "- Using default `tuple` with comma\n",
    "- Using preferred data structure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using default `tuple` with comma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('luke skywalker', 'LUKE SKYWALKER', 'lUKE SKYWALKER', 'Luke Skywalker')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def return_different_case_formats(x):\n",
    "    return x.lower(), x.upper(), x.swapcase(), x.title()\n",
    "\n",
    "return_different_case_formats(\"Luke skywalker\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using preferred data structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'lowerCased': 'luke skywalker',\n",
       " 'upperCased': 'LUKE SKYWALKER',\n",
       " 'swapCased': 'lUKE SKYWALKER',\n",
       " 'titleCased': 'Luke Skywalker'}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def return_different_case_formats(x):\n",
    "    out = {\n",
    "        \"lowerCased\": x.lower(),\n",
    "        \"upperCased\": x.upper(),\n",
    "        \"swapCased\": x.swapcase(),\n",
    "        \"titleCased\": x.title()\n",
    "    }\n",
    "    return out\n",
    "\n",
    "return_different_case_formats(\"Luke skywalker\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is a module in Python?\n",
    "\n",
    "A Python module is a file with the extension of `.py` which consists of a couple of functions or classes. A Python module can also be in the form of a folder which consists of a couple of files with the extension of `.py`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Standard modules\n",
    "\n",
    "- Modules distributed with Python are called **standard modules**.\n",
    "- We can literally **see** them in our environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `__file__` attribute to find the location of a certain module\n",
    "\n",
    "Use `import` keyword to specify the module we are about to leverage.\n",
    "\n",
    "```python\n",
    "import standard_module\n",
    "\n",
    "print(standard_module.__file__)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Navigate files using Terminal\n",
    "\n",
    "- Use `cd` to change directory. `cd` stands for change directory.\n",
    "- Type `cd path/of/modules/file/location` then press Enter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `ls` to see some standard modules\n",
    "\n",
    "- `ls` stands for list.\n",
    "- We can literally see some of the modules."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Create a module locally\n",
    "\n",
    "- Create an empty `my_module.py` in working directory.\n",
    "- Working directory refers to the path where we open Visual Studio Code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Copy the previously defined `symbolic_calculator` function and paste into `my_module.py`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# my_module.py\n",
    "def symbolic_calculator(x: int, y: int, operator: str):\n",
    "    operator_dict = {\n",
    "        \"+\": x + y,\n",
    "        \"-\": x - y,\n",
    "        \"*\": x*y,\n",
    "        \"/\": x/y\n",
    "    }\n",
    "    return operator_dict[operator]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Import pre-defined class from a module\n",
    "\n",
    "- Use `import` keyword to specify the module we are about to leverage.\n",
    "- Use `as` keyword for alias.\n",
    "\n",
    "```python\n",
    "import module_name\n",
    "import module_name as alias\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `.` to specify affiliations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "121\n"
     ]
    }
   ],
   "source": [
    "import my_module\n",
    "\n",
    "print(my_module.symbolic_calculator(55, 66, \"+\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "121\n"
     ]
    }
   ],
   "source": [
    "import my_module as mm\n",
    "\n",
    "print(mm.symbolic_calculator(55, 66, \"+\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Import specific feature from a module\n",
    "\n",
    "- A module may consist of a couple of functions or classes.\n",
    "- Use `from` and `import` keywords to leverage a specific feature.\n",
    "\n",
    "```python\n",
    "from module_name import class_name as alias\n",
    "from module_name import function_name as alias\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "121\n"
     ]
    }
   ],
   "source": [
    "from my_module import symbolic_calculator\n",
    "\n",
    "print(symbolic_calculator(55, 66, \"+\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "121\n"
     ]
    }
   ],
   "source": [
    "from my_module import symbolic_calculator as sc\n",
    "\n",
    "print(sc(55, 66, \"+\"))"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}