Week_8_Efficiency.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 8 Coding Efficiency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating a list for ten numbers using list comprehension\n",
    "\n",
    "nums = [x for x in range(100)]\n",
    "print(nums)\n",
    "\n",
    "# or you could do this, with more lines..... obviously above is better and more readable.\n",
    "nums1 = []\n",
    "for x in range(100):\n",
    "    nums1.append(x)\n",
    "\n",
    "print(nums1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using if statements within list comprehension\n",
    "\n",
    "nums = [x for x in range(10) if x % 2 == 0]\n",
    "\n",
    "print(nums)\n",
    "# or you could do this, with more lines..... obviously above is better and more readable.\n",
    "\n",
    "nums1 = []\n",
    "for x in range(10):\n",
    "    if x % 2 == 0:\n",
    "        nums1.append(x)\n",
    "\n",
    "print(nums1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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 within list comprehension\n",
    "\n",
    "nums = [\"Even\" if x % 2 == 0 else \"Odd\" for x in range(10)]\n",
    "\n",
    "print(nums)\n",
    "\n",
    "# or this...\n",
    "\n",
    "nums1 = []\n",
    "for x in range(10):\n",
    "    if x % 2 == 0:\n",
    "        nums1.append(\"Even\")\n",
    "    else:\n",
    "        nums1.append(\"Odd\")\n",
    "\n",
    "print(nums1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating a list from a list using list comprehension\n",
    "\n",
    "nums = [2,4,6,8]\n",
    "squared_nums = [i**2 for i in nums]\n",
    "\n",
    "print(squared_nums)\n",
    "\n",
    "# or...\n",
    "\n",
    "squared_nums1 = []\n",
    "for i in nums:\n",
    "    squared_nums1.append(i**2)\n",
    "\n",
    "print(squared_nums1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionary comprehension\n",
    "\n",
    "numbers = [x for x in range(10)]\n",
    "squares = { num : num**2 for num in numbers if num % 2 == 0 }\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Excercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Degree conversion\n",
    "\n",
    "tempc = [12,21,15,32]\n",
    "\n",
    "tempf = [ ((9 / 5 ) * i + 32) for i in tempc]\n",
    "\n",
    "print(tempf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]\n"
     ]
    }
   ],
   "source": [
    "# Divisible or not...\n",
    "\n",
    "num = int(input(\"Please input a whole number up the value of 100: \"))\n",
    "\n",
    "numdiv = [i for i in range(100) if i % num == 0]\n",
    "\n",
    "print(numdiv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# lamba functions\n",
    "like Gordon Freeman?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using a lambda to square a number\n",
    "\n",
    "( lambda x : x**2 )(4)\n",
    "\n",
    "# or like this\n",
    "\n",
    "def square(x):\n",
    "    return x**2\n",
    "square(4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# passing multiple arguments in a lambda\n",
    "\n",
    "( lambda x,y : x * y )(10,5)\n",
    "\n",
    "# or....\n",
    "\n",
    "def multiply(x,y):\n",
    "    return x * y\n",
    "num = multiply(10,5)\n",
    "print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# writing lambda functions to a variable\n",
    "\n",
    "square = lambda x,y : x * y\n",
    "print(square) # this will just print where the function is being stored in memory\n",
    "result = square(10,5)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using conditionals within a lambda\n",
    "\n",
    "greater = lambda x,y : x if x > y else y\n",
    "\n",
    "result = greater(5,10)\n",
    "print(result)\n",
    "\n",
    "# or this...\n",
    "\n",
    "def greater2(x,y):\n",
    "    if x > y:\n",
    "        return x\n",
    "    else:\n",
    "        return y\n",
    "result1 = greater2(5,10)\n",
    "print(result1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returning lambdas from functions\n",
    "\n",
    "def my_func(n):\n",
    "    return lambda x : x * n\n",
    "\n",
    "doubler = my_func(2)    # here it is returning lambda x : x * 2\n",
    "print(doubler(5))\n",
    "\n",
    "tripler = my_func(3)\n",
    "print(tripler(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fill in the blanks:\n",
    "\n",
    "half_century = lambda x : True if x > 50 else False\n",
    "\n",
    "num = int(input(\"Enter a number: \"))\n",
    "\n",
    "if not half_century(num):  # If the number is not greater than 50\n",
    "    print(\"Your number is less than or equal to 50\")\n",
    "else:\n",
    "    print(\"Your number is greater than 50\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Degree conversion revisit....\n",
    "\n",
    "\n",
    "tempf = lambda i : ( ( 9 / 5 ) * i + 32 )\n",
    "\n",
    "tempc = float(12)\n",
    "\n",
    "k = tempf(tempc)\n",
    "l = tempf(12)\n",
    "\n",
    "print(k)\n",
    "print(l)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Map, Filter and Reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using a map function without lambdas\n",
    "\n",
    "def convertDegC(C):\n",
    "    return (9/5) * C + 32\n",
    "\n",
    "temps = [12.5, 13.6, 15, 9.2]\n",
    "\n",
    "converted_temps = map(convertDegC, temps)\n",
    "print(converted_temps)\n",
    "\n",
    "converted_temps = list(converted_temps)\n",
    "print(converted_temps)\n",
    "\n",
    "# essentially the same as:\n",
    "\n",
    "for item in temps:\n",
    "    convertDegC(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[54.5, 56.480000000000004, 59.0, 48.56]\n",
      "[54.5, 56.480000000000004, 59.0, 48.56]\n"
     ]
    }
   ],
   "source": [
    "# using a map function with lambdas\n",
    "\n",
    "temps = [12.5, 13.6, 15, 9.2]\n",
    "converted_temps = list( map( lambda C : (9/5) * C +32, temps))      # usefull to have type conversion in single line\n",
    "print(converted_temps)\n",
    "\n",
    "# or something like this....\n",
    "\n",
    "def convertDeg(degrees):\n",
    "    converted = []\n",
    "    for degree in degrees:\n",
    "        result = (9/5) * degree + 32\n",
    "        converted.append(result)\n",
    "    return converted\n",
    "\n",
    "converted_temps1 = convertDeg(temps)\n",
    "print(converted_temps1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<filter object at 0x75db2ebaca90>\n",
      "[13.6, 15]\n"
     ]
    }
   ],
   "source": [
    "# Using filter function without lambdas\n",
    "\n",
    "temps = [12.5, 13.6, 15, 9.2]\n",
    "\n",
    "def filterTemps(C):\n",
    "    converted = (9/5) * C + 32\n",
    "    return True if converted > 55 else False\n",
    "\n",
    "filtered_temps = filter(filterTemps, temps)\n",
    "print(filtered_temps)\n",
    "\n",
    "filtered_temps = list(filtered_temps)\n",
    "print(filtered_temps)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[13.6, 15]\n",
      "[13.6, 15]\n"
     ]
    }
   ],
   "source": [
    "# using filter with lambda functions\n",
    "\n",
    "temps = [12.5, 13.6, 15, 9.2]\n",
    "\n",
    "filtered_temps = list( filter( lambda C : True if ( 9/5 )* C + 32 > 55 else False, temps))\n",
    "print(filtered_temps)\n",
    "\n",
    "# or.....\n",
    "\n",
    "def convertDeg(degrees):\n",
    "    filtered = []\n",
    "    for degree in degrees:\n",
    "        result = (9/5) * degree + 32\n",
    "        if result > 55:\n",
    "            filtered.append(degree)\n",
    "    return filtered\n",
    "\n",
    "filtered_temps1 = convertDeg(temps)\n",
    "print(filtered_temps1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "24\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "# for teaching purposes only.... reduce()\n",
    "\n",
    "from functools import reduce\n",
    "\n",
    "nums = [1,2,3,4]\n",
    "\n",
    "result = reduce( lambda a, b : a * b, nums)\n",
    "print(result)\n",
    "\n",
    "# or something like this:\n",
    "\n",
    "total = 1\n",
    "for n in nums:\n",
    "    total = total * n\n",
    "\n",
    "print(total)\n",
    "\n",
    "# or in a function....\n",
    "\n",
    "def calcProduct(nums):\n",
    "    total = 1\n",
    "    for num in nums:\n",
    "        total = total * num\n",
    "    return total\n",
    "\n",
    "print(calcProduct(nums))\n",
    "\n",
    "# in general, probably don't use reduce() as for more complicated data structures, better to fully define the for loop.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Excercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Ryan', 'Paul', 'Kevin connors']\n",
      "['Ryan', 'Paul', 'Kevin Connors']\n"
     ]
    }
   ],
   "source": [
    "# mapping names\n",
    "\n",
    "names = [\"ryan\", \"PAUL\", \"kevin connors    \"]\n",
    "\n",
    "names_formatted = list(map( lambda name : name.rstrip( ).capitalize(), names ))\n",
    "\n",
    "print(names_formatted)\n",
    "\n",
    "# Top example didn't quite work, so this one below does\n",
    "\n",
    "names_formatted2 = list(map( lambda name: name.rstrip( ).title(), names))\n",
    "print(names_formatted2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Frank', 'Ripal']\n",
      "['Amanda', 'Frank', 'Abby', 'Ripal', 'Adam']\n",
      "['Frank', 'Ripal']\n"
     ]
    }
   ],
   "source": [
    "# Filter names\n",
    "\n",
    "names = ['Amanda','Frank','abby','Ripal','Adam']\n",
    "\n",
    "names_filtered = list(filter( lambda name: not name.lower().startswith('a'), names))\n",
    "print(names_filtered)\n",
    "\n",
    "# or like this, but I like the one above, as its a bit more readable.\n",
    "\n",
    "names_capitalized = [name.capitalize() for name in names]   # using list comprehension\n",
    "\n",
    "names_filtered1 = list(filter( lambda name : name[0] != 'A', names_capitalized))\n",
    "print(names_filtered1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recursive functions and Memoization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64034522846623895262347970319503005850702583026002959458684445942802397169186831436278478647463264676294350575035856810848298162883517435228961988646802997937341654150838162426461942352307046244325015114448670890662773914918117331955996440709549671345290477020322434911210797593280795101545372667251627877890009349763765710326350331533965349868386831339352024373788157786791506311858702618270169819740062983025308591298346162272304558339520759611505302236086810433297255194852674432232438669948422404232599805551610635942376961399231917134063858996537970147827206606320217379472010321356624613809077942304597360699567595836096158715129913822286578579549361617654480453222007825818400848436415591229454275384803558374518022675900061399560145595206127211192918105032491008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n"
     ]
    }
   ],
   "source": [
    "# writing a factorial using recursive function\n",
    "\n",
    "def factorial(n):\n",
    "    # set base case\n",
    "    if n <= 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return factorial( n - 1) * n\n",
    "    \n",
    "print(factorial(400))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n",
      "89\n",
      "144\n",
      "233\n",
      "377\n",
      "610\n",
      "987\n",
      "1597\n",
      "2584\n",
      "4181\n",
      "6765\n",
      "10946\n",
      "17711\n",
      "28657\n",
      "46368\n",
      "75025\n",
      "121393\n",
      "196418\n",
      "317811\n",
      "514229\n",
      "832040\n",
      "1346269\n",
      "2178309\n",
      "3524578\n",
      "5702887\n"
     ]
    }
   ],
   "source": [
    "# fibonacci sequence\n",
    "\n",
    "def fib(n):\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    else:\n",
    "        return fib( n - 1 ) + fib ( n -2 )\n",
    "\n",
    "# note this is not the most efficient due to the branching nature of this iterative function\n",
    "for n in range(35):\n",
    "    print(fib(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875\n"
     ]
    }
   ],
   "source": [
    "# using memoization with the fibonacci sequence\n",
    "\n",
    "cache = {}\n",
    "def fib(n):\n",
    "    if n in cache:\n",
    "        return cache[n]\n",
    "    result = 0\n",
    "    if n <= 1:\n",
    "        result = n\n",
    "    else:\n",
    "        result = fib(n-1) + fib(n-2)\n",
    "    cache[n] = result\n",
    "    return result\n",
    "\n",
    "print(fib(1000))\n",
    "#print(cache) # This prints out the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12586269025"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using @lru_cache, Python's default moization/caching technique\n",
    "\n",
    "from functools import lru_cache\n",
    "@lru_cache()\n",
    "\n",
    "def fib(n):\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    else:\n",
    "        return fib(n-1) + fib(n-2)\n",
    "    \n",
    "fib(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64034522846623895262347970319503005850702583026002959458684445942802397169186831436278478647463264676294350575035856810848298162883517435228961988646802997937341654150838162426461942352307046244325015114448670890662773914918117331955996440709549671345290477020322434911210797593280795101545372667251627877890009349763765710326350331533965349868386831339352024373788157786791506311858702618270169819740062983025308591298346162272304558339520759611505302236086810433297255194852674432232438669948422404232599805551610635942376961399231917134063858996537970147827206606320217379472010321356624613809077942304597360699567595836096158715129913822286578579549361617654480453222007825818400848436415591229454275384803558374518022675900061399560145595206127211192918105032491008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n"
     ]
    }
   ],
   "source": [
    "# using cache for factorial() recursive function\n",
    "\n",
    "cache = {}\n",
    "\n",
    "def factorial(n):\n",
    "    # set base case\n",
    "    if n in cache:\n",
    "        return cache[n]\n",
    "    result = 1\n",
    "    if n <= 1:\n",
    "        result = n\n",
    "    else:\n",
    "        result = factorial( n - 1) * n\n",
    "    cache[n] = result\n",
    "    return result\n",
    "\n",
    "print(factorial(400))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "80658175170943878571660636856403766975289505440883277824000000000000\n"
     ]
    }
   ],
   "source": [
    "# using cache for factorial() recursive function using @lru_cache\n",
    "\n",
    "from functools import lru_cache\n",
    "@lru_cache()\n",
    "\n",
    "def factorial(n):\n",
    "    # set base case\n",
    "    if n <= 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return factorial( n - 1) * n\n",
    "    \n",
    "print(factorial(52))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your number 500 is not in the list\n"
     ]
    }
   ],
   "source": [
    "# searching data\n",
    "\n",
    "searchList = ([2,3,[18,22],6],22)\n",
    "\n",
    "def search(data,value):\n",
    "    for i in data:\n",
    "        if isinstance(i,list):\n",
    "            if search(i, value):\n",
    "                return True\n",
    "        elif i == value:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "value1 = int(input(\"What integer do you want to search for: \"))\n",
    "result = search(searchList,value1)\n",
    "\n",
    "if result == True:\n",
    "    print(\"Your number {} is in the list\".format(value1))\n",
    "else:\n",
    "    print(\"Your number {} is not in the list\".format(value1))\n",
    "    "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "bootcamp",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}