06_python_functions_modules_packages.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions Cheat Sheet\n",
    "\n",
    "Functions is a group of related statements that performs a specific task\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Jashan\n"
     ]
    }
   ],
   "source": [
    "# Python automatically returns None\n",
    "\n",
    "def printName(name):\n",
    "    \"\"\"\n",
    "    This function print the name: Doc String\n",
    "    \"\"\"\n",
    "    print(\"Hello \"+ str(name))\n",
    "    \n",
    "\n",
    "printName('Jashan')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    This function print the name: Doc String\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(printName.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# scope(global and local) and life time of varaibles\n",
    "\n",
    "# two types of fxn : Built-in and user defined (printName is user defined)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']\n",
      "------------------------------\n",
      "(4, 1)\n",
      "------------------------------\n",
      "Index 10 has value 10\n",
      "Index 11 has value 20\n",
      "Index 12 has value 30\n",
      "Index 13 has value 40\n",
      "------------------------------\n",
      "[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "------------------------------\n"
     ]
    }
   ],
   "source": [
    "# abs() \n",
    "# all() : if all elements in an iterable are true. Note: Empty list always true\n",
    "\n",
    "\n",
    "# dir(): return a list of valid attributes of the object\n",
    "lst = [1,2,3]\n",
    "print(dir(lst))\n",
    "print('------------------------------')\n",
    "\n",
    "\n",
    "\n",
    "# divmod() : takes two numbers and return a pair of numbers( a tuple) consisting of their quotient and remainder\n",
    "print(divmod(9,2))\n",
    "print('------------------------------')\n",
    "\n",
    "\n",
    "# enumerate(iterabele, [start=0]): adds counter to an iterable and returns it\n",
    "numbers = [10,20,30,40]\n",
    "for index, num in enumerate(numbers, start = 10):\n",
    "    print(\"Index {0} has value {1}\".format(index, num))\n",
    "print('------------------------------')\n",
    "\n",
    "\n",
    "# filter(function, iterable) method contructs an ierator from elements of an iterable for which a function returns true\n",
    "def findPositive(num):\n",
    "    if num > 0:\n",
    "        return  num\n",
    "\n",
    "numberList = range(-10, 10)\n",
    "print(list(numberList))\n",
    "\n",
    "positiveNumberList = list(filter(findPositive, numberList))\n",
    "print(positiveNumberList)\n",
    "print('------------------------------')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "------------------------------\n",
      "[1, 4, 9, 16]\n",
      "------------------------------\n",
      "[1, 4, 9, 16]\n",
      "------------------------------\n"
     ]
    }
   ],
   "source": [
    "# isinstance(object, classinfo): check if the object is an instance or subclass of classinfo class\n",
    "lst = [1,2,3]\n",
    "print(isinstance(lst, list))\n",
    "print(isinstance(lst, tuple))\n",
    "print('------------------------------')\n",
    "\n",
    "\n",
    "# map(fxn, listOfInputs): applies a fxn to all the items\n",
    "numbers = [1,2,3,4]\n",
    "squared = []\n",
    "for num in numbers:\n",
    "    squared.append(num**2)\n",
    "print(squared)\n",
    "print('------------------------------')\n",
    "\n",
    "\n",
    "numbers = [1,2,3,4]\n",
    "def powerOfTwo(num):\n",
    "    return num**2\n",
    "squared = list(map(powerOfTwo, numbers))\n",
    "print(squared)\n",
    "print('------------------------------')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "# reduce() function is performing some computation on a list and returning the result\n",
    "from functools import reduce # in python 3\n",
    "product = 1\n",
    "lst = [1,2,3,4]\n",
    "\n",
    "def multiply(x,y):\n",
    "    return x*y\n",
    "product = reduce(multiply, lst)\n",
    "print(product)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Jashan, Nice to meet You :)\n",
      "('Jashan', 'Bansal', 'JashanJim')\n",
      "Hello, Jashan\n",
      "Hello, Bansal\n",
      "Hello, JashanJim\n"
     ]
    }
   ],
   "source": [
    "# Always pass same number of arguments otherwise error OR use default arguments\n",
    "\n",
    "# different types of arguments\n",
    "# 1. Default arguments(make parameters passing compulsary) \n",
    "# 2. Keyword Arguments (More readable, many libraries used this.)\n",
    "\"\"\"\n",
    "kwargs allows us to pass keyworded variable length of arguments to a function.\n",
    "You should use **kwargs if you want to handle named arguments in a function\n",
    "\"\"\"\n",
    "\n",
    "def greet(**kwargs):\n",
    "    if kwargs:\n",
    "        print(\"Hello {0}, {1}\".format(kwargs[\"name\"], kwargs['msg']))\n",
    "greet(name=\"Jashan\", msg=\"Nice to meet You :)\")\n",
    "\n",
    "\n",
    "# 3. Arbitrary arguments : when we don't know the no. of args passed. (names act as a tuple)\n",
    "\n",
    "def greet(*names):\n",
    "    print(names)\n",
    "    for name in names:\n",
    "        print(\"Hello, {0}\".format(name))\n",
    "greet('Jashan', 'Bansal', 'JashanJim')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Anonymous/ Lambda functions\n",
    "\n",
    "Used along with built-in functions like filter(), map(), reduce() extensibly\n",
    "\n",
    "lambda arguments: expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "double = lambda x: x*2\n",
    "print(double(5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4]\n"
     ]
    }
   ],
   "source": [
    "# example use with filter()\n",
    "lst = [1,2,3,4,5]\n",
    "newList = list(filter(lambda x: (x%2 == 0), lst))\n",
    "print(newList)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "# example use with filter()\n",
    "lst = [1,2,3,4,5]\n",
    "newList = list(map(lambda x: x**2 , lst))\n",
    "print(newList)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "# example use with reduce()\n",
    "from functools import reduce\n",
    "lst = [1,2,3,4,5]\n",
    "product = reduce(lambda x,y: x*y, lst)\n",
    "print(product)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules\n",
    "\n",
    "Module refer to the file containing Pyhton statments and definitions\n",
    "\n",
    "eg: abc.py is called a module and abc would be module name\n",
    "\n",
    "Pyhton all modules: https://docs.python.org/3/py-modindex.html\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "# import a module\n",
    "import math\n",
    "print(math.pi)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-05-12 00:10:45.245193\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "print(datetime.datetime.now())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "import math as m\n",
    "print(m.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-05-12 00:12:19.393828\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime   # Import the part to a big module\n",
    "print(datetime.now())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "from math import *\n",
    "print(pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__doc__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'acos',\n",
       " 'acosh',\n",
       " 'asin',\n",
       " 'asinh',\n",
       " 'atan',\n",
       " 'atan2',\n",
       " 'atanh',\n",
       " 'ceil',\n",
       " 'copysign',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'degrees',\n",
       " 'e',\n",
       " 'erf',\n",
       " 'erfc',\n",
       " 'exp',\n",
       " 'expm1',\n",
       " 'fabs',\n",
       " 'factorial',\n",
       " 'floor',\n",
       " 'fmod',\n",
       " 'frexp',\n",
       " 'fsum',\n",
       " 'gamma',\n",
       " 'gcd',\n",
       " 'hypot',\n",
       " 'inf',\n",
       " 'isclose',\n",
       " 'isfinite',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'ldexp',\n",
       " 'lgamma',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'modf',\n",
       " 'nan',\n",
       " 'pi',\n",
       " 'pow',\n",
       " 'radians',\n",
       " 'sin',\n",
       " 'sinh',\n",
       " 'sqrt',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tau',\n",
       " 'trunc']"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dir() function to find out names that are defined inside a module\n",
    "dir(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pow(x, y)\n",
      "\n",
      "Return x**y (x to the power of y).\n"
     ]
    }
   ],
   "source": [
    "print(math.pow.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Packages\n",
    "\n",
    "Package are a way of structuring Python's module namespace by using \"dotted module names\"\n",
    "\n",
    "A directory must contain a file named __init__.py in order to consider it as a package. This file can be left empty but we generally place the initialization code for that package in this file.\n",
    "\n",
    "In a package there are also sub packages allowed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import module from a package\n",
    "\n",
    "import package.subPackage.file1"
   ]
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}