1.6_week6_map filter and reduce functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "328456d2",
   "metadata": {},
   "source": [
    "In this exercise I will be talking about the map, filter, and reduce functions which are examples of **python functional programming**. This functions allow the programmer to write simpler, shorter code, without necessarily needing to add additional lines with loops and branching.\n",
    "\n",
    "* `map(func, iterable)` applies the function 'func' evenly to all the items in the 'iterable' object\n",
    "* `filter(func, iterable)` takes in 'func' as a boolean condition. All the items in 'iterable' for which 'func' returns False are filtered out\n",
    "* `functools.reduce(func, iterable[ ,iterable])` applies a function of two arguments, 'func', cumulatively to the elements of 'iterable', optionally starting with an initial argument\n",
    "\n",
    "For this exercise I will be converting some angles (which are measured in radians) to floating point numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d20b897b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'%.3f'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sin, cos, tan, pi\n",
    "from typing import Tuple\n",
    "\n",
    "#we are setting the precision to the floating point numbers to be 3 decimal places\n",
    "%precision %.3f "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "94f1e2b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_trigf(val: float) -> Tuple[float]: #the funct takes in the floats and converts it into a tuple containing 3 elements (sin,cos,tan)\n",
    "    return sin(val), cos(val), tan(val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "05d643da",
   "metadata": {},
   "outputs": [],
   "source": [
    "angles = [0, pi/6, pi/4, pi/3, pi/2, pi, 3*pi/2, 2*pi] #creating a list of radians that need to be converted"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "909a036f",
   "metadata": {},
   "source": [
    "# For loop & list comprehension\n",
    "\n",
    "I will first use a for loop to show how the task can be done without the map,filter, and functools functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e16e0531",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0.000, 1.000, 0.000),\n",
       " (0.500, 0.866, 0.577),\n",
       " (0.707, 0.707, 1.000),\n",
       " (0.866, 0.500, 1.732),\n",
       " (1.000, 0.000, 16331239353195370.000),\n",
       " (0.000, -1.000, -0.000),\n",
       " (-1.000, -0.000, 5443746451065123.000),\n",
       " (-0.000, 1.000, -0.000)]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = []\n",
    "for el in angles:\n",
    "    res.append(compute_trigf(el))\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5b9cbcac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0.000, 1.000, 0.000),\n",
       " (0.500, 0.866, 0.577),\n",
       " (0.707, 0.707, 1.000),\n",
       " (0.866, 0.500, 1.732),\n",
       " (1.000, 0.000, 16331239353195370.000),\n",
       " (0.000, -1.000, -0.000),\n",
       " (-1.000, -0.000, 5443746451065123.000),\n",
       " (-0.000, 1.000, -0.000)]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = [compute_trigf(el) for el in angles]\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b1efee1",
   "metadata": {},
   "source": [
    "# `map()` function\n",
    "\n",
    "`map(func, iterable)` applies the function 'func' evenly to all the items in the 'iterable' object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "36731641",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x1c7fd4be890>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = []\n",
    "res = map(compute_trigf, angles) \n",
    "res #the output is a map object that needs to be converted to a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9e4ba146",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0.000, 1.000, 0.000),\n",
       " (0.500, 0.866, 0.577),\n",
       " (0.707, 0.707, 1.000),\n",
       " (0.866, 0.500, 1.732),\n",
       " (1.000, 0.000, 16331239353195370.000),\n",
       " (0.000, -1.000, -0.000),\n",
       " (-1.000, -0.000, 5443746451065123.000),\n",
       " (-0.000, 1.000, -0.000)]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(res) #convert from map -> list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "1f8021ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((0.000, 1.000, 0.000),\n",
       " (0.500, 0.866, 0.577),\n",
       " (0.707, 0.707, 1.000),\n",
       " (0.866, 0.500, 1.732),\n",
       " (1.000, 0.000, 16331239353195370.000),\n",
       " (0.000, -1.000, -0.000),\n",
       " (-1.000, -0.000, 5443746451065123.000),\n",
       " (-0.000, 1.000, -0.000))"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple(res) #convert from map -> tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a9a15fa",
   "metadata": {},
   "source": [
    "method 2: using the `lambda` function for list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "497dc6a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0.000, 1.000, 0.000),\n",
       " (0.500, 0.866, 0.577),\n",
       " (0.707, 0.707, 1.000),\n",
       " (0.866, 0.500, 1.732),\n",
       " (1.000, 0.000, 16331239353195370.000),\n",
       " (0.000, -1.000, -0.000),\n",
       " (-1.000, -0.000, 5443746451065123.000),\n",
       " (-0.000, 1.000, -0.000)]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(\n",
    "    #we are using lambda to perform the operations directly\n",
    "    #val is the input value from the angles list\n",
    "    map(lambda val: (sin(val), cos(val), tan(val)), angles) #lambda fits the function in-line\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd02855f",
   "metadata": {},
   "source": [
    "# `filter()` function\n",
    "\n",
    "`filter(func, iterable)` takes in 'func' as a boolean condition. All the items in 'iterable' for which 'func' returns False are filtered out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "bfed6a81",
   "metadata": {},
   "outputs": [],
   "source": [
    "from numbers import Number\n",
    "from typing import Any\n",
    "\n",
    "lst_to_filter = [1, 'bye', True, None, 2.5, 10, 'hello', tuple(), -6, 14.6, 7]\n",
    "\n",
    "def is_number(val: Any) -> bool: #the function takes in any value and converts it into a bool\n",
    "    #booloean types (true & false) are counted as numbers in Python\n",
    "    return isinstance(val, Number) and not isinstance(val, bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "85bb36de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2.500, 10, -6, 14.600, 7]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(is_number, lst_to_filter)) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2bf5707",
   "metadata": {},
   "source": [
    "# `functools.reduce()` function\n",
    "\n",
    "`functools.reduce(func, iterable[ ,iterable])` applies a function of two arguments, 'func', cumulatively to the elements of 'iterable', optionally starting with an initial argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "e1fa7908",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_to_sum = [1, 2.5, 10, -6, 14.6, 7, pi] #we need to get the sum of this list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "e428e548",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32.242"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#method 1: for loop\n",
    "res=0\n",
    "for el in lst_to_sum:\n",
    "    res+=el\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "ee01184d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32.242"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "reduce(lambda el, prev_sum: prev_sum + el, lst_to_sum, 0) #zero is the starting value. el is the list item"
   ]
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}