basic/Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Table of contents**<a id='toc0_'></a>    \n",
    "- [Function](#toc1_)    \n",
    "- [Python Function Types](#toc2_)    \n",
    "  - [Built-in functions](#toc2_1_)    \n",
    "- [User-defined Functions](#toc3_)    \n",
    "- [Python Function Arguments](#toc4_)    \n",
    "  - [Function Argument with Default Values](#toc4_1_)    \n",
    "  - [Keyword Argument](#toc4_2_)    \n",
    "- [Function With Arbitrary Arguments](#toc5_)    \n",
    "- [Python Recursive Function](#toc6_)    \n",
    "- [Python Lambda/Anonymous Function](#toc7_)    \n",
    "- [Python Modules](#toc8_)    \n",
    "  - [Python Standard Library Modules](#toc8_1_)    \n",
    "- [The dir() built-in function](#toc9_)    \n",
    "- [Python Package](#toc10_)    \n",
    "  - [Package Model Structure in Python Programming](#toc10_1_)    \n",
    "    - [Importing module from a package](#toc10_1_1_)    \n",
    "\n",
    "<!-- vscode-jupyter-toc-config\n",
    "\tnumbering=false\n",
    "\tanchor=true\n",
    "\tflat=false\n",
    "\tminLevel=1\n",
    "\tmaxLevel=6\n",
    "\t/vscode-jupyter-toc-config -->\n",
    "<!-- THIS CELL WILL BE REPLACED ON TOC UPDATE. DO NOT WRITE YOUR TEXT IN THIS CELL -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc1_'></a>[Function](#toc0_)\n",
    "\n",
    "- Function is a code block that is used to perform a specific task.\n",
    "- Dividing a complex problem into smaller chunks makes our program easy to understand and reuse.\n",
    "\n",
    "# <a id='toc2_'></a>[Python Function Types](#toc0_)\n",
    "\n",
    "- Built-in functions (aka Standard library functions)\n",
    "- User-defined functions\n",
    "\n",
    "## <a id='toc2_1_'></a>[Built-in functions](#toc0_)\n",
    "\n",
    "- Function that already exist in programming language to peform specific task in optimized way. \n",
    "- Exp: `print()`, `type()`, `id()`, `pow(2,3)`\n",
    "\n",
    "\n",
    "\n",
    "`Python 3.12` has `71` [Built-in Functions](https://docs.python.org/3/library/functions.html) that are enlisted below:\n",
    "\n",
    "![built_functions_py](imgs/built_functions_py.PNG)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ArithmeticError',\n",
       " 'AssertionError',\n",
       " 'AttributeError',\n",
       " 'BaseException',\n",
       " 'BlockingIOError',\n",
       " 'BrokenPipeError',\n",
       " 'BufferError',\n",
       " 'BytesWarning',\n",
       " 'ChildProcessError',\n",
       " 'ConnectionAbortedError',\n",
       " 'ConnectionError',\n",
       " 'ConnectionRefusedError',\n",
       " 'ConnectionResetError',\n",
       " 'DeprecationWarning',\n",
       " 'EOFError',\n",
       " 'Ellipsis',\n",
       " 'EncodingWarning',\n",
       " 'EnvironmentError',\n",
       " 'Exception',\n",
       " 'False',\n",
       " 'FileExistsError',\n",
       " 'FileNotFoundError',\n",
       " 'FloatingPointError',\n",
       " 'FutureWarning',\n",
       " 'GeneratorExit',\n",
       " 'IOError',\n",
       " 'ImportError',\n",
       " 'ImportWarning',\n",
       " 'IndentationError',\n",
       " 'IndexError',\n",
       " 'InterruptedError',\n",
       " 'IsADirectoryError',\n",
       " 'KeyError',\n",
       " 'KeyboardInterrupt',\n",
       " 'LookupError',\n",
       " 'MemoryError',\n",
       " 'ModuleNotFoundError',\n",
       " 'NameError',\n",
       " 'None',\n",
       " 'NotADirectoryError',\n",
       " 'NotImplemented',\n",
       " 'NotImplementedError',\n",
       " 'OSError',\n",
       " 'OverflowError',\n",
       " 'PendingDeprecationWarning',\n",
       " 'PermissionError',\n",
       " 'ProcessLookupError',\n",
       " 'RecursionError',\n",
       " 'ReferenceError',\n",
       " 'ResourceWarning',\n",
       " 'RuntimeError',\n",
       " 'RuntimeWarning',\n",
       " 'StopAsyncIteration',\n",
       " 'StopIteration',\n",
       " 'SyntaxError',\n",
       " 'SyntaxWarning',\n",
       " 'SystemError',\n",
       " 'SystemExit',\n",
       " 'TabError',\n",
       " 'TimeoutError',\n",
       " 'True',\n",
       " 'TypeError',\n",
       " 'UnboundLocalError',\n",
       " 'UnicodeDecodeError',\n",
       " 'UnicodeEncodeError',\n",
       " 'UnicodeError',\n",
       " 'UnicodeTranslateError',\n",
       " 'UnicodeWarning',\n",
       " 'UserWarning',\n",
       " 'ValueError',\n",
       " 'Warning',\n",
       " 'WindowsError',\n",
       " 'ZeroDivisionError',\n",
       " '__IPYTHON__',\n",
       " '__build_class__',\n",
       " '__debug__',\n",
       " '__doc__',\n",
       " '__import__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'abs',\n",
       " 'aiter',\n",
       " 'all',\n",
       " 'anext',\n",
       " 'any',\n",
       " 'ascii',\n",
       " 'bin',\n",
       " 'bool',\n",
       " 'breakpoint',\n",
       " 'bytearray',\n",
       " 'bytes',\n",
       " 'callable',\n",
       " 'chr',\n",
       " 'classmethod',\n",
       " 'compile',\n",
       " 'complex',\n",
       " 'copyright',\n",
       " 'credits',\n",
       " 'delattr',\n",
       " 'dict',\n",
       " 'dir',\n",
       " 'display',\n",
       " 'divmod',\n",
       " 'enumerate',\n",
       " 'eval',\n",
       " 'exec',\n",
       " 'execfile',\n",
       " 'filter',\n",
       " 'float',\n",
       " 'format',\n",
       " 'frozenset',\n",
       " 'get_ipython',\n",
       " 'getattr',\n",
       " 'globals',\n",
       " 'hasattr',\n",
       " 'hash',\n",
       " 'help',\n",
       " 'hex',\n",
       " 'id',\n",
       " 'input',\n",
       " 'int',\n",
       " 'isinstance',\n",
       " 'issubclass',\n",
       " 'iter',\n",
       " 'len',\n",
       " 'license',\n",
       " 'list',\n",
       " 'locals',\n",
       " 'map',\n",
       " 'max',\n",
       " 'memoryview',\n",
       " 'min',\n",
       " 'next',\n",
       " 'object',\n",
       " 'oct',\n",
       " 'open',\n",
       " 'ord',\n",
       " 'pow',\n",
       " 'print',\n",
       " 'property',\n",
       " 'range',\n",
       " 'repr',\n",
       " 'reversed',\n",
       " 'round',\n",
       " 'runfile',\n",
       " 'set',\n",
       " 'setattr',\n",
       " 'slice',\n",
       " 'sorted',\n",
       " 'staticmethod',\n",
       " 'str',\n",
       " 'sum',\n",
       " 'super',\n",
       " 'tuple',\n",
       " 'type',\n",
       " 'vars',\n",
       " 'zip']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print builtins functions, errortypes, ...\n",
    "import builtins\n",
    "dir(builtins)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc3_'></a>[User-defined Functions](#toc0_)\n",
    "\n",
    "- These functions are custom functions that are defined to perform a specific task repeatedly. \n",
    "\n",
    "# <a id='toc4_'></a>[Python Function Arguments](#toc0_)\n",
    "- In computer programming, an argument is a value that is accepted by a function.\n",
    "\n",
    "## <a id='toc4_1_'></a>[Function Argument with Default Values](#toc0_)\n",
    "- provide default values to function arguments\n",
    "\n",
    "\n",
    "```\n",
    "def add_numbers( a = 7,  b = 8):\n",
    "    sum = a + b\n",
    "    print('Sum:', sum)\n",
    "```\n",
    "\n",
    "## <a id='toc4_2_'></a>[Keyword Argument](#toc0_)\n",
    "- In keyword arguments, arguments are assigned based on the name of arguments.\n",
    "\n",
    "```\n",
    "def display_info(first_name, last_name):\n",
    "    print('First Name:', first_name)\n",
    "    print('Last Name:', last_name)\n",
    "\n",
    "display_info(last_name = 'Ali', first_name = 'Malik')\n",
    "```\n",
    "\n",
    "\n",
    "# <a id='toc5_'></a>[Function With Arbitrary Arguments](#toc0_)\n",
    "- When we do not know in advance the number of arguments that will be passed into a function. To handle this kind of situation, we can use arbitrary arguments in Python.\n",
    "- We use an asterisk (*) before the parameter name to denote this kind of argument\n",
    "\n",
    "```\n",
    "# program to find sum of multiple numbers \n",
    "\n",
    "def find_sum(*numbers):\n",
    "    result = 0\n",
    "    \n",
    "    for num in numbers:\n",
    "        result = result + num\n",
    "    \n",
    "    print(\"Sum = \", result)\n",
    "\n",
    "# function call with 3 arguments\n",
    "find_sum(1, 2, 3)\n",
    "\n",
    "# function call with 2 arguments\n",
    "find_sum(4, 9)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Ali! \n",
      "Please let me know what help you need?\n"
     ]
    }
   ],
   "source": [
    "def greet(name):\n",
    "    print(f\"Hello {name}! \\nPlease let me know what help you need?\")\n",
    "\n",
    "greet(\"Ali\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "height = 25\n",
      "width = 15\n",
      "depth = 5\n",
      "Area calculated = 1875\n",
      "--------------------------------------------------\n",
      "Returned Value of Area = 1875\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "def calculate_area(height, width, depth):\n",
    "    print(f\"height = {height}\")\n",
    "    print(f\"width = {width}\")\n",
    "    print(f\"depth = {depth}\")\n",
    "\n",
    "    area = height * width * depth\n",
    "    print(f\"Area calculated = {area}\")\n",
    "    print(\"-\"*50)\n",
    "    return area\n",
    "\n",
    "# Pass Args by Order\n",
    "area = calculate_area(25,15,5)\n",
    "print(f\"Returned Value of Area = {area}\")\n",
    "print(\"-\"*50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "height = 25\n",
      "width = 15\n",
      "depth = 5\n",
      "Area calculated = 1875\n",
      "--------------------------------------------------\n",
      "Returned Value of Area = 1875\n"
     ]
    }
   ],
   "source": [
    "# Keyword Argument >> Pass Args by name\n",
    "area = calculate_area(width=15, height=25, depth=5)\n",
    "# area = calculate_area(width=15, 25, 5) # SyntaxError: positional argument follows keyword argument\n",
    "print(f\"Returned Value of Area = {area}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "height = 25\n",
      "width = 15\n",
      "depth = 5\n",
      "Area calculated = 1875\n",
      "--------------------------------------------------\n",
      "Returned Value of Area = 1875\n"
     ]
    }
   ],
   "source": [
    "# Keyword Argument Pass Args by name & position\n",
    "area = calculate_area(25, depth=5, width=15)\n",
    "# area = calculate_area(width=15, 25, 5) # SyntaxError: positional argument follows keyword argument\n",
    "print(f\"Returned Value of Area = {area}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "height = 1\n",
      "width = 1\n",
      "depth = 1\n",
      "Area calculated = 1\n",
      "--------------------------------------------------\n",
      "Returned Value of Area = 1\n",
      "--------------------------------------------------\n",
      "height = 25\n",
      "width = 1\n",
      "depth = 1\n",
      "Area calculated = 25\n",
      "--------------------------------------------------\n",
      "Returned Value of Area = 25\n",
      "--------------------------------------------------\n",
      "height = 25\n",
      "width = 15\n",
      "depth = 1\n",
      "Area calculated = 375\n",
      "--------------------------------------------------\n",
      "Returned Value of Area = 375\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Default Value >> Function Argument with Default Values\n",
    "def calculate_area(height=1, width=1, depth=1):\n",
    "    print(f\"height = {height}\")\n",
    "    print(f\"width = {width}\")\n",
    "    print(f\"depth = {depth}\")\n",
    "\n",
    "    area = height * width * depth\n",
    "    print(f\"Area calculated = {area}\")\n",
    "    print(\"-\"*50)\n",
    "    return area\n",
    "\n",
    "\n",
    "area = calculate_area()\n",
    "print(f\"Returned Value of Area = {area}\")\n",
    "print(\"-\"*50)\n",
    "\n",
    "# Pass Args by Order\n",
    "area = calculate_area(25)\n",
    "print(f\"Returned Value of Area = {area}\")\n",
    "print(\"-\"*50)\n",
    "\n",
    "# Pass Args by Order\n",
    "area = calculate_area(25,15)\n",
    "print(f\"Returned Value of Area = {area}\")\n",
    "print(\"-\"*50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc6_'></a>[Python Recursive Function](#toc0_)\n",
    "- In Python, we know that a function can call other functions. It is even possible for the function to call itself. These types of construct are termed as `recursive functions`.\n",
    "\n",
    "**Base condition (Terminating conditon)**\n",
    "- Every recursive function must have a base condition that stops the recursion or else the function calls itself infinitely.\n",
    "\n",
    "- The Python interpreter limits the depths of recursion to help avoid infinite recursions, resulting in stack overflows.\n",
    "\n",
    "- By default, Python has `maximum depth of recursion is 1000`. If the limit is crossed, it results in RecursionError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The factorial of 5 is 120\n",
      "The factorial of 0 is 1\n"
     ]
    }
   ],
   "source": [
    "def factorial(num):\n",
    "    if num == 1 or num == 0:  # Base condition >> Terminating conditon\n",
    "        return 1\n",
    "    else:\n",
    "        return num * factorial(num-1) # recursive call\n",
    "    \n",
    "\n",
    "x = 5\n",
    "print(\"The factorial of\", x, \"is\", factorial(x))\n",
    "\n",
    "x = 0\n",
    "print(\"The factorial of\", x, \"is\", factorial(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc7_'></a>[Python Lambda/Anonymous Function](#toc0_)\n",
    "\n",
    "- In Python, a lambda function is a special type of function without the function name. \n",
    "\n",
    "```\n",
    "lambda argument(s) : expression\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "# declare a lambda function\n",
    "greet = lambda : print('Hello World!')\n",
    "\n",
    "# call lambda function\n",
    "greet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# func_name = lambda i/p args : logic with return value \n",
    "\n",
    "calculate_cube = lambda x : x*x*x\n",
    "calculate_cube(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# passing multiple inputs args in lambda function\n",
    "calculate_area = lambda a,b : a*b\n",
    "calculate_area(5,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Full name: Ali Malik'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "full_name = lambda first, last: f'Full name: {first.title()} {last.title()}'\n",
    "full_name('Ali', 'Malik')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "even\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'odd'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Even or Odd  \n",
    "\n",
    "# 1 line logic >> x%2 and \"odd\" or \"even\"\n",
    "\n",
    "even_odd = lambda num : x%2 and \"odd\" or \"even\"\n",
    "\n",
    "print(even_odd(12))\n",
    "\n",
    "\n",
    "# can also pass arg in single line ()\n",
    "(lambda x: (x % 2 and 'odd' or 'even'))(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc8_'></a>[Python Modules](#toc0_)\n",
    "\n",
    "Module is a file that contains code to perform a specific task. A module may contain variables, functions, classes etc.\n",
    "\n",
    "\n",
    "- `Module Creation` >> Write some python code in file & save it. Exp: `arithmetic.py` (define functions add,sub,mul,div)\n",
    "- `Import modules in Python` >> `import arithmetic`\n",
    "- `Access Function defined in Module` >> `arithmetic.add()`\n",
    "\n",
    "\n",
    "## <a id='toc8_1_'></a>[Python Standard Library Modules](#toc0_)\n",
    "\n",
    "- The Python standard library contains well over 200 modules.\n",
    "\n",
    "```\n",
    "# import standard math module \n",
    "import math\n",
    "\n",
    "# use math.pi to get value of pi\n",
    "print(\"The value of pi is\", math.pi)\n",
    "```\n",
    "\n",
    "# <a id='toc9_'></a>[The dir() built-in function](#toc0_)\n",
    "\n",
    "In Python, we can use the dir() function to list all the function names in a module.\n",
    "\n",
    "```\n",
    "import math\n",
    "dir(math)\n",
    "\n",
    "# Output like: ['__doc__',\n",
    " '__loader__',\n",
    " '__name__',\n",
    " '__package__',\n",
    " '__spec__',\n",
    " 'acos',\n",
    " 'acosh',\n",
    " 'asin',\n",
    " .... ]\n",
    "\n",
    "--> Here  '__name__'  >> is an Attribute, it contains the name of the module >> Likewise other attribs '__doc__' ...\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "math.__name__ : math\n",
      "math.__doc__ : This module provides access to the mathematical functions\n",
      "defined by the C standard.\n",
      "math.__spec__ : ModuleSpec(name='math', loader=<class '_frozen_importlib.BuiltinImporter'>, origin='built-in')\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "dir(math)\n",
    "\n",
    "# Here '__doc__' , '__name__'  >> Attributes\n",
    "print(f\"math.__name__ : {math.__name__}\")\n",
    "print(f\"math.__doc__ : {math.__doc__}\")\n",
    "print(f\"math.__spec__ : {math.__spec__}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc10_'></a>[Python Package](#toc0_)\n",
    "\n",
    "\n",
    "- A package is `a container` that contains various functions to perform specific tasks. For example, the `math` package includes the `sqrt()` function to perform the square root of a number.\n",
    "\n",
    "\n",
    "- While working on big projects, we have to deal with a large amount of code, and writing everything together in the same file will make our code look messy. \n",
    "    - Instead, we can separate our code into multiple files by keeping the related code together in `packages`.\n",
    "\n",
    "\n",
    "-  A directory must contain a file named __init__.py in order for Python to consider it as a package. \n",
    "   -  This file can be left empty but we generally place the initialization code for that package in this file.\n",
    "\n",
    "## <a id='toc10_1_'></a>[Package Model Structure in Python Programming](#toc0_)\n",
    "\n",
    "Suppose we are developing a game. One possible organization of packages and modules could be as shown in the figure below.\n",
    "\n",
    "\n",
    "<!-- using Table Style for this -->\n",
    "| ![Package Model Structure](imgs/packages-in-python.png)|\n",
    "| **Game Package Model Structure** |\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### <a id='toc10_1_1_'></a>[Importing module from a package](#toc0_)\n",
    "```\n",
    "import Game.Level.start\n",
    "Game.Level.start.select_difficulty(2)\n",
    "\n",
    "\n",
    "# Import Without Package Prefix\n",
    "from Game.Level import start\n",
    "start.select_difficulty(2)\n",
    "\n",
    "# Import Required Functionality Only\n",
    "from Game.Level.start import select_difficulty\n",
    "select_difficulty(2)  # directly call this function\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**References**\n",
    "\n",
    "- [The Python Standard Library](https://docs.python.org/3/library/index.html) \n",
    "  - [Built-in Functions](https://docs.python.org/3/library/functions.html)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "- The [Python Language Reference](https://docs.python.org/3/reference/index.html#reference-index) describes the exact syntax and semantics of the Python language. \n",
    "\n",
    "- The [Python Standard Library](https://docs.python.org/3/library/index.html) reference manual describes the standard library that is distributed with Python. It also describes some of the optional components that are commonly included in Python distributions."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py311_django",
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}