B09. Built In Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# B09: Built In Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has a lot of useful Built-in functions and we're going to explore a few of these below as well as signpost you to some more resources where you can learn more. Personally I use these functions quite rarely for data analysis, but knowing that they're there as well as having some stock code in your cookbook for them can save you time and effort."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get things off to the best possible start, Lambda isn't a built in function! It's very similar to defning a function via the def: keyword with two main differences:\n",
    "\n",
    "* They are written on a single line\n",
    "* You don't have to define a name for them, meaning that they can be anonymous (but don't have to be!)\n",
    "\n",
    "The idea is that you use lambda functions at the point they are created and then discard them. When we meet the map() function lambda will start to make more sense.\n",
    "\n",
    "The syntax for lambda is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "f = lambda x, y : x + y   # Basic syntax for a non-anonymous lambda function\n",
    "print(type(f),f(1,2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we've created two arguments for our function x & y. These are followed by a colon (:) and then the syntax of the function.\n",
    "\n",
    "As you'll see, there are a lot of similarities between lambda functions and list comprehensions. It's worth noting that Guido Van Rossum isn't a fan of lambda and uses list comprehensions instead, however lambda is widely used within the Python community and you're bound to stumble across it sooner or later so you'll have to understand it even if you don't use it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The map() function takes a function and a data structure (e.g. a list, dict, set etc.), and applies the function to every element of that data structure. You can then use it in conjunction with functions like list() and tuple() to output a transformed data structure. We'll first explore using it with a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def fahrenheit(T):\n",
    "    '''Function to convert Celsius to Fahrenheit'''\n",
    "    return ((float(9)/5)*T + 32)\n",
    "\n",
    "temp_c = [0, 5, 10, 15, 20, 25, 30]     # Using the range function to create a list of every 5th integer between 0 and 30\n",
    "temp_f = list(map(fahrenheit,temp_c))   # Taking a function and a data structure and applying the function to each item in the data structure\n",
    "\n",
    "temp_f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whilst this is pretty good, using lambda, we can make our code even simpler and more concise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "temp_c = list(range(0,35,5)) \n",
    "temp_f = list(map(lambda T:((float(9)/5)*T + 32), temp_c))\n",
    "temp_f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reduce is similar to map in that it takes a function and a data structure and applies the function to every element of that data structure. The main difference however is that it outputs a single value rather than a data structure as the output from the previous iterataion, becomes the input for the next one. \n",
    "\n",
    "One other thing to note is that this is the first time we're going to be importing a library into Python as the reduce() function is part of the functools library. We'll cover libraries/packages/modules/extensions in more detail later but for now all you need to know is the syntax to import the library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import functools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the functools library imported we can now access the reduce() function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mylist1 =[50,100,200,50]\n",
    "output = int(functools.reduce(lambda x,y: x+y,mylist1))\n",
    "output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reduce() function took our list and added all the components together in an iterative fashion before outputting a single value.\n",
    "\n",
    "Also note that we referenced the functools library when calling the reduce() function like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "functools.reduce()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also just import the reduce() function on its own:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from functools import reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's better to do this when you're only using a single function from a large library since it will free memory space and make Python more efficient. Also, if we import a particular element from a library in this manner, we don't need to reference the library itself when calling the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mylist1 =[50,100,200,50]\n",
    "output = int(reduce(lambda x,y: x+y,mylist1))\n",
    "output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The filter() function again takes two arguments, a function with a boolean output (true / false) and a data structure. It filters the data structure for values that resolve to True as a result of the function's boolean test. The syntax is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mylist2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n",
    "true_dat = list(filter(lambda item: item % 2 == 0,mylist2))       # Simple odd / even check\n",
    "true_dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last built in function we're going to explore is the zip() function. This function takes multiple arguments and aggregates elements from each into a single data structure into a tuple.\n",
    "\n",
    "That sounds a lot more complicated than it is, and hopefully it will become a lot clearer when we look at an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mylist3 = ['A','B','C','D']\n",
    "mylist4 = [1,2,3,4]\n",
    "zipped_list = list(zip(mylist3,mylist4))\n",
    "zipped_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see zip() has taken the corresponding items from each of our input lists and zipped them together in a tuple. We can add a third data structure of a different type also:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mytuple5 = ('!','\"','£','$')\n",
    "zipped_list = list(zip(mylist3,mylist4,mytuple5))\n",
    "zipped_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However since tuples aren't as versatile as lists we can also use zip as part of a list comprehension to output lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "[list(item) for item in zip(mylist3,mylist4,mytuple5)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further Reading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://docs.python.org/3.5/library/functions.html\">List of Built in Functions</a><br/>\n",
    "<a href=\"https://docs.python.org/3.5/library/functools.html\">The functools library</a><br/>"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}