args_kwargs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \\*args and \\**kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook will help you recognize and use starred (\\*) **arguments** and starred (\\*) **keyword arguments**. These are often referred to as \\*args and \\*\\*kwargs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Arguments and keyword arguments are passed to functions, so let's review two types of functions that can take \\*args and \\*\\*kwargs:\n",
    "- **Built-in functions** that load with Python\n",
    "- **User-defined functions** that you write yourself or that someone else wrote in a Python script that you have borrowed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example of a user-defined function:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*If you are new to Jupyter notebooks, each gray cell is a piece of code. To run the code, click inside the gray cell and either click the triangle button up top, or press shift+return (or shift+enter) on your keyboard. If you are using Google Colab, shift+return should also work.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_two(a, b): \n",
    "    c=a+b\n",
    "    return c\n",
    "add_two(9, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>Some functions take only a definite number of arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(-16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `abs()` function returns the absolute value of a number. What happens if we pass it multiple arguments?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(-16, -4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>In the Python documentation, `abs()` looks like this:\n",
    "#### <br><center>abs(x)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`x` is the only argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>Other functions can take either one OR multiple arguments of the same type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at the `print()` function. I usually only use it to print one object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"something\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the Python documentation, `print()` looks like this:\n",
    "#### <br><center>print(*objects, sep=' ', end='\\n', file=sys.stdout, flush=False)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function has one **argument**: `objects` and four **keyword arguments**: `sep`, `end`, `file`, and `flush`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keyword arguments have **default values** - the values that follow the `=` in the function documentation. You do not need to pass these arguments when you call the function if you want to use the default values, but you can also change them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When calling any function, arguments go before keyword arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"something\", end=\"!\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>The one argument in the function documentation is preceded by a star `*`. \n",
    "<br><br>This means that you can actually pass the function multiple arguments, **separated by commas**, and the function will act on all of them in the same way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello\", \"World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello\", \"World\", \"How are you?\", sep=\", \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>You can also pass variables as arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Bugs Bunny\"\n",
    "print(\"Happy\", \"Birthday\", name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Bugs Bunny\"\n",
    "print(\"Happy\", \"Birthday\", name, sep=\" (!) \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br>\\*args"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>Here we have a function that takes a student's name and three homework grades they received. It prints the student's name and average grade."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_grade(student, grade1, grade2, grade3):\n",
    "    final = (grade1 + grade2 + grade3)/3\n",
    "    print(student + \"\\'s final grade is \" + str(final))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade(\"Colby\", 80, 85, 87)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br><br>What if the third homework assignment was optional, and I didn't complete it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade(\"Colby\", 80, 85)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br><br>We can use \\*args to make the function more flexible. Now it can take any number of grades and will find the average."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_grade(student, *args):\n",
    "    final = sum(args)/len(args)\n",
    "    print(student + \"\\'s final grade is \" + str(final))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade(\"Colby\", 80, 85)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade(\"Dan\", 95, 96, 94)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Any other arguments must come before \\*args. Let's try switching the arguments in the function definition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_grade(*args, student):\n",
    "    final = sum(args)/len(args)\n",
    "    print(student + \"\\'s final grade is \" + str(final))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade(80, 85, \"Colby\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We don't have to call our \\*args `*args`. We can name it something more useful, as long as we keep the `*` in front. Modify the function below to change `args` to `grades`. Make sure you change it everywhere in the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_grade2(student, *args):\n",
    "    final = sum(args)/len(args)\n",
    "    print(student + \"\\'s final grade is \" + str(final))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade2(\"Colby\", 80, 85)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br>Packing and unpacking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>Let's see what is happening behind the scenes when we use \\*args:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_grades(student, *grades):\n",
    "    print(grades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_grades(\"Colby\", 80, 85)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Python is taking all of the \\*args and changing them to a tuple. Tuples are like lists, they can hold items in an order, separated by commas. They are surrounded by parantheses instead of square brackets. Like lists, tuples can be iterated (looped) through."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is called **packing**. It packs the arguments into a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Using \\*args with a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might find a function that you want to use that takes \\*args, but your code has already packaged your data into a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_grade(student, *args):\n",
    "    final = sum(args)/len(args)\n",
    "    print(student + \"\\'s final grade is \" + str(final))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Colby_grades = [80, 85]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade(\"Colby\", Colby_grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>To use the list, you can **unpack** the list when you give it as an argument in your function call. You just put an \\* in front of the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade(\"Colby\", *Colby_grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You ran an experiment and got these results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "run_0431_results = [0.14, 0.02, 0.31, 0.04, 0.12, 0.14]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You found a useful function online that will summarize your results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def summarize_results(sample_name, *results):\n",
    "    max_result = max(results)\n",
    "    min_result = min(results)\n",
    "    average = sum(results)/len(results)\n",
    "    print(\"For sample \" + str(sample_name) + \", \" + \n",
    "          \"the minimum result was \" + str(min_result) + \n",
    "          \" and the maximum result was \" + str(max_result) + \n",
    "          \" and the average result was \" + str(round(average,3)) + \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function call to use the `summarize_results` function with your experimental results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br>\\*\\*kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>\\*args **packs** your arguments into a tuple. \\*\\*kwargs **packs** your keyword arguments into a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_kwargs(**kwargs):\n",
    "    print(kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_kwargs(test1=83, test2=89, test3=79, hw1=89, hw2=84)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>Here's a function that prints the average grade, but it takes the data as a keyword argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_grade3(**kwargs):\n",
    "    for student, grades in kwargs.items():\n",
    "        final = sum(grades)/len(grades)\n",
    "        print(student + \"\\'s final grade is \" + str(final))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade3(Colby=[80, 85, 87])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note that you don't need to put Colby in quotes when passing a keyword argument in your function call.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>We can run the function on multiple keyword arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade3(Colby=[80, 85, 87], Dan=[95, 96, 94])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I scored the following grades this quarter: tests - 89, 87, 82; final exam - 88; participation - 95; homework assignments - 80, 85, 90, 85, 75, 95.\n",
    "<br>This function will print out the average grade in each category you give it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grade_breakdown(student, **grade_categories):\n",
    "    print(student, \"\\'s grade breakdown:\")\n",
    "    for category, grades in grade_categories.items():\n",
    "        if type(grades) == int:\n",
    "            final = grades\n",
    "        else:\n",
    "            final = round(sum(grades)/len(grades), 2)\n",
    "        print(category, \"grade:\", final)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function call to run `grade_breakdown` with my grades in each category."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br><br>Using \\*\\*kwargs with a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <br>Just like how we **unpacked** a list for a function that took \\*args, we can unpack a dictionary for a function that takes \\*\\*kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade_dict = {\"Colby\" : [80, 85, 87], \"Dan\" : [95, 96, 94]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_grade3(**kwargs):\n",
    "    for student, grades in kwargs.items():\n",
    "        final = sum(grades)/len(grades)\n",
    "        print(student + \"\\'s final grade is \" + str(final))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade3(grade_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_grade3(**grade_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <br><br>Combining args, \\*args, kwargs, and \\*\\*kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keyword arguments are nice because they let you set default values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <br>Exercise 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On a piece of paper, answer the questions in this survey for yourself:\n",
    "<br><br>**Lunch Survey**\n",
    "- Name (if you would like to provide it):\n",
    "- Age (if you would like to provide it):\n",
    "- Question 1. What is your most common lunch these days?\n",
    "- Question 2. If you could eat anything for lunch tomorrow, what would you eat?\n",
    "- Question 3. Do you ever eat dessert with lunch?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>The function below will format the results of your survey:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_survey(survey_name, name=\"did not provide\", \n",
    "                 age=\"did not provide\", **survey_answers):\n",
    "    print(\"Participant\", name, sep=\": \")\n",
    "    print(\"Participant age\", age, sep=\": \")\n",
    "    print(\"For the\", survey_name, \"survey:\")\n",
    "    for question, answer in survey_answers.items():\n",
    "        print(question, answer, sep=\": \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, write a function call for `clean_survey` that provides all of your survey answers as arguments. Then, **before you run your function call,** use your paper and pencil to write down exactly what you think the results will be of your function call. Finally, run the function call and see if your were correct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*You will have to decide what to name each question in your function call, since variable names cannot start with numbers or include spaces.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}