Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### is a set of code that performs a particular task\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "-> runs when it is called\n",
    "-> can pass data (parameters or arguments)\n",
    "-> can return data\n",
    "-> Calling a fuction - followed by paranthesis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# Definition of the function\n",
    "def first():\n",
    "    print(\"Hello World\")\n",
    "    \n",
    "first()   # Calling the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ram Tribbiani\n",
      "Joey Tribbiani\n",
      "Mary Angela Tribbiani\n"
     ]
    }
   ],
   "source": [
    "def func(name):\n",
    "    print(name + \" \" + \"Tribbiani\")\n",
    "\n",
    "n = \"Ram\" # Value of parameters using a variable\n",
    "func(n)   \n",
    "func(\"Joey\")# Passing the parameter directly\n",
    "func(\"Mary Angela\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 6 and y = 8\n",
      "a = 6 and b = 8\n",
      "6 + 8 is 14\n"
     ]
    }
   ],
   "source": [
    "def add(x, y):\n",
    "    result = x + y\n",
    "    print(\"x = %d and y = %d\" % (x,y))\n",
    "    print(\"a = %d and b = %d\" % (a,b))\n",
    "    print(a, \"+\", b ,\"is\", result)\n",
    "    \n",
    "\n",
    "a = 6\n",
    "b = 8\n",
    "add(a, b) #values are position dependent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 subtracted from 4 is -5\n",
      "10 subtracted from 20 is 10\n"
     ]
    }
   ],
   "source": [
    "def sub(a , b):\n",
    "\n",
    "    diff = a - b\n",
    "    print(\"%d subtracted from %d is %d\" % (b , a , diff))\n",
    "    \n",
    "sub(4,9)\n",
    "\n",
    "sub(b = 10, a = 20 )#values independent of their positions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 subtracted from 4 is -2\n"
     ]
    }
   ],
   "source": [
    "def sub(a , b = 6): # Default Argument\n",
    "\n",
    "    diff = a - b\n",
    "    print(\"%d subtracted from %d is %d\" % (b , a , diff))\n",
    "    \n",
    "sub(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 subtracted from 4 is 2\n",
      "5 subtracted from 8 is 3\n"
     ]
    }
   ],
   "source": [
    "def sub(a = 8 , b = 5): # Default Arguments\n",
    "\n",
    "    diff = a - b\n",
    "    print(\"%d subtracted from %d is %d\" % (b , a , diff))\n",
    "    \n",
    "sub(4 , 2)\n",
    "sub()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 subtracted from 8 is 3\n"
     ]
    }
   ],
   "source": [
    "def sub(a = 8 , b = 5): # Default Arguments\n",
    "\n",
    "    diff = a - b\n",
    "    print(\"%d subtracted from %d is %d\" % (b , a , diff))\n",
    "    \n",
    "sub()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "sub() missing 1 required positional argument: 'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-15-4164f4fc2178>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"%d subtracted from %d is %d\"\u001b[0m \u001b[1;33m%\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m \u001b[1;33m,\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m,\u001b[0m \u001b[0mdiff\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0msub\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: sub() missing 1 required positional argument: 'a'"
     ]
    }
   ],
   "source": [
    "def sub(a , b = 5): # Default Arguments\n",
    "\n",
    "    diff = a - b\n",
    "    print(\"%d subtracted from %d is %d\" % (b , a , diff))\n",
    "    \n",
    "sub()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before swap\n",
      "5 6\n",
      "After swap\n",
      "6 5\n",
      "5 6\n",
      "Before swap\n",
      "8 9\n",
      "After swap\n",
      "9 8\n",
      "5 6\n"
     ]
    }
   ],
   "source": [
    "def swap(x, y):  \n",
    "    # x and y are local to the function definition\n",
    "    print(\"Before swap\")\n",
    "    print(x,y) \n",
    "    temp = x \n",
    "    x = y\n",
    "    y = temp\n",
    "    print(\"After swap\")\n",
    "    print(x,y) \n",
    "\n",
    "x = 5\n",
    "y = 6\n",
    "swap(x, y)\n",
    "print(x,y)\n",
    "\n",
    "swap(8,9)\n",
    "print(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List  [10, 20, 30]\n",
      "List inside [1, 2, 3, 4]\n",
      "List outside [10, 20, 30]\n"
     ]
    }
   ],
   "source": [
    "def change_list( mylist ):\n",
    "    print(\"List \" , mylist)\n",
    "    mylist = [1,2,3,4]\n",
    "    print(\"List inside\" , mylist)\n",
    "    return mylist\n",
    "\n",
    "mylist = [10,20,30]\n",
    "\n",
    "change_list( mylist )\n",
    "print(\"List outside\" , mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2532515248328\n",
      "Inside Function\n",
      "2532515248328\n",
      "2532515248456\n",
      "[0]\n",
      "Outside Function\n",
      "2532515248328\n"
     ]
    }
   ],
   "source": [
    "def append_li(li):\n",
    "    print(\"Inside Function\")\n",
    "    print(id(li))\n",
    "    li = [0, 1]\n",
    "    print(id(li))\n",
    "x = [0]\n",
    "print(id(x))\n",
    "append_li(x)\n",
    "print(x)\n",
    "print(\"Outside Function\")\n",
    "print(id(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outside Function\n",
      "2532515248456\n",
      "Inside Function\n",
      "2532515248456\n",
      "2532515248456\n",
      "[0, 1]\n",
      "2532515248456\n"
     ]
    }
   ],
   "source": [
    "def append_li(li):\n",
    "    print(\"Inside Function\")\n",
    "    print(id(li))\n",
    "    li.append(1)\n",
    "    print(id(li))\n",
    "x = [0]\n",
    "print(\"Outside Function\")\n",
    "print(id(x))\n",
    "append_li(x)\n",
    "print (x)\n",
    "print(id(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum is :  10\n",
      "The sum is :  26\n"
     ]
    }
   ],
   "source": [
    "# Passing list as the argument\n",
    "#when we do not know the total no. of arguments to be passed in a list\n",
    "\n",
    "def add(*l):\n",
    "    result = 0\n",
    "    for i in l:\n",
    "        result =  result + i\n",
    "    print(\"The sum is : \", result)\n",
    "    \n",
    "add(1,2,3,4)\n",
    "add(5,6,7,8,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum is :  12\n"
     ]
    }
   ],
   "source": [
    "def add(list):\n",
    "    result = 0\n",
    "    for i in list:\n",
    "        result =  result + i\n",
    "    print(\"The sum is : \", result)\n",
    "    \n",
    "list = [1,2,4,5]\n",
    "add(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 6, 3, 2, 0]\n",
      "[8, 6, 9, 2, 0]\n"
     ]
    }
   ],
   "source": [
    "def mutable(ls):\n",
    "    ls[2] = 9\n",
    "    \n",
    "ls = [8,6,3,2,0]\n",
    "print(ls)\n",
    "mutable(ls)\n",
    "print(ls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result is: -5\n"
     ]
    }
   ],
   "source": [
    "#Returning values of the function to the line of call\n",
    "def sub(a , b):\n",
    "    diff = a - b\n",
    "    return diff\n",
    "    \n",
    "r = sub(4,9) \n",
    "print(\"Result is:\" , r)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Calculate no. of upper cases and lower cases in a string\n",
    "Palindrome string"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "factorial\n",
    "fibonacci\n",
    "value of a to the powers of b\n",
    "sum of digits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func():\n",
    "    \"\"\" This is the documentation of function 'func' \"\"\"\n",
    "    \n",
    "func()\n",
    "#print(func.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WAP to reverse a string using Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enetr a stringkaruna\n",
      "anurak\n"
     ]
    }
   ],
   "source": [
    "def rev_str(str1):\n",
    "\n",
    "    rev_str1 = ''\n",
    "    i = len(str1)\n",
    "    while i > 0:\n",
    "        rev_str1 += str1[ i - 1 ]\n",
    "        i = i - 1\n",
    "    return rev_str1\n",
    "\n",
    "str1 = input(\"Enetr a string : \")\n",
    "print(rev_str(str1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a program in python to calculate the result of basic  arithmetic operations using a function by passing a list of integers as the argument to the function. Return and print the result of each operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "def add(li, a):\n",
    "    add_l = []\n",
    "    \n",
    "    for i in li:\n",
    "        x = i + a\n",
    "        add_l.append(x)\n",
    "        \n",
    "    return add_l\n",
    "\n",
    "li = [1,2,3,4]\n",
    "a = 6\n",
    "add_l = add(li, a)\n",
    "print(add_l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Addition list [16, 49, 24, 12, 23, 29, 10]\n",
      "\n",
      " Subtraction List [8, 41, 16, 4, 15, 21, 2]\n",
      "\n",
      " Division list [3.0, 11.25, 5.0, 2.0, 4.75, 6.25, 1.5]\n",
      "\n",
      " Multiplication list [48, 180, 80, 32, 76, 100, 24]\n",
      "\n",
      " Exponential list [20736, 4100625, 160000, 4096, 130321, 390625, 1296]\n",
      "\n",
      " Floor Division list [3, 11, 5, 2, 4, 6, 1]\n",
      "\n",
      " Remainder list [0, 1, 0, 0, 3, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "def arithmetic(li, a):\n",
    "    add_l = []\n",
    "    sub_l = []\n",
    "    div_l = []\n",
    "    mul_l = []\n",
    "    exp_l = []\n",
    "    flr_l = []\n",
    "    rem_l = []\n",
    "    for i in li:\n",
    "        x = i + a\n",
    "        add_l.append(x)\n",
    "        \n",
    "        x = i - a\n",
    "        sub_l.append(x)\n",
    "        \n",
    "        x = i / a\n",
    "        div_l.append(x)\n",
    "        \n",
    "        x = i * a\n",
    "        mul_l.append(x)\n",
    "        \n",
    "        x = i ** a\n",
    "        exp_l.append(x)\n",
    "        \n",
    "        x = i // a\n",
    "        flr_l.append(x)\n",
    "        \n",
    "        x = i % a\n",
    "        rem_l.append(x)\n",
    "        \n",
    "        \n",
    "    return add_l, sub_l, div_l, mul_l, exp_l, flr_l, rem_l\n",
    "\n",
    "li = [12, 45, 20, 8, 19, 25, 6]\n",
    "a = 4\n",
    "\n",
    "add_l, sub_l, div_l, mul_l, exp_l, flr_l, rem_l  = arithmetic(li, a)\n",
    "\n",
    "print(\"\\n Addition list\", add_l )\n",
    "print(\"\\n Subtraction List\", sub_l)\n",
    "print(\"\\n Division list\", div_l )\n",
    "print(\"\\n Multiplication list\", mul_l )\n",
    "print(\"\\n Exponential list\", exp_l )\n",
    "print(\"\\n Floor Division list\", flr_l )\n",
    "print(\"\\n Remainder list\", rem_l )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WAP to print factorial of a number using function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 0\n",
      "The factorial of 0 is 1\n"
     ]
    }
   ],
   "source": [
    "num = int(input(\"Enter a number: \"))\n",
    "\n",
    "fact = 1\n",
    "\n",
    "# check if the number is negative, positive or zero\n",
    "if num < 0:\n",
    "    print(\"!!!Negative number\")\n",
    "elif num == 0:\n",
    "    print(\"The factorial of 0 is 1\")\n",
    "else:\n",
    "    for i in range(1, num + 1):\n",
    "        fact = fact*i\n",
    "    print(\"The factorial of\",num,\"is\",fact)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WAP to check whether or not a number is prime using function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prime numbers are greater than 1\n",
    "\n",
    "def prime(num):\n",
    "    if(num<1):\n",
    "        print(\"Please eneter positive number\")\n",
    "    else:\n",
    "        for i in range(2,num):\n",
    "            if (num % i) == 0:\n",
    "                print(num,\"is not a prime number\")\n",
    "                print(i,\"*\",num//i,\"is\",num)\n",
    "                break\n",
    "        else:\n",
    "            print(num,\"is a prime number\")\n",
    "        \n",
    "num = int(input(\"Enter a number: \"))\n",
    "prime(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WAP to convert decimal number into binary using function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dec_bin(n):\n",
    "    if (n > 1):\n",
    "        dec_bin(n//2)\n",
    "    print((n % 2),end = '')\n",
    "\n",
    "dec = int(input(\"Enter decimal number\"))\n",
    "\n",
    "dec_bin(dec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WAP to check whether a number is armstrong or not using function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 153\n",
      "No. of digits in  153 are 3\n",
      "153 is an Armstrong number\n"
     ]
    }
   ],
   "source": [
    "#153 = 1*1*1 + 5*5*5 + 3*3*3\n",
    "\n",
    "def count_digits(num):\n",
    "    c = 0\n",
    "    while (num>0) :\n",
    "        a = num % 10\n",
    "        num= num//10\n",
    "        c += 1\n",
    "    return c\n",
    "\n",
    "def check_arms(num):\n",
    "    s = 0\n",
    "    while num > 0:\n",
    "        digit = num % 10\n",
    "        s += digit ** c\n",
    "        num //= 10\n",
    "    return s\n",
    "\n",
    "num = int(input(\"Enter a number: \"))\n",
    "c = count_digits(num)\n",
    "print(\"No. of digits in \",num, \"are\" ,c)        \n",
    "s = check_arms(num)\n",
    "if (num == s):\n",
    "    print(num,\"is an Armstrong number\")\n",
    "else:\n",
    "    print(num,\"is not an Armstrong number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rec(k):\n",
    "    if (k>0):\n",
    "        result = k +rec(k-1)\n",
    "        print(result)\n",
    "        \n",
    "    else :\n",
    "        result = 0\n",
    "    return result\n",
    "\n",
    "rec(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WAP to print sum of natural numbers using recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recur_sum(n):\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    else:\n",
    "        return n + recur_sum(n-1)\n",
    "\n",
    "n = int(input(\"Enter a number: \"))\n",
    "\n",
    "if (n < 0):\n",
    "    print(\"Enter a positive number\")\n",
    "else:\n",
    "    print(\"The sum is\",recur_sum(num))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WAP to print factorial of a number using recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def recur_factorial(n):\n",
    "    if n == 1:\n",
    "        return n\n",
    "    else:\n",
    "        return n*recur_factorial(n-1)\n",
    "\n",
    "num = int(input(\"Enter a number: \"))\n",
    "\n",
    "if num < 0:\n",
    "    print(\"negative number\")\n",
    "elif num == 0:\n",
    "    print(\"The factorial of 0 is 1\")\n",
    "else:\n",
    "    print(\"The factorial of\",num,\"is\",recur_factorial(num))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WAP to print fibonacci series using recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fibonacci sequence:\n",
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n"
     ]
    }
   ],
   "source": [
    "def recur_fibo(n):\n",
    "      if n <= 1:\n",
    "        return n\n",
    "      else:\n",
    "        return(recur_fibo(n-1) + recur_fibo(n-2))\n",
    "\n",
    "n = 10\n",
    "\n",
    "#n = int(input(\"How many no. of terms? \"))\n",
    "if n <= 0:\n",
    "    print(\"enter a positive integer\")\n",
    "else:\n",
    "    print(\"Fibonacci sequence:\")\n",
    "    for i in range(n):\n",
    "        print(recur_fibo(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# lambda() Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### is an anonymous function with just one expression\n",
    "- Syntax:\n",
    "      function_name = lambda arguments : expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multi = lambda a,b : a*b\n",
    "\n",
    "print(multi(4,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cube = lambda a : a*a*a\n",
    "\n",
    "print(cube(9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WAP to print numbers divisble by 13 from a list of numbers using anonymous function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [12, 65, 54, 39, 102, 339, 221,]\n",
    "\n",
    "result = (filter(lambda x: (x % 13 == 0), my_list))\n",
    "result= list(result)\n",
    "\n",
    "print(\"Numbers divisible by 13 are\",result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WAP to print powers of 2 using lambda function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The total terms is: 10\n",
      "2 raised to power 0 is 1\n",
      "2 raised to power 1 is 2\n",
      "2 raised to power 2 is 4\n",
      "2 raised to power 3 is 8\n",
      "2 raised to power 4 is 16\n",
      "2 raised to power 5 is 32\n",
      "2 raised to power 6 is 64\n",
      "2 raised to power 7 is 128\n",
      "2 raised to power 8 is 256\n",
      "2 raised to power 9 is 512\n"
     ]
    }
   ],
   "source": [
    "terms = 10\n",
    "\n",
    "#terms = int(input(\"How many terms? \"))\n",
    "\n",
    "result = list(map(lambda x: 2 ** x, range(terms)))\n",
    "\n",
    "print(\"The total terms is:\",terms)\n",
    "for i in range(terms):\n",
    "    print(\"2 raised to power\",i,\"is\",result[i])"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}