Notebook1_part2-more_exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-3b25f2b6cfc80b65",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "# Python review: More exercises\n",
    "\n",
    "This notebook continues the review of Python basics based on [Chris Simpkins's](https://www.cc.gatech.edu/~simpkins/) [Python Bootcamp](https://www.cc.gatech.edu/~simpkins/teaching/python-bootcamp/syllabus.html).\n",
    "\n",
    "This particular notebook adapts the exercises that appeared with the [\"Functional Programming\" slides](https://www.cc.gatech.edu/~simpkins/teaching/python-bootcamp/slides/functional-programming.html) of the Fall 2016 offering."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-f3331b5182117a1f",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Consider the following dataset of exam grades, organized as a 2-D table and stored in Python as a \"list of lists\" under the variable name, `grades`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-9dc72b683a8858c7",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "grades = [\n",
    "    # First line is descriptive header. Subsequent lines hold data\n",
    "    ['Student', 'Exam 1', 'Exam 2', 'Exam 3'],\n",
    "    ['Thorny', '100', '90', '80'],\n",
    "    ['Mac', '88', '99', '111'],\n",
    "    ['Farva', '45', '56', '67'],\n",
    "    ['Rabbit', '59', '61', '67'],\n",
    "    ['Ursula', '73', '79', '83'],\n",
    "    ['Foster', '89', '97', '101']\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-04082681e80572d5",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "**Exercise 0** (`students_test`: 1 point). Write some code that computes a new list named `students[:]`, which holds the names of the students as they from \"top to bottom\" in the table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "students",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Thorny', 'Mac', 'Farva', 'Rabbit', 'Ursula', 'Foster']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#\n",
    "# YOUR CODE HERE\n",
    "#\n",
    "students = [x[0] for x in grades if x[0] != 'Student']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "students_test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Thorny', 'Mac', 'Farva', 'Rabbit', 'Ursula', 'Foster']\n",
      "\n",
      "(Passed!)\n"
     ]
    }
   ],
   "source": [
    "# `students_test`: Test cell\n",
    "print(students)\n",
    "assert type(students) is list\n",
    "assert students == ['Thorny', 'Mac', 'Farva', 'Rabbit', 'Ursula', 'Foster']\n",
    "print(\"\\n(Passed!)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-e5e0181d53efed56",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "**Exercise 1** (`assignments_test`: 1 point). Write some code to compute a new list named `assignments[:]`, to hold the names of the class assignments. (These appear in the descriptive header element of `grades`.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "assignments",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Exam 1', 'Exam 2', 'Exam 3']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#\n",
    "# YOUR CODE HERE\n",
    "#\n",
    "assignments = [x for x in grades[0] if x != 'Student']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "assignments_test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Exam 1', 'Exam 2', 'Exam 3']\n",
      "\n",
      "(Passed!)\n"
     ]
    }
   ],
   "source": [
    "# `assignments_test`: Test cell\n",
    "print(assignments)\n",
    "assert type(assignments) is list\n",
    "assert assignments == ['Exam 1', 'Exam 2', 'Exam 3']\n",
    "print(\"\\n(Passed!)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-1bd41417aad245fa",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "**Exercise 2** (`grade_lists_test`: 1 point). Write some code to compute a new _dictionary_, named `grade_lists`, that maps names of students to _lists_ of their exam grades. The grades should be converted from strings to integers. For instance, `grade_lists['Thorny'] == [100, 90, 80]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "grade_lists",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Create a dict mapping names to lists of grades.\n",
    "#\n",
    "# YOUR CODE HERE\n",
    "#\n",
    "grade_lists = {x[0]: [int(x[1]), int(x[2]), int(x[3])] for x in grades if x[0] != 'Student'}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "grade_lists_test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Foster': [89, 97, 101], 'Ursula': [73, 79, 83], 'Mac': [88, 99, 111], 'Farva': [45, 56, 67], 'Rabbit': [59, 61, 67], 'Thorny': [100, 90, 80]}\n",
      "\n",
      "(Passed!)\n"
     ]
    }
   ],
   "source": [
    "# `grade_lists_test`: Test cell\n",
    "print(grade_lists)\n",
    "assert type(grade_lists) is dict, \"Did not create a dictionary.\"\n",
    "assert len(grade_lists) == len(grades)-1, \"Dictionary has the wrong number of entries.\"\n",
    "assert {'Thorny', 'Mac', 'Farva', 'Rabbit', 'Ursula', 'Foster'} == set(grade_lists.keys()), \"Dictionary has the wrong keys.\"\n",
    "assert grade_lists['Thorny'] == [100, 90, 80], 'Wrong grades for: Thorny'\n",
    "assert grade_lists['Mac'] == [88, 99, 111], 'Wrong grades for: Mac'\n",
    "assert grade_lists['Farva'] == [45, 56, 67], 'Wrong grades for: Farva'\n",
    "assert grade_lists['Rabbit'] == [59, 61, 67], 'Wrong grades for: Rabbit'\n",
    "assert grade_lists['Ursula'] == [73, 79, 83], 'Wrong grades for: Ursula'\n",
    "assert grade_lists['Foster'] == [89, 97, 101], 'Wrong grades for: Foster'\n",
    "print(\"\\n(Passed!)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-a628c6c0f63e7e7c",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "**Exercise 3** (`grade_dicts_test`: 2 points). Write some code to compute a new dictionary, `grade_dicts`, that maps names of students to _dictionaries_ containing their scores. Each entry of this scores dictionary should be keyed on assignment name and hold the corresponding grade as an integer. For instance, `grade_dicts['Thorny']['Exam 1'] == 100`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "grade_dicts",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Create a dict mapping names to dictionaries of grades.\n",
    "#\n",
    "# YOUR CODE HERE\n",
    "#\n",
    "grade_dicts = {}\n",
    "for key, value in grade_lists.items():\n",
    "    grade_dicts[key] = {x:y for x,y in zip(assignments, value)}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "grade_dicts_test",
     "locked": true,
     "points": 2,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Ursula': {'Exam 2': 79, 'Exam 3': 83, 'Exam 1': 73}, 'Thorny': {'Exam 2': 90, 'Exam 3': 80, 'Exam 1': 100}, 'Mac': {'Exam 2': 99, 'Exam 3': 111, 'Exam 1': 88}, 'Farva': {'Exam 2': 56, 'Exam 3': 67, 'Exam 1': 45}, 'Rabbit': {'Exam 2': 61, 'Exam 3': 67, 'Exam 1': 59}, 'Foster': {'Exam 2': 97, 'Exam 3': 101, 'Exam 1': 89}}\n",
      "\n",
      "(Passed!)\n"
     ]
    }
   ],
   "source": [
    "# `grade_dicts_test`: Test cell\n",
    "print(grade_dicts)\n",
    "assert type(grade_dicts) is dict, \"Did not create a dictionary.\"\n",
    "assert len(grade_dicts) == len(grades)-1, \"Dictionary has the wrong number of entries.\"\n",
    "assert {'Thorny', 'Mac', 'Farva', 'Rabbit', 'Ursula', 'Foster'} == set(grade_dicts.keys()), \"Dictionary has the wrong keys.\"\n",
    "assert grade_dicts['Foster']['Exam 1'] == 89, 'Wrong score'\n",
    "assert grade_dicts['Foster']['Exam 3'] == 101, 'Wrong score'\n",
    "assert grade_dicts['Foster']['Exam 2'] == 97, 'Wrong score'\n",
    "assert grade_dicts['Ursula']['Exam 1'] == 73, 'Wrong score'\n",
    "assert grade_dicts['Ursula']['Exam 3'] == 83, 'Wrong score'\n",
    "assert grade_dicts['Ursula']['Exam 2'] == 79, 'Wrong score'\n",
    "assert grade_dicts['Rabbit']['Exam 1'] == 59, 'Wrong score'\n",
    "assert grade_dicts['Rabbit']['Exam 3'] == 67, 'Wrong score'\n",
    "assert grade_dicts['Rabbit']['Exam 2'] == 61, 'Wrong score'\n",
    "assert grade_dicts['Mac']['Exam 1'] == 88, 'Wrong score'\n",
    "assert grade_dicts['Mac']['Exam 3'] == 111, 'Wrong score'\n",
    "assert grade_dicts['Mac']['Exam 2'] == 99, 'Wrong score'\n",
    "assert grade_dicts['Farva']['Exam 1'] == 45, 'Wrong score'\n",
    "assert grade_dicts['Farva']['Exam 3'] == 67, 'Wrong score'\n",
    "assert grade_dicts['Farva']['Exam 2'] == 56, 'Wrong score'\n",
    "assert grade_dicts['Thorny']['Exam 1'] == 100, 'Wrong score'\n",
    "assert grade_dicts['Thorny']['Exam 3'] == 80, 'Wrong score'\n",
    "assert grade_dicts['Thorny']['Exam 2'] == 90, 'Wrong score'\n",
    "print(\"\\n(Passed!)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-840a57a4b61944e5",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "**Exercise 4** (`avg_grades_by_student_test`: 1 point). Write some code to compute a dictionary named `avg_grades_by_student` that maps each student to his or her average exam score. For instance, `avg_grades_by_student['Thorny'] == 90`.\n",
    "\n",
    "> **Hint.** The [`statistics`](https://docs.python.org/3.5/library/statistics.html) module of Python has at least one helpful function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "avg_grades_by_student",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Create a dict mapping names to grade averages.\n",
    "#\n",
    "# YOUR CODE HERE\n",
    "#\n",
    "avg_grades_by_student = {name: sum(score)/3 for name, score in grade_lists.items()}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "avg_grades_by_student_test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Ursula': 78.33333333333333, 'Thorny': 90.0, 'Mac': 99.33333333333333, 'Farva': 56.0, 'Rabbit': 62.333333333333336, 'Foster': 95.66666666666667}\n",
      "\n",
      "(Passed!)\n"
     ]
    }
   ],
   "source": [
    "# `avg_grades_by_student_test`: Test cell\n",
    "print(avg_grades_by_student)\n",
    "assert type(avg_grades_by_student) is dict, \"Did not create a dictionary.\"\n",
    "assert len(avg_grades_by_student) == len(students), \"Output has the wrong number of students.\"\n",
    "assert abs(avg_grades_by_student['Mac'] - 99.33333333333333) <= 4e-15, 'Mean is incorrect'\n",
    "assert abs(avg_grades_by_student['Foster'] - 95.66666666666667) <= 4e-15, 'Mean is incorrect'\n",
    "assert abs(avg_grades_by_student['Farva'] - 56) <= 4e-15, 'Mean is incorrect'\n",
    "assert abs(avg_grades_by_student['Rabbit'] - 62.333333333333336) <= 4e-15, 'Mean is incorrect'\n",
    "assert abs(avg_grades_by_student['Thorny'] - 90) <= 4e-15, 'Mean is incorrect'\n",
    "assert abs(avg_grades_by_student['Ursula'] - 78.33333333333333) <= 4e-15, 'Mean is incorrect'\n",
    "print(\"\\n(Passed!)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-3f31ab810dcb86d1",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "**Exercise 5** (`grades_by_assignment_test`: 2 points). Write some code to compute a dictionary named `grades_by_assignment`, whose keys are assignment (exam) names and whose values are lists of scores over all students on that assignment. For instance, `grades_by_assignment['Exam 1'] == [100, 88, 45, 59, 73, 89]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "grades_by_assignment",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "#\n",
    "# YOUR CODE HERE\n",
    "#\n",
    "grades_by_assignment = {}\n",
    "\n",
    "for i in range(1, len(assignments) + 1):\n",
    "    grades_by_assignment['Exam {}'.format(i)] = [int(x[i]) for x in grades if x[i] != 'Exam {}'.format(i)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "grades_by_assignment_test",
     "locked": true,
     "points": 2,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Exam 2': [90, 99, 56, 61, 79, 97], 'Exam 3': [80, 111, 67, 67, 83, 101], 'Exam 1': [100, 88, 45, 59, 73, 89]}\n",
      "\n",
      "(Passed!)\n"
     ]
    }
   ],
   "source": [
    "# `grades_by_assignment_test`: Test cell\n",
    "print(grades_by_assignment)\n",
    "assert type(grades_by_assignment) is dict, \"Output is not a dictionary.\"\n",
    "assert len(grades_by_assignment) == 3, \"Wrong number of assignments.\"\n",
    "assert grades_by_assignment['Exam 1'] == [100, 88, 45, 59, 73, 89], 'Wrong grades list'\n",
    "assert grades_by_assignment['Exam 3'] == [80, 111, 67, 67, 83, 101], 'Wrong grades list'\n",
    "assert grades_by_assignment['Exam 2'] == [90, 99, 56, 61, 79, 97], 'Wrong grades list'\n",
    "print(\"\\n(Passed!)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-d763d8a25d8cac78",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "**Exercise 6** (`avg_grades_by_assignment_test`: 1 point). Write some code to compute a dictionary, `avg_grades_by_assignment`, which maps each exam to its average score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "avg_grades_by_assignment",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Create a dict mapping items to average for that item across all students.\n",
    "#\n",
    "# YOUR CODE HERE\n",
    "#\n",
    "avg_grades_by_assignment = {exam: sum(scores)/len(scores) for exam, scores in grades_by_assignment.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "avg_grades_by_assignment_test",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Exam 2': 80.33333333333333, 'Exam 3': 84.83333333333333, 'Exam 1': 75.66666666666667}\n",
      "\n",
      "(Passed!)\n"
     ]
    }
   ],
   "source": [
    "# `avg_grades_by_assignment_test`: Test cell\n",
    "print(avg_grades_by_assignment)\n",
    "assert type(avg_grades_by_assignment) is dict\n",
    "assert len(avg_grades_by_assignment) == 3\n",
    "assert abs((100+88+45+59+73+89)/6 - avg_grades_by_assignment['Exam 1']) <= 7e-15\n",
    "assert abs((80+111+67+67+83+101)/6 - avg_grades_by_assignment['Exam 3']) <= 7e-15\n",
    "assert abs((90+99+56+61+79+97)/6 - avg_grades_by_assignment['Exam 2']) <= 7e-15\n",
    "print(\"\\n(Passed!)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-7d85977d9fab2482",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "**Exercise 7** (`rank_test`: 2 points). Write some code to create a new list, `rank`, which contains the names of students in order by _decreasing_ score. That is, `rank[0]` should contain the name of the top student (highest average exam score), and `rank[-1]` should have the name of the bottom student (lowest average exam score)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "rank",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "#\n",
    "# YOUR CODE HERE\n",
    "#\n",
    "rank_scores = sorted([(y,x) for x,y in avg_grades_by_student.items()], reverse=True)\n",
    "rank = [x[1] for x in rank_scores]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "nbgrader": {
     "grade": true,
     "grade_id": "rank_test",
     "locked": true,
     "points": 2,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mac', 'Foster', 'Thorny', 'Ursula', 'Rabbit', 'Farva']\n",
      "\n",
      "=== Ranking ===\n",
      "1. Mac: 99.33333333333333\n",
      "2. Foster: 95.66666666666667\n",
      "3. Thorny: 90.0\n",
      "4. Ursula: 78.33333333333333\n",
      "5. Rabbit: 62.333333333333336\n",
      "6. Farva: 56.0\n",
      "\n",
      "(Passed!)\n"
     ]
    }
   ],
   "source": [
    "# `rank_test`: Test cell\n",
    "print(rank)\n",
    "print(\"\\n=== Ranking ===\")\n",
    "for i, s in enumerate(rank):\n",
    "    print(\"{}. {}: {}\".format(i+1, s, avg_grades_by_student[s]))\n",
    "    \n",
    "assert rank == ['Mac', 'Foster', 'Thorny', 'Ursula', 'Rabbit', 'Farva']\n",
    "for i in range(len(rank)-1):\n",
    "    assert avg_grades_by_student[rank[i]] >= avg_grades_by_student[rank[i+1]]\n",
    "print(\"\\n(Passed!)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Create Assignment",
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}