adv_py_builtin_functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Map, Filter, Reduce, Lambda & Recursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tasks Today:\n",
    "\n",
    "1) <b>Lambda Functions</b> <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; a) Syntax <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; b) Saving to a Variable <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; c) Multiple Inputs <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; d) Passing a Lambda into a Function <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; e) Returning a Lambda from a Function <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; f) In-Class Exercise #1 <br>\n",
    "2) <b>Map</b> <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; a) Syntax <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; b) Using Lambda's with Map <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; c) In-Class Exercise #2 <br>\n",
    "3) <b>Filter</b> <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; a) Syntax <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; b) Using Lambda's with Filter <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; c) In-Class Exercise #3 <br>\n",
    "4) <b>Reduce</b> <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; a) Syntax <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; b) Using Lambda's with Reduce <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; c) In-Class Exercise #4 <br>\n",
    "5) <b>Recursion</b> <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; a) Implementing a Base <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; b) Writing a Factorial Function <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; c) In-Class Exercise #5 <br>\n",
    "6) <b>Generators & Iterators</b> <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; a) Yield Keyword <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; b) Inifinite Generator <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; c) In-Class Exercise #6 <br>\n",
    "7) <b>Exercises</b> <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; a) Exercise #1 - Filtering Empty Strings <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; b) Exercise #2 - Sorting with Last Name <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; c) Exercise #3 - Conversion to Farhenheit <br>\n",
    " &nbsp;&nbsp;&nbsp;&nbsp; d) Exercise #4 - Fibonacci Sequence <br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda Functions <br>\n",
    "<p>Lambda functions... or \"Anonymous Functions\" are referring to inline functions with no name. The keyword lambda denotes the no name function, and executes within a single line. Without saving it to a variable; however, it is not able to be used, unless passed in either as a paramater or within list comprehension.<br>Written as \"( (keyword lambda) (one or more inputs) (colon) (function to be executed) ) (value to pass into the lambda)\"</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "## basic function syntax\n",
    "\n",
    "def addTwo(x):\n",
    "    return x + 2\n",
    "print(addTwo(4))\n",
    "\n",
    "## Lambda function syntax\n",
    "\n",
    "a_var = 6\n",
    "# lambda function: 'input x ; get back x + 2'\n",
    "# pass input into lambda function by putting in parens right after it (a_var)\n",
    "print((lambda x: x + 2)(a_var))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Saving to a Variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# makes it slightly easier to reuse a lambda\n",
    "f_test = lambda x: x + 2\n",
    "f_test(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multiple Inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "# Multiple inputs with no variable\n",
    "print((lambda x,y,z: x * y * z)(3,5,8))\n",
    "\n",
    "# same but saved to a variable for re-use\n",
    "x_test = lambda x,y,z: x * y * z\n",
    "print(x_test(3,5,8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Passing a Lambda into a Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# From style of coding called Functional Programming\n",
    "def multiply(f, num):\n",
    "    \"\"\"\n",
    "        f expects a lambda function\n",
    "        num expects a number\n",
    "    \"\"\"\n",
    "    return f(num)\n",
    "\n",
    "multiply(lambda x: x * x, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Returning a Lambda from a Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function returnFunc.<locals>.multiply at 0x7fe2f862df70>\n",
      "8\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "# Normal defined function\n",
    "def multiply_test(num):\n",
    "    return num * 4\n",
    "\n",
    "# Function within a function\n",
    "def returnFunc():\n",
    "    test = 4\n",
    "    def multiply(num):\n",
    "        return num * 2\n",
    "    return multiply\n",
    "\n",
    "f_return = returnFunc()\n",
    "print(returnFunc())\n",
    "# 4 gets passed into returnFunc() -> multiply() -> 4 * 2 = 8\n",
    "print(f_return(4))\n",
    "\n",
    "# Lambda function return from a regular function\n",
    "def returnLam(b,c):\n",
    "    return lambda x,a: x + a + b + c\n",
    "r_lamb = returnLam(4,5)\n",
    "# still missing x,a so need to pass those in\n",
    "print(r_lamb(5,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### If Statements within Lambdas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "# feels similar to list comprehension\n",
    "# Lambda x: True if (condition) else False\n",
    "f_condition = lambda num : num * 2 if num > 10 else num + 2\n",
    "\n",
    "print(f_condition(8))\n",
    "print(f_condition(15))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### In-Class Exercise #1 <br>\n",
    "<p>Write an anonymous function that cubes the arguments passed in and assign the anonymous function to a variable 'f'.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "27"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = lambda x: x**3\n",
    "f(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Map <br>\n",
    "<p>The map function allows you to iterate over an entire list while running a function on each item of the list. This is why the map function works well with lambda's, because it simplifies things and you write less lines of code.<br>The syntax for a map function is \"map(function to be used, list to be used)\"<br>However, you must be careful, as the map function returns a map object, not a list. To turn it into a list we use the list() type conversion.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(16, 16), (11, 10), (20, 3), (9, 4), (15, 6)]\n"
     ]
    }
   ],
   "source": [
    "# map(function, iterable)\n",
    "# an iterable is something you can loop over such as list, dict, tuple, set, or string\n",
    "# Normally, the usage of map happens with a pre-defined function, but we can use lambdas as well\n",
    "def squared(num, num2):\n",
    "    if num < 10 and num2 < 10:\n",
    "        return num ** 2, num2 ** 2\n",
    "    else:\n",
    "        return num, num2\n",
    "    \n",
    "numbers = [4,11,20,3,15,20]\n",
    "more_nums = [4,10,3,2,6]\n",
    "\n",
    "# pass in the squared function, and it will run on numbers and more_nums\n",
    "\n",
    "# want as a list instead of the map data type which can be tricky\n",
    "squared_nums_map = list(map(squared, numbers, more_nums))\n",
    "print(squared_nums_map)\n",
    "# didn' run on the 20 in numbers because there wasn't a matching \n",
    "# index in more_nums which was shorter by 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using Lambda's with Map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(16, 16), (11, 10), (20, 3), (9, 4), (15, 6)]\n"
     ]
    }
   ],
   "source": [
    "# map(lambda x: do something, iterable)\n",
    "# using lambda in map usually all takes place on one line\n",
    "# make it a list instead of dealing with map data type\n",
    "squared_nums_lamb = list(map(lambda x, y : (x ** 2, y ** 2) if x < 10 and y < 10 else (x,y), numbers, more_nums))\n",
    "print(squared_nums_lamb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### In-Class Exercise #2 <br>\n",
    "<p>Use the map function to double each number and minus it by one in the list by using a lambda function</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 3), (3, 7), (5, 11), (7, 15), (9, 19)]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,4,5]\n",
    "y = [2,4,6,8,10]\n",
    "double_minus_lamb = list(map(lambda x, y : (x * 2 - 1,y * 2 - 1),x,y))\n",
    "print(double_minus_lamb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filter() <br>\n",
    "<p>Filter's are similar to the map function, where you're able to pass a function argument and a list argument and filter out something from the list based on the conditions passed. Similar to the map function, it returns a filter object, so you need to type convert it to a list()</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Andy', 'Angelica']\n"
     ]
    }
   ],
   "source": [
    "names = ['Bob', 'Andy', 'Max', 'Evan', 'Angelica']\n",
    "\n",
    "# function arguments for filters must return either True or False\n",
    "# will apply the bool to a list and only return those that are True\n",
    "def a_names(name):\n",
    "    if name[0].lower() == 'a':\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "# will apply the function a_names to the original list of names\n",
    "new_names_list = list(filter(a_names, names))\n",
    "print(new_names_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using Lambda's with Filter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Andy', 'Angelica']\n"
     ]
    }
   ],
   "source": [
    "new_names_lamb = list(filter(lambda name: True if name[0].lower() == 'a' else False, names))\n",
    "print(new_names_lamb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### In-Class Exercise #3 <br>\n",
    "<p>Filter out all the numbers that are below the mean of the list.<br><b>Hint: Import the 'statistics' module</b></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.728571428571429\n",
      "[7, 9, 4.9]\n"
     ]
    }
   ],
   "source": [
    "from statistics import mean\n",
    "# mean is sum of all vavlues in an entity divided by the number of values in the entity\n",
    "\n",
    "nums = [2,7,4.2,1.6,9,4.4,4.9]\n",
    "mean_nums = mean(nums)\n",
    "print(mean_nums)\n",
    "\n",
    "def below_mean(number):\n",
    "    if number >= mean_nums:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "new_nums_list = list(filter(below_mean, nums)) \n",
    "print(new_nums_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reduce() <br>\n",
    "<p>Be very careful when using this function, as of Python 3 it's been moved to the 'functools' library and no longer is a built-in function.<br>The creator of Python himself, says to just use a for loop instead.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# just use a for loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using Lambda's with Reduce()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### In-Class Exercise #4 <br>\n",
    "<p>Use the reduce function to multiply the numbers in the list below together with a lambda function.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recursion <br>\n",
    "<p>Recursion means that a function is calling itself, so it contanstly executes until a base case is reached. It will then push the returning values back up the chain until the function is complete. A prime example of recursion is computing factorials... such that 5! (factorial) is 5*4*3*2*1 which equals 120.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Implementing a Base Case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "addNums(5) = 5 + addNums(4)\n",
      "addNums(4) = 4 + addNums(3)\n",
      "addNums(3) = 3 + addNums(2)\n",
      "addNums(2) = 2 + addNums(1)\n",
      "addNums(1) = 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# extraordinarily useful and cool tool, but situational\n",
    "# i.e. this would never end; bad recursion\n",
    "# def add_two(x):\n",
    "#     return add_two(x)\n",
    "    \n",
    "def addNums(num):\n",
    "    # set a base case to stop recursion from going forever!!!\n",
    "    # will sometimes use 1, sometimes 0; important to learn when\n",
    "    if num <= 1:\n",
    "        print(f\"addNums(1) = 1\")\n",
    "        return num\n",
    "    else:\n",
    "        print(f\"addNums({num}) = {num} + addNums({num - 1})\")\n",
    "        return num + addNums(num - 1)\n",
    "\n",
    "addNums(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Writing a Factorial Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 5! = 5 * 4 * 3 * 2 * 1\n",
    "def factorial(num):\n",
    "    if num <= 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return num * factorial(num - 1)\n",
    "\n",
    "factorial(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### In-Class Exercise #5 <br>\n",
    "<p>Write a recursive function that subtracts all numbers to the argument given.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "subNums(5) = 5 - subNums(4)\n",
      "subNums(4) = 4 - subNums(3)\n",
      "subNums(3) = 3 - subNums(2)\n",
      "subNums(2) = 2 - subNums(1)\n",
      "subNums(1) = 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# whatever number you are given is going to subtract the top number from there\n",
    "# Output: \n",
    "    # subNums(5) = 5 - subNums(4)\n",
    "    # subNums(4) = 4 - subNums(3)\n",
    "    # subNums(3) = 3 - subNums(2)\n",
    "    # subNums(2) = 2 - subNums(1)\n",
    "    # subNums(1) = 1\n",
    "def subNums(num):\n",
    "    # set a base case to stop recursion from going forever!!!\n",
    "    # will sometimes use 1, sometimes 0; important to learn when\n",
    "    if num <= 1:\n",
    "        print(f\"subNums(1) = 1\")\n",
    "        return num\n",
    "    else:\n",
    "        print(f\"subNums({num}) = {num} - subNums({num - 1})\")\n",
    "        return num + subNums(num - 1)\n",
    "\n",
    "subNums(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generators <br>\n",
    "<p>Generators are a type of iterable, like lists or tuples. They do not allow indexing, but they can still be iterated through with for loops. They are created using functions and the yield statement.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Yield Keyword <br>\n",
    "<p>The yield keyword denotes a generator, it doesn't return so it won't leave the function and reset all variables in the function scope, instead it yields the number back to the caller.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "# little finnicky, not used often but useful to know\n",
    "# when an object is 'yielded', you can use it but it is not the same as being returned\n",
    "# returning stops everything, yielding allows whatever is calling the function to use the object\n",
    "# but it continues on without stopping, which can be useful\n",
    "def my_range(stop, start = 0, step = 2):\n",
    "    while start < stop:\n",
    "        yield start\n",
    "        start += step\n",
    "        \n",
    "# have to parse over a generator object to get values back\n",
    "for i in my_range(20):\n",
    "    my_generator_value = i\n",
    "    print(my_generator_value)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Infinite Generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bad, never create infinite loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### In-Class Exercise #6 <br>\n",
    "<p>Create a generator that takes a number argument and yields that number squared, then prints each number squared until zero is reached.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "4\n",
      "16\n",
      "36\n",
      "64\n",
      "100\n",
      "144\n",
      "196\n",
      "256\n",
      "324\n"
     ]
    }
   ],
   "source": [
    "def my_range(stop, start = 0, step = 2):\n",
    "    while start < stop:\n",
    "        yield start ** 2\n",
    "        start += step\n",
    "        \n",
    "# have to parse over a generator object to get values back\n",
    "for i in my_range(20):\n",
    "    my_generator_value = i\n",
    "    print(my_generator_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise #1 <br>\n",
    "<p>Filter out all of the empty strings from the list below</p>\n",
    "\n",
    "`Output: ['Argentina', 'San Diego', 'Boston', 'New York']`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Argentina', 'San Diego', 'Boston', 'New York']\n"
     ]
    }
   ],
   "source": [
    "places = [\" \",\"Argentina\", \" \", \"San Diego\",\"\",\"  \",\"\",\"Boston\",\"New York\"]\n",
    "\n",
    "def empty_strings(name):\n",
    "    # whitespace or empty string\n",
    "    if name.startswith(' ') or not name:\n",
    "        return False\n",
    "    else:\n",
    "        return True\n",
    "\n",
    "# will apply the function empty_strings to the original list of places\n",
    "non_empties_list = list(filter(empty_strings, places))\n",
    "print(non_empties_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise #2 <br>\n",
    "<p>Write an anonymous function that sorts this list by the last name...<br><b>Hint: Use the \".sort()\" method and access the key\"</b></p>\n",
    "\n",
    "`Output: ['Victor aNisimov', 'Gary A.J. Bernstein', 'Joel Carter', 'Andrew P. Garfield', 'David hassELHOFF']`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Victor aNisimov', 'Gary A.J. Bernstein', 'Joel Carter', 'Andrew P. Garfield', 'David hassELHOFF']\n"
     ]
    }
   ],
   "source": [
    "author = [\"Joel Carter\", \"Victor aNisimov\", \"Andrew P. Garfield\",\"David hassELHOFF\",\"Gary A.J. Bernstein\"]\n",
    "\n",
    "def sortLast(list):\n",
    "    \n",
    "    last_names = []\n",
    "    sorted_list = []\n",
    "    \n",
    "    for name in list:\n",
    "        last_names.append(name.split())\n",
    "      \n",
    "    # use lambda to set sorting key to the last word in each name\n",
    "    for name in sorted(last_names, key = lambda x: x[-1].lower()):\n",
    "        sorted_list.append(' '.join(name))\n",
    "        \n",
    "    return sorted_list\n",
    "\n",
    "print(sortLast(author))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise #3 <br>\n",
    "<p>Convert the list below from Celsius to Farhenheit, using the map function with a lambda...</p>\n",
    "\n",
    "`Output: [('Nashua', 89.6), ('Boston', 53.6), ('Los Angelos', 111.2), ('Miami', 84.2)]\n",
    "`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Nashua', 89.6), ('Boston', 53.6), ('Los Angelos', 111.2), ('Miami', 84.2)]\n"
     ]
    }
   ],
   "source": [
    "# F = (9/5)*C + 32\n",
    "places = [('Nashua',32),(\"Boston\",12),(\"Los Angelos\",44),(\"Miami\",29)]\n",
    "cels_to_fahr = list(map(lambda x: (x[0], (9/5)*x[1] + 32), places))\n",
    "print(cels_to_fahr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise #4 <br>\n",
    "<p>Write a recursion function to perform the fibonacci sequence up to the number passed in.</p>\n",
    "\n",
    "`Output for fib(5) => \n",
    "Iteration 0: 1\n",
    "Iteration 1: 1\n",
    "Iteration 2: 2\n",
    "Iteration 3: 3\n",
    "Iteration 4: 5\n",
    "Iteration 5: 8`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 0: 0\n",
      "Iteration 1: 1\n",
      "Iteration 2: 1\n",
      "Iteration 3: 2\n",
      "Iteration 4: 3\n",
      "Iteration 5: 5\n"
     ]
    }
   ],
   "source": [
    "# fibonacci sequence ; Fn = Fn-1 + Fn-2\n",
    "# i.e. 0,1,1,2,3,5,8,13,21,34,55,89,144...\n",
    "# add two previous numbers to get next number\n",
    "def fibonacci(n):\n",
    "    \"\"\"\n",
    "    n is number of desired iterations of fibonacci sequence\n",
    "    \"\"\"\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    else:\n",
    "        return fibonacci(n-1) + fibonacci(n-2)\n",
    "\n",
    "for i in range(6):\n",
    "    print(f\"Iteration {i}: {fibonacci(i)}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}