Exceptions, Function closures and decorators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exception handling in Python\n",
    "##### It is used to handle change in code behaviour due to some error/exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    x = 5/0\n",
    "except:\n",
    "    print('In except')\n",
    "else:\n",
    "    print('In else')\n",
    "finally:\n",
    "    print('Finally will always run')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    x = 5/0\n",
    "    a  = int('h')\n",
    "    x = [0]\n",
    "    print(x[1])\n",
    "except ZeroDivisionError:\n",
    "    print(\"Division by 0 not possible\")\n",
    "except ValueError:\n",
    "    print(\"Cannot change a to int\")\n",
    "except:\n",
    "    print(\"Other exceptions\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'h'\n",
    "try:\n",
    "    x = 5/0\n",
    "except:\n",
    "    print('Zero Error')\n",
    "    try:\n",
    "        a = int(a)\n",
    "    except:\n",
    "        print('Value Error')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " #### For a try block, there can be multiple except blocks but one else and one finally block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Calculate the number of  non-digit characters in a list using exception handling only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1,2,4,'a',5,6,'v',1,'e','n',7,'2']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### raise\n",
    "#### It is used to force an exception to occur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "raise ValueError('raised value error')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 19\n",
    "if age>=18:\n",
    "    print('Vote')\n",
    "else:\n",
    "    raise ValueError('Age should be greater than 18')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Write a Python function that takes only Armstrong number as input and raises error otherwise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### assert\n",
    "#### assert is used to check a given condition. If true, it continues execution else it raises an exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "assert 5!=5, 'Not correct'\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "number = 4\n",
    "assert number%2==0, 'Its odd'\n",
    "print('Its even')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Write a Python function to calculate the square root of a number with appropriate restrictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Difference betweeen raise and assert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### raise is used to raise an exception on our will\n",
    "\n",
    "#### assert is used to raise an exception on the basis of a given condition, used in debugging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First class functions in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Functions are objects(can be assigned to variables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def demo():\n",
    "    a=5\n",
    "    print('Hello')\n",
    "tst = demo\n",
    "tst_2 = tst\n",
    "tst_2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Functions can be passed as arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_det(func):\n",
    "    print('Name of the given function is',func.__name__)\n",
    "show_det(demo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Functions can be returned by other functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def call_demo():\n",
    "    return demo()\n",
    "\n",
    "call_demo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function closure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### global"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 5\n",
    "\n",
    "def demo():\n",
    "    num = 10\n",
    "    print(num)\n",
    "    \n",
    "demo()\n",
    "print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def global_demo():\n",
    "    global num\n",
    "    num = 10\n",
    "    print(num)\n",
    "    \n",
    "global_demo()\n",
    "print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### nonlocal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def demo():\n",
    "    num = 5\n",
    "    def wrapper():\n",
    "        num = 10\n",
    "        print(\"Wrapper:\",num)\n",
    "    wrapper()\n",
    "    print(\"Demo:\",num)\n",
    "\n",
    "demo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nonlocal_demo():\n",
    "    num = 5\n",
    "    def wrapper():\n",
    "        nonlocal num\n",
    "        num = 10\n",
    "        print(\"Wrapper:\",num)\n",
    "    wrapper()\n",
    "    print(\"Nonlocal_demo:\",num)\n",
    "\n",
    "nonlocal_demo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Closures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_text(txt):\n",
    "    def helper():\n",
    "        return 'The text is {}'.format(txt)\n",
    "    return helper\n",
    "\n",
    "f = print_text('Testing')\n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Three conditions for a closure\n",
    "1. Should be a nested function\n",
    "2. Should use a value from the higher function\n",
    "3. Should be returned by the higher function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Implement partial using function closure, *args and *kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Implementing OOP using closures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_divisible(n):\n",
    "    def helper(x):\n",
    "        return x%n == 0\n",
    "    return helper\n",
    "\n",
    "divisible_by_2 = is_divisible(2)\n",
    "# divisible_by_2(15)\n",
    "divisble_by_3 = is_divisible(3)\n",
    "divisble_by_3(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using closures make a class like structure that stores a student's name and grade"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function Decorators\n",
    "#### Decorators are used to modify an existing function. This is known as metaprogramming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Decorator on a function without  arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def demo():\n",
    "    print('Demo function')\n",
    "    \n",
    "    \n",
    "def my_deco(func):\n",
    "    \n",
    "    def wrapper():\n",
    "        print('my_deco is called on',func.__name__)\n",
    "        func()\n",
    "    \n",
    "    return wrapper\n",
    "\n",
    "deco_demo = my_deco(demo)\n",
    "deco_demo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using @"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_deco(func):\n",
    "    \n",
    "    def wrapper():\n",
    "        print('My deco is called on',func.__name__)\n",
    "        func()\n",
    "    \n",
    "    return wrapper\n",
    "\n",
    "@my_deco\n",
    "def demo():\n",
    "    print('Demo function')\n",
    "    \n",
    "# @my_deco is same as\n",
    "# demo = my_deco(demo)\n",
    "\n",
    "demo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Use of @wraps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Decorator on a function with arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_detail(func):\n",
    "    \n",
    "    def wrapper(*args, **kwargs):\n",
    "        print(\"Function name:\", func.__name__)\n",
    "        print(\"Arguments:\",*args)\n",
    "        print(\"Keywords\", kwargs)\n",
    "        func(*args, **kwargs)\n",
    "    return wrapper\n",
    "\n",
    "@get_detail\n",
    "def demo(a, b, c=4):\n",
    "    print('In the demo function')\n",
    "\n",
    "demo(1,2,c=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### How to make a parameterised decorator?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def arg_dec(num):\n",
    "    def real_dec(func):\n",
    "        def wrapper():\n",
    "            for i in range(num):\n",
    "                func()\n",
    "        return wrapper\n",
    "    return real_dec\n",
    "\n",
    "@arg_dec(5)\n",
    "def demo():\n",
    "    print('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Write a decorator which prints n \"*\" before and after the function, n is passed as an argument in the decorator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Make a decorator which prints the time taken by a fuction to run"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}