notebooks/Functional_Introduction_To_Python_Section_2(Functions).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A Functional Introduction To Python\n",
    "## Section 1.  Introductory Concepts \n",
    "## <span style=\"color:blue\"> Section 2.  Functions</span>\n",
    "## Section 3.  Control Structures\n",
    "## Section 4.  Intermediate Topics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Section 2:  Functions\n",
    "*  Writing Functions\n",
    "*  Function arguments:  positional, keyword\n",
    "*  Functional Currying:  Passing uncalled functions\n",
    "*  Functions that Yield\n",
    "*  Decorators:  Functions that wrap other functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Writing Functions\n",
    "Learning to write a function is the most fundamental skill to learn in Python.  With a basic mastery of functions, it is possible to have an almost full command of the language.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Simple function\n",
    "The simplest functions just return a value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def favorite_martial_art():\n",
    "    return \"bjj\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bjj'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "favorite_martial_art()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Documenting Functions\n",
    "It is a very good idea to document functions.  \n",
    "In Jupyter Notebook and IPython docstrings can be viewed by referring to the function with a ?.  ie.\n",
    "```\n",
    "In [2]: favorite_martial_art_with_docstring?\n",
    "Signature: favorite_martial_art_with_docstring()\n",
    "Docstring: This function returns the name of my favorite martial art\n",
    "File:      ~/src/functional_intro_to_python/<ipython-input-1-bef983c31735>\n",
    "Type:      function\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def favorite_martial_art_with_docstring():\n",
    "    \"\"\"This function returns the name of my favorite martial art\"\"\"\n",
    "    return \"bjj\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### Docstrings of functions can be printed out by referring to ```__doc__```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This function returns the name of my favorite martial art'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "favorite_martial_art_with_docstring.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Function arguments: positional, keyword\n",
    "A function is most useful when arguments are passed to the function.\n",
    "New values for times are processed inside the function.\n",
    "This function is also a 'positional' argument, vs a keyword argument.  Positional arguments are processed in the order they are created in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def practice(times):\n",
    "    print(f\"I like to practice {times} times a day\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I like to practice 2 times a day\n"
     ]
    }
   ],
   "source": [
    "practice(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I like to practice 3 times a day\n"
     ]
    }
   ],
   "source": [
    "practice(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Positional Arguments are processed in order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def practice(times, technique, duration):\n",
    "    print(f\"I like to practice {technique}, {times} times a day, for {duration} minutes\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I like to practice leg locks, 3 times a day, for 45 minutes\n"
     ]
    }
   ],
   "source": [
    "practice(3, \"leg locks\", 45)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Keyword Arguments are processed by key, value and can have default values\n",
    "One handy feature of keyword arguments is that you can set defaults and only change the defaults you want to change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def practice(times=2, technique=\"kimura\", duration=60):\n",
    "    print(f\"I like to practice {technique}, {times} times a day, for {duration} minutes\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I like to practice kimura, 2 times a day, for 60 minutes\n"
     ]
    }
   ],
   "source": [
    "practice()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I like to practice kimura, 2 times a day, for 90 minutes\n"
     ]
    }
   ],
   "source": [
    "practice(duration=90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### \\*\\*kwargs and \\*args\n",
    "* allow dynamic argument passing to functions\n",
    "* Should be used with discretion because it can make code hard to understand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def attack_techniques(**kwargs):\n",
    "    \"\"\"This accepts any number of keyword arguments\"\"\"\n",
    "    \n",
    "    for name, attack in kwargs.items():\n",
    "        print(f\"This is attack I would like to practice: {attack}\")\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is attack I would like to practice: kimura\n",
      "This is attack I would like to practice: straight_ankle_lock\n",
      "This is attack I would like to practice: arm_triangle\n"
     ]
    }
   ],
   "source": [
    "attack_techniques(arm_attack=\"kimura\", \n",
    "                  leg_attack=\"straight_ankle_lock\", neck_attach=\"arm_triangle\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### passing dictionary of keywords to function\n",
    "**kwargs syntax can also be used to pass in arguments all at once"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "attacks = {\"arm_attack\":\"kimura\", \n",
    "           \"leg_attack\":\"straight_ankle_lock\", \n",
    "           \"neck_attach\":\"arm_triangle\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is attack I would like to practice: kimura\n",
      "This is attack I would like to practice: straight_ankle_lock\n",
      "This is attack I would like to practice: arm_triangle\n"
     ]
    }
   ],
   "source": [
    "attack_techniques(**attacks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Passing Around Functions\n",
    "Object-Oriented programming is a very popular way to program, but it isn't the only style available in Python.  For concurrency and for Data Science, functional programming fits as a complementary style.\n",
    "\n",
    "In the example, below a function can be used inside of another function by being passed into the function itself as an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def attack_location(technique):\n",
    "    \"\"\"Return the location of an attack\"\"\"\n",
    "    \n",
    "    attacks = {\"kimura\": \"arm_attack\",\n",
    "           \"straight_ankle_lock\":\"leg_attack\", \n",
    "           \"arm_triangle\":\"neck_attach\"}\n",
    "    if technique in attacks:\n",
    "        return attacks[technique]\n",
    "    return \"Unknown\"\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'arm_attack'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "attack_location(\"kimura\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Unknown'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "attack_location(\"bear hug\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def multiple_attacks(attack_location_function):\n",
    "    \"\"\"Takes a function that categorizes attacks and returns location\"\"\"\n",
    "    \n",
    "    new_attacks_list = [\"rear_naked_choke\", \"americana\", \"kimura\"]\n",
    "    for attack in new_attacks_list:\n",
    "        attack_location = attack_location_function(attack)\n",
    "        print(f\"The location of attack {attack} is {attack_location}\")\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'attack_location' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-b8c3a164e6e6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmultiple_attacks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mattack_location\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'attack_location' is not defined"
     ]
    }
   ],
   "source": [
    "multiple_attacks(attack_location)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Closures and Functional Currying\n",
    "Closures are functions that contain other nested functions.\n",
    "In Python, a common way to use them is to keep track of the state.\n",
    "In the example below, the outer function, attack_counter keeps track of counts of attacks.\n",
    "The inner fuction attack_filter uses the \"nonlocal\" keyword in Python3, to modify the variable in the outer function.\n",
    "\n",
    "This approach is called **\"functional currying\"**.  It allows for a specialized function to be created from general functions.  As shown below, this style of function could be the basis of a simple video game or maybe for the statistics crew of a mma match."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def attack_counter():\n",
    "    \"\"\"Counts number of attacks on part of body\"\"\"\n",
    "    lower_body_counter = 0\n",
    "    upper_body_counter = 0\n",
    "    def attack_filter(attack):\n",
    "        nonlocal lower_body_counter\n",
    "        nonlocal upper_body_counter\n",
    "        attacks = {\"kimura\": \"upper_body\",\n",
    "           \"straight_ankle_lock\":\"lower_body\", \n",
    "           \"arm_triangle\":\"upper_body\",\n",
    "            \"keylock\": \"upper_body\",\n",
    "            \"knee_bar\": \"lower_body\"}\n",
    "        if attack in attacks:\n",
    "            if attacks[attack] == \"upper_body\":\n",
    "                upper_body_counter +=1\n",
    "            if attacks[attack] == \"lower_body\":\n",
    "                lower_body_counter +=1\n",
    "        print(f\"Upper Body Attacks {upper_body_counter}, Lower Body Attacks {lower_body_counter}\")\n",
    "    return attack_filter\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "fight = attack_counter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Upper Body Attacks 1, Lower Body Attacks 0\n"
     ]
    }
   ],
   "source": [
    "fight(\"kimura\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Upper Body Attacks 1, Lower Body Attacks 1\n"
     ]
    }
   ],
   "source": [
    "fight(\"knee_bar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Upper Body Attacks 2, Lower Body Attacks 1\n"
     ]
    }
   ],
   "source": [
    "fight(\"keylock\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Functions that Yield (Generators)\n",
    "A very useful style of programming is \"lazy evaluation\".  A generator is an example of that.  Generators yield an items at a time.\n",
    "\n",
    "The example below return an \"infinite\" random sequence of attacks.  The lazy portion comes into play in that while there is an infinite amount of values, they are only returned when the function is called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def lazy_return_random_attacks():\n",
    "    \"\"\"Yield attacks each time\"\"\"\n",
    "    import random\n",
    "    attacks = {\"kimura\": \"upper_body\",\n",
    "           \"straight_ankle_lock\":\"lower_body\", \n",
    "           \"arm_triangle\":\"upper_body\",\n",
    "            \"keylock\": \"upper_body\",\n",
    "            \"knee_bar\": \"lower_body\"}\n",
    "    while True:\n",
    "        random_attack = random.choices(list(attacks.keys()))\n",
    "        yield random_attack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "attack = lazy_return_random_attacks()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "generator"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(attack)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "    attacks = {\"kimura\": \"upper_body\",\n",
    "           \"straight_ankle_lock\":\"lower_body\", \n",
    "           \"arm_triangle\":\"upper_body\",\n",
    "            \"keylock\": \"upper_body\",\n",
    "            \"knee_bar\": \"lower_body\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['keylock']\n",
      "['keylock']\n",
      "['arm_triangle']\n"
     ]
    }
   ],
   "source": [
    "for _ in range(3):\n",
    "    print(next(attack))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Decorators:  Functions that wrap other functions\n",
    "Another useful technique in Python is to use the decorator syntax to wrap one function with another function.\n",
    "In the example below, a decorator is written that adds random sleep to each function call.  When combined with the previous \"infinite\" attack generator, it generates random sleeps between each function call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def randomized_speed_attack_decorator(function):\n",
    "    \"\"\"Randomizes the speed of attacks\"\"\"\n",
    "    \n",
    "    import time\n",
    "    import random\n",
    "    \n",
    "    def wrapper_func(*args, **kwargs):\n",
    "        sleep_time = random.randint(0,3)\n",
    "        print(f\"Attacking after {sleep_time} seconds\")\n",
    "        time.sleep(sleep_time)\n",
    "        return function(*args, **kwargs)\n",
    "    return wrapper_func\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "@randomized_speed_attack_decorator\n",
    "def lazy_return_random_attacks():\n",
    "    \"\"\"Yield attacks each time\"\"\"\n",
    "    import random\n",
    "    attacks = {\"kimura\": \"upper_body\",\n",
    "           \"straight_ankle_lock\":\"lower_body\", \n",
    "           \"arm_triangle\":\"upper_body\",\n",
    "            \"keylock\": \"upper_body\",\n",
    "            \"knee_bar\": \"lower_body\"}\n",
    "    while True:\n",
    "        random_attack = random.choices(list(attacks.keys()))\n",
    "        yield random_attack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attacking after 3 seconds\n",
      "['keylock']\n",
      "Attacking after 2 seconds\n",
      "['kimura']\n",
      "Attacking after 3 seconds\n",
      "['straight_ankle_lock']\n",
      "Attacking after 0 seconds\n",
      "['straight_ankle_lock']\n",
      "Attacking after 1 seconds\n",
      "['knee_bar']\n",
      "Attacking after 2 seconds\n",
      "['knee_bar']\n",
      "Attacking after 1 seconds\n",
      "['keylock']\n",
      "Attacking after 1 seconds\n",
      "['arm_triangle']\n",
      "Attacking after 2 seconds\n",
      "['straight_ankle_lock']\n",
      "Attacking after 2 seconds\n",
      "['kimura']\n"
     ]
    }
   ],
   "source": [
    "for _ in range(10):\n",
    "    print(next(lazy_return_random_attacks()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##### Applying a Function to a Pandas DataFrame\n",
    "The final lesson on functions is to take this knowledge and use it on a DataFrame in Pandas. One of the more fundamental concepts in Pandas is use apply on a column vs iterating through all of the values.  An example is shown below where all of the numbers are rounded to a whole digit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "      <th>species</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal_length  sepal_width  petal_length  petal_width species\n",
       "0           5.1          3.5           1.4          0.2  setosa\n",
       "1           4.9          3.0           1.4          0.2  setosa\n",
       "2           4.7          3.2           1.3          0.2  setosa\n",
       "3           4.6          3.1           1.5          0.2  setosa\n",
       "4           5.0          3.6           1.4          0.2  setosa"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "iris = pd.read_csv('https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv')\n",
    "iris.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "      <th>species</th>\n",
       "      <th>rounded_sepal_length</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal_length  sepal_width  petal_length  petal_width species  \\\n",
       "0           5.1          3.5           1.4          0.2  setosa   \n",
       "1           4.9          3.0           1.4          0.2  setosa   \n",
       "2           4.7          3.2           1.3          0.2  setosa   \n",
       "3           4.6          3.1           1.5          0.2  setosa   \n",
       "4           5.0          3.6           1.4          0.2  setosa   \n",
       "\n",
       "   rounded_sepal_length  \n",
       "0                   5.0  \n",
       "1                   5.0  \n",
       "2                   5.0  \n",
       "3                   5.0  \n",
       "4                   5.0  "
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris['rounded_sepal_length'] = iris[['sepal_length']].apply(pd.Series.round)\n",
    "iris.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This was done with a built in function, but a custom function can also be written and applied to a column.  In the example below, the values are multiplied by 100.  The alternative way to accomplish this would be to create a loop, transform the data and then write it back.  In Pandas, it is straightforward and simple to apply custom functions instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "      <th>species</th>\n",
       "      <th>rounded_sepal_length</th>\n",
       "      <th>100x_sepal_length</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "      <td>5.0</td>\n",
       "      <td>510.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "      <td>5.0</td>\n",
       "      <td>490.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "      <td>5.0</td>\n",
       "      <td>470.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "      <td>5.0</td>\n",
       "      <td>460.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "      <td>5.0</td>\n",
       "      <td>500.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal_length  sepal_width  petal_length  petal_width species  \\\n",
       "0           5.1          3.5           1.4          0.2  setosa   \n",
       "1           4.9          3.0           1.4          0.2  setosa   \n",
       "2           4.7          3.2           1.3          0.2  setosa   \n",
       "3           4.6          3.1           1.5          0.2  setosa   \n",
       "4           5.0          3.6           1.4          0.2  setosa   \n",
       "\n",
       "   rounded_sepal_length  100x_sepal_length  \n",
       "0                   5.0              510.0  \n",
       "1                   5.0              490.0  \n",
       "2                   5.0              470.0  \n",
       "3                   5.0              460.0  \n",
       "4                   5.0              500.0  "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def multiply_by_100(x):\n",
    "    \"\"\"Multiplies by 100\"\"\"\n",
    "    return x*100\n",
    "iris['100x_sepal_length'] = iris[['sepal_length']].apply(multiply_by_100)\n",
    "iris.head()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}