07 Learn_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learn Python Functions:- \n",
    "- This section explains how to use Functions in Python. Functions are a convenient way to divide your code into useful blocks, allowing us to order our code, make it more readable, reuse it and save some time. Also functions are a key way to define interfaces so programmers can share their code.\n",
    "<br>\n",
    "\n",
    "- (or) To bundle a set of instructions that we want to use repeatedly \n",
    " - **Reuability**\n",
    " - **Debugging**\n",
    " \n",
    "## Python supports two type of functions:-\n",
    "- Built in Functions\n",
    "> **Eg:- id(), type(), input(), etc....**\n",
    "- User Defined Functions\n",
    "\n",
    "### for User Defined Functions, there are two thinks \n",
    "   - **1. Function Definition**\n",
    "   - **2. Function Call**\n",
    "\n",
    "**1. Fucntion Definition:-** Every function should starts with **def** keyword and should mention function name (Note: Keyword should not come as function name) and also function returns empty or values. In addtion python return multiple values at same time in the form of tuple.\n",
    "\n",
    "**2. Fucntion Call:-** Just call the Fucntion Definition.\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function Definition\n",
    "\n",
    "def add_two_number():\n",
    "    a = 5\n",
    "    b = 10\n",
    "    print(a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "add_two_number()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function Definition\n",
    "\n",
    "def add_list_value():\n",
    "    a , b = 10 ,5\n",
    "    return a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "x = add_list_value()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Type of Arguments:- \n",
    "- Required or Position Arguments\n",
    "- Keywords Arguments\n",
    "- Default Arguments\n",
    "- Variable length Arguments\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6)\n",
      "{'a': 1, 'b': 2, 'c': 3}\n"
     ]
    }
   ],
   "source": [
    "#Position Arguments\n",
    "def add_num(*args):\n",
    "    print(args)\n",
    "    \n",
    "def add_num1(**y):\n",
    "    print(y)\n",
    "\n",
    "add_num(1, 2, 3, 4 , 5, 6)\n",
    "\n",
    "add_num1(a = 1, b =2 , c= 3)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum of (5, 10, 10) are 25\n",
      "************************************************\n",
      "{'g1': 2, 'g2': 3}\n",
      "************************************************\n",
      "1 (2, 3) {'g1': 100, 'g2': 200}\n"
     ]
    }
   ],
   "source": [
    "# Learn *args and **kwargs\n",
    "\n",
    "a = 5\n",
    "b = 10\n",
    "c = 10\n",
    "\n",
    "def getData(*args):    \n",
    "    print(f\"sum of {args} are {sum(args)}\")  \n",
    "\n",
    "getData(a,b,c)\n",
    "print(\"************************************************\")\n",
    "\n",
    "def getData1(**kwargs):\n",
    "    print(kwargs)\n",
    "    \n",
    "getData1(g1 = 2, g2 = 3)\n",
    "print(\"************************************************\")\n",
    "    \n",
    "    \n",
    "def getData2(c, *args,  **kwargs):\n",
    "    print(c, args, kwargs) \n",
    "    \n",
    "\n",
    "getData2(1,2,3, g1 = 100, g2 = 200)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Local vs Global Variable:- "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "sum of 10 and 15 are 0\n",
      "sum of 20 and 5 are 0\n"
     ]
    }
   ],
   "source": [
    "e =5\n",
    "d = 20\n",
    "\n",
    "def getData(*args):\n",
    "    print(args)\n",
    "    d = 10\n",
    "    e = 15\n",
    "    print(f\"sum of {d} and {e} are {sum(args)}\")\n",
    "    \n",
    "def getData1(*args):    \n",
    "    print(f\"sum of {d} and {e} are {sum(args)}\")\n",
    "    \n",
    "    \n",
    "getData()\n",
    "getData1()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Expression oriented functions are:\n",
    "\n",
    "1. map(Fun, Seq)\n",
    "2. filter(Fun, Seq)\n",
    "3. reduce(Fun, Seq)\n",
    "4. lambda\n",
    "5. list comprehension\n",
    "\n",
    "# LAMBDA Functions:- (Anonymous Functions)\n",
    "\n",
    "   \n",
    " - The Lambda operator or Lambda function is a way to create small Anonymous functions (**Function without name**). \n",
    " - its doesn't return value but its alwasy returns Expressions.\n",
    " - its defined by using 'LAMBDA' keyword.\n",
    " - do not defined by 'def' keyword because this function doesn't have any name.\n",
    " - also its cann't access global variable.\n",
    " - its one-line function, no loops and no code blocking. But we can use simple if-else conditions.\n",
    " - These functions are throw-away functions, i.e. they are just needed where they have been created. Lambda functions are mainly used in combinations with the functions filter(), map() and reduce().\n",
    " \n",
    "\n",
    "\n",
    "## Syntax:- \n",
    " - ### lambda argument_list : expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Normal Functions:-\n",
    "def power2(x):\n",
    "    return x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.power2(x)>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    return a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.add(a, b)>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(x)>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lambda x : x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(x, y)>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lambda x, y : x+y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = lambda x : x**2\n",
    "l(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = lambda x, y=10 : x+y\n",
    "g(2, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, ('a', 'b', 'c'), {'y': 100, 'a': 10, 'b': 20})"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = lambda x, *args, **kwargs: (x, args, kwargs)\n",
    "\n",
    "\n",
    "d(1, 'a','b','c', y=100, a=10, b=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sq1(x):\n",
    "    return x**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def apply_func(x, y):\n",
    "    return y(x)\n",
    "\n",
    "apply_func(5, sq1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#using lambda:- \n",
    "apply_func(5, lambda x : x**3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isEven = lambda x : x % 2 == 0\n",
    "isEven(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func1 = lambda x : x + 2 if x %2 == 0 else x + 1\n",
    "func1(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lambda's and Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sorted in module builtins:\n",
      "\n",
      "sorted(iterable, /, *, key=None, reverse=False)\n",
      "    Return a new list containing all items from the iterable in ascending order.\n",
      "    \n",
      "    A custom key function can be supplied to customize the sort order, and the\n",
      "    reverse flag can be set to request the result in descending order.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "l = ['a', 'B', 'c', 'D', 'a']\n",
    "l\n",
    "\n",
    "sorted(l)\n",
    "\n",
    "help(sorted)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['c', 'a', 'a', 'D', 'B']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(l, reverse = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('B')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sorted in module builtins:\n",
      "\n",
      "sorted(iterable, /, *, key=None, reverse=False)\n",
      "    Return a new list containing all items from the iterable in ascending order.\n",
      "    \n",
      "    A custom key function can be supplied to customize the sort order, and the\n",
      "    reverse flag can be set to request the result in descending order.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sorted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'a', 'B', 'c', 'D']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(l, key = lambda s : s.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'def' : 300, 'abc' : 100, 'ghi' : 200}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "def\n",
      "abc\n",
      "ghi\n"
     ]
    }
   ],
   "source": [
    "for k in d:\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc', 'def', 'ghi']"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc', 'ghi', 'def']"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(d, key = lambda e : d[e])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Babu', 'Balaji', 'Divya', 'Gopi', 'Sarath']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = {\"Babu\", \"Gopi\", \"Sarath\", \"Balaji\", \"Divya\"}\n",
    "\n",
    "sorted(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Divya', 'Sarath', 'Gopi', 'Balaji', 'Babu']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(l, key = lambda s : s[-1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Map, Filter and Zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fact(n):\n",
    "    return 1 if n < 2 else n * fact(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fact(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#syntax:-\n",
    "# map(func, *iterator)-------> [Note: its might be list, tuple or any seq]\n",
    "\n",
    "results = list(map(fact, range(6)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 6, 24, 120]\n"
     ]
    }
   ],
   "source": [
    "print(list(results))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "2\n",
      "6\n",
      "24\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "for i in results:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 22, 33, 44, 55]\n"
     ]
    }
   ],
   "source": [
    "l1 = [1,2,3,4,5]\n",
    "#l2 = [10, 20, 30, 40, 50]\n",
    "\n",
    "results = list(map(lambda x: (x**2), l1))\n",
    "print(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[111, 222, 333]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = [1,2,3,4,5]\n",
    "l2 = [10, 20, 30]\n",
    "l3 = [100, 200, 300, 400, 500]\n",
    "\n",
    "list(map(lambda x, y, z : x+y+z, l1,l2, l3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def n():\n",
    "    pass\n",
    "\n",
    "#filter(func, iterator)\n",
    "\n",
    "# Filter:-  map(func, iterator)\n",
    "list(filter(lambda x : x % 2 ==0, range(25)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 'a', 'b', True]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(None, [1, 2, 0, 'a', 0, 0 ,'b', True, False]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 16, 25, 36]\n"
     ]
    }
   ],
   "source": [
    "# 1. list of the squares of the integers from 0 to 9 where the \n",
    "# square is greater than 20 and less than 40\n",
    "\n",
    "special_squares = []\n",
    "for x in range(10):\n",
    "    square = x**2\n",
    "    if square > 5 and square < 40:\n",
    "        special_squares.append(square)\n",
    " \n",
    "\n",
    "print(special_squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[25, 36]\n"
     ]
    }
   ],
   "source": [
    "sq = map(lambda x : x**2, range(10))\n",
    "fr = filter(lambda x: x > 20 and x < 40, sq)\n",
    "print (list(fr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 10, 't'), (2, 20, 'e'), (3, 30, 's'), (4, 40, 't'), (5, 50, 'l')]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Zip:- Syntax:- zip(*iterables)\n",
    "\n",
    "'''The zip() function is used to make an iterator that aggregates \n",
    "   elements from each of the iterables. The iterator stops \n",
    "   when the shortest input iterable is exhausted'''\n",
    "\n",
    "l1 = [1,2,3,4,5]\n",
    "l2 = [10, 20, 30, 40, 50]\n",
    "l3 = 'testleaf'\n",
    "\n",
    "result = zip(l1, l2, l3)\n",
    "list(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'p'), (1, 'y'), (2, 't'), (3, 'h'), (4, 't'), (5, 'o'), (6, 'n')]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = range(1000)\n",
    "l2 = 'pythton'\n",
    "\n",
    "list(zip(l1, l2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 a\n",
      "2 b\n",
      "3 c\n",
      "4 d\n"
     ]
    }
   ],
   "source": [
    "l1 = [1, 2, 3, 4]\n",
    "l2 = ['a', 'b', 'c', 'd']\n",
    "\n",
    "for i, j in zip(l1, l2):\n",
    "    print(i, j)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'p'), (1, 'y'), (2, 't'), (3, 'h'), (4, 't'), (5, 'o'), (6, 'n')]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1 = range(1000)\n",
    "l2 = 'pythton'\n",
    "\n",
    "zipped = list(zip(l1, l2))\n",
    "zipped"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 1, 2, 3, 4, 5, 6), ('p', 'y', 't', 'h', 't', 'o', 'n')]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unzipped = list(zip(*zipped))\n",
    "unzipped"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}