07-args and kwargs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `*args` and `**kwargs`\n",
    "\n",
    "Work with Python long enough, and eventually you will encounter `*args` and `**kwargs`. These strange terms show up as parameters in function definitions. What do they do? Let's review a simple function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def myfunc(a,b):\n",
    "    return sum((a,b))*.05\n",
    "\n",
    "myfunc(40,60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function returns 5% of the sum of **a** and **b**. In this example, **a** and **b** are *positional* arguments; that is, 40 is assigned to **a** because it is the first argument, and 60 to **b**. Notice also that to work with multiple positional arguments in the `sum()` function we had to pass them in as a tuple.\n",
    "\n",
    "What if we want to work with more than two numbers? One way would be to assign a *lot* of parameters, and give each one a default value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def myfunc(a=0,b=0,c=0,d=0,e=0):\n",
    "    return sum((a,b,c,d,e))*.05\n",
    "\n",
    "myfunc(40,60,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously this is not a very efficient solution, and that's where `*args` comes in.\n",
    "\n",
    "## `*args`\n",
    "\n",
    "When a function parameter starts with an asterisk, it allows for an *arbitrary number* of arguments, and the function takes them in as a tuple of values. Rewriting the above function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def myfunc(*args):\n",
    "    return sum(args)*.05\n",
    "\n",
    "myfunc(40,60,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how passing the keyword \"args\" into the `sum()` function did the same thing as a tuple of arguments.\n",
    "\n",
    "It is worth noting that the word \"args\" is itself arbitrary - any word will do so long as it's preceded by an asterisk. To demonstrate this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def myfunc(*spam):\n",
    "    return sum(spam)*.05\n",
    "\n",
    "myfunc(40,60,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `**kwargs`\n",
    "\n",
    "Similarly, Python offers a way to handle arbitrary numbers of *keyworded* arguments. Instead of creating a tuple of values, `**kwargs` builds a dictionary of key/value pairs. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My favorite fruit is pineapple\n"
     ]
    }
   ],
   "source": [
    "def myfunc(**kwargs):\n",
    "    if 'fruit' in kwargs:\n",
    "        print(f\"My favorite fruit is {kwargs['fruit']}\")  # review String Formatting and f-strings if this syntax is unfamiliar\n",
    "    else:\n",
    "        print(\"I don't like fruit\")\n",
    "        \n",
    "myfunc(fruit='pineapple')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I don't like fruit\n"
     ]
    }
   ],
   "source": [
    "myfunc()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `*args` and `**kwargs` combined\n",
    "\n",
    "You can pass `*args` and `**kwargs` into the same function, but `*args` have to appear before `**kwargs`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I like eggs and spam and my favorite fruit is cherries\n",
      "May I have some orange juice?\n"
     ]
    }
   ],
   "source": [
    "def myfunc(*args, **kwargs):\n",
    "    if 'fruit' and 'juice' in kwargs:\n",
    "        print(f\"I like {' and '.join(args)} and my favorite fruit is {kwargs['fruit']}\")\n",
    "        print(f\"May I have some {kwargs['juice']} juice?\")\n",
    "    else:\n",
    "        pass\n",
    "        \n",
    "myfunc('eggs','spam',fruit='cherries',juice='orange')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Placing keyworded arguments ahead of positional arguments raises an exception:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (<ipython-input-8-fc6ff65addcc>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-8-fc6ff65addcc>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    myfunc(fruit='cherries',juice='orange','eggs','spam')\u001b[0m\n\u001b[1;37m                                          ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "myfunc(fruit='cherries',juice='orange','eggs','spam')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with \"args\", you can use any name you'd like for keyworded arguments - \"kwargs\" is just a popular convention.\n",
    "\n",
    "That's it! Now you should understand how `*args` and `**kwargs` provide the flexibilty to work with arbitrary numbers of arguments!"
   ]
  }
 ],
 "metadata": {
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}