Python_08.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "#creating a list of ten numbers using list comprehension\n",
    "nums=[x for x in range(10)]           #generates a list of numbers from 0 upto 10\n",
    "print(nums)\n",
    "\n",
    "nums=[]\n",
    "for n in range(10):\n",
    "    nums.append(n)\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n",
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "#using if statements with list comprehension\n",
    "nums=[x for x in range(10) if x%2 == 0]   #generates a list of even numbers from 0 upto 10\n",
    "print(nums)\n",
    "\n",
    "nums=[]\n",
    "for n in range(10):\n",
    "    if n % 2 ==0 :\n",
    "        nums.append(n)\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd']\n",
      "['Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even', 'Odd']\n"
     ]
    }
   ],
   "source": [
    "#using if/else statements with list comprehension\n",
    "nums=[\"Even\" if x%2 ==0 else \"Odd\" for x in range(10)]\n",
    "print(nums)\n",
    "\n",
    "nums=[]\n",
    "for n in range(10):\n",
    "    if n % 2 == 0:\n",
    "        nums.append(\"Even\")\n",
    "    else:\n",
    "        nums.append(\"Odd\")\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehension with variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "#creating a list of squared numbers from another list of numbers using list comprehension\n",
    "nums=[2,4,6,8]\n",
    "nums_squared=[n**2 for n in nums]\n",
    "print(nums_squared)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionary Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}\n"
     ]
    }
   ],
   "source": [
    "#creating a dictionary of even numbers and square values using comprehension\n",
    "nums=[x for x in range(10)]\n",
    "squares={x:x**2 for x in nums}\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[53.6, 69.80000000000001, 59.0, 89.6]\n"
     ]
    }
   ],
   "source": [
    "#Excercises\n",
    "degrees=[12,21,15,32]\n",
    "fah=[(9/5)*x + 32 for x in degrees]\n",
    "print(fah)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a no:25\n",
      "[25, 50, 75, 100]\n"
     ]
    }
   ],
   "source": [
    "inp=int(input(\"Enter a no:\"))\n",
    "div=[x for x in range(1,101) if x % inp == 0 ]\n",
    "print(div)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#using lambda to square a number\n",
    "(lambda x:x**2)(4)             #takes in 4 and returns the square"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#passing multiple arguments\n",
    "(lambda x,y:x+y)(10,3)         #x=10,y=3 and returns x+y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving Lambda function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function <lambda> at 0x000002045DE90D38>\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "#saving a lambda function\n",
    "product=lambda x,y:x * y\n",
    "print(product)\n",
    "result=product(10,5)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "#both if and else needs to be used with lambda functions\n",
    "greater = lambda x,y:x if x > y else y\n",
    "result=greater(10,5)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Returning a lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "#returning a lambda function from another function\n",
    "def my_func(n):\n",
    "    return lambda x:x * n\n",
    "doubler = my_func(2)           #returns equivalent of lambda x:x*2\n",
    "print(doubler(4))\n",
    "tripler = my_func(3)           #returns equivalent of lambda x:x*3\n",
    "print(tripler(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Map, Filter and Reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Map without lambdas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<map object at 0x0000017F9757BC08>\n",
      "[54.5, 56.480000000000004, 59.0, 48.56]\n"
     ]
    }
   ],
   "source": [
    "#using the map function without lambdas\n",
    "def convertDeg(c):\n",
    "    return (9/5) * c + 32\n",
    "temps = [12.5,13.6,15,9.2]\n",
    "converted_temps = map(convertDeg,temps)            #returns map object\n",
    "print(converted_temps)\n",
    "converted_temps=list(converted_temps)              #type convert map object into list of converted temps   \n",
    "print(converted_temps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Map with lambdas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[54.5, 56.480000000000004, 59.0, 48.56]\n"
     ]
    }
   ],
   "source": [
    "#using map function with lambdas\n",
    "temps = [12.5,13.6,15,9.2]\n",
    "converted_temps=list(map(lambda c:(9/5) * c + 32,temps))\n",
    "print(converted_temps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filter without lambdas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<filter object at 0x0000017F96F97508>\n",
      "[13.6, 15]\n"
     ]
    }
   ],
   "source": [
    "#using the filter functions without lambdas,filter out temps below 55F\n",
    "def filterTemps(c):\n",
    "    converted = (9/5) * c + 32\n",
    "    return True if converted > 55 else False     #use ternary operator\n",
    "temps = [12.5,13.6,15,9.2]\n",
    "filtered_temps = filter(filterTemps,temps)       #returns filter object\n",
    "print(filtered_temps)\n",
    "filtered_temps = list(filtered_temps)            #convert filtered object to list of filtered data\n",
    "print(filtered_temps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filter with lambdas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[13.6, 15]\n"
     ]
    }
   ],
   "source": [
    "#using the filter functions without lambdas,filter out temps below 55F\n",
    "temps = [12.5,13.6,15,9.2]\n",
    "filtered_temps = list(filter(lambda c:True if (9/5) * c + 32 > 55 else False,temps))\n",
    "print(filtered_temps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "nums = [1,2,3,4]\n",
    "result = reduce(lambda x,y:x*y,nums)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Ryan', 'Paul', 'Kevin Connors']\n"
     ]
    }
   ],
   "source": [
    "names = [\"    ryan\",\"PAUL\",\"kevin connors           \"]\n",
    "names_converted = list(map(lambda x: (x.strip()).title(),names))\n",
    "print(names_converted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Frank', 'Ripal']\n"
     ]
    }
   ],
   "source": [
    "names = [\"Amanda\",\"Frank\",\"abby\",\"Ripal\",\"Adam\"]\n",
    "names_filtered = list(filter(lambda x: False if (x.lower()).startswith('a') else True,names))\n",
    "print(names_filtered)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recursive functions and Memoization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understanding Recursive functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "##writing a factorial using recursive funciton\n",
    "def factorial(n):\n",
    "    if n <= 1 :\n",
    "        return 1\n",
    "    else:\n",
    "       return n * factorial(n-1)\n",
    "print(factorial(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "#writing recursive fibonacci sequence\n",
    "def fib(n):\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    else:\n",
    "        return fib(n-1) + fib(n-2)\n",
    "print(fib(5))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Memoization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#using memoization with fibonacci sequence\n",
    "cache = {}\n",
    "def fib(n):\n",
    "    if n in cache:\n",
    "        return cache[n]\n",
    "    result = 0\n",
    "    else:\n",
    "        return fib(n-1) + fib(n-2)\n"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}