reading-journal-7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reading Journal 7\n",
    "\n",
    "Reading: *Think Python*, [Chapters 11.1-4](http://www.greenteapress.com/thinkpython/html/thinkpython012.html), [12.1-5](http://www.greenteapress.com/thinkpython2/html/thinkpython2013.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 11](http://www.greenteapress.com/thinkpython/html/thinkpython012.html)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick check:** In about one sentence using your own words, what is a dictionary?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 11.4"
   },
   "source": [
    "### Exercise 11.4  \n",
    "\n",
    "Modify `reverse_lookup` so that it builds and returns a list of all keys that map to `v`, or an empty list if there are none. Add unit tests for your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution": "Exercise 11.4"
   },
   "outputs": [],
   "source": [
    "def reverse_lookup(d, v):\n",
    "    for k in d:\n",
    "        if d[k] == v:\n",
    "            return k\n",
    "    raise ValueError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you'd like to learn more about errors and exceptions, you can check out the [Python tutorial](https://docs.python.org/3/tutorial/errors.html) or read ahead to [Appendix A](http://www.greenteapress.com/thinkpython2/html/thinkpython2021.html) of Think Python. If you choose to use doctest for your unit testing, it can also [deal with exceptions](https://docs.python.org/3/library/doctest.html#what-about-exceptions)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick check** What type of objects can be used as keys to a dictionary, i.e. what property must they have?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Chapter 12](http://www.greenteapress.com/thinkpython2/html/thinkpython2013.html)\n",
    "\n",
    "**Quick check:** In about one sentence using your own words, what is a tuple?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 12.1"
   },
   "source": [
    "### Chapter 12.4  \n",
    "\n",
    "Many of the built-in functions use variable-length argument tuples. For example, `max` and `min` can take any number of arguments:\n",
    "\n",
    "```\n",
    ">>> max(1,2,3)\n",
    "3\n",
    "```\n",
    "\n",
    "But `sum` does not.\n",
    "\n",
    "```\n",
    ">>> sum(1, 2, 3)\n",
    "TypeError: sum expected at most 2 arguments, got 3\n",
    "```\n",
    "\n",
    "Write a function called ```sumall``` that takes any number of arguments and returns their sum. \n",
    "\n",
    "Write unit tests for your function. Do I actually need to keep saying this? Let's assume it's always a good idea :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution": "Exercise 12.1"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you're interested in more flexible ways to pass arguments to functions, check out the [Python tutorial](https://docs.python.org/3/tutorial/controlflow.html#more-on-defining-functions). For instance, you can also use keyword arguments, which are collected into a dictionary just like `*` gathers variable numbers of positional arguments into a tuple.\n",
    "\n",
    "This pattern is very common for defining functions with complex optional behaviors in Python, and you will often see definitions like:\n",
    "\n",
    "```python\n",
    "def my_func(required_argument1, *arguments, **keywords):\n",
    "    ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 12 sort"
   },
   "source": [
    "### Exercise\n",
    "\n",
    "Write a function `sort_by_last_letter` that takes a list of words and returns a new list with the words sorted alphabetically by the _last letter_ in the word. Hint: use the **Decorate, Sort, Undecorate** pattern. Write unit tests for your function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution": "Exercise 12 sort"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quick check** Give an example of when you might use each sequence type:\n",
    "\n",
    "- tuple\n",
    "\n",
    "- list\n",
    "\n",
    "- string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Exercise 12.3"
   },
   "source": [
    "### Exercise 12.1 \n",
    "\n",
    "Write a function called `most_frequent` that takes a string and prints the letters in decreasing order of frequency. Find text samples from several different languages and see how letter frequency varies between languages. Compare your results with the tables at http://en.wikipedia.org/wiki/Letter_frequencies. \n",
    "\n",
    "Allen's solution (try it on your own first): http://greenteapress.com/thinkpython2/code/most_frequent.py. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "solution": "Exercise 12.3"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `is_palindrome`\n",
    "\n",
    "\\[This is the problem from in class on Thursday. In class we named the function `palindrome`.\\]\n",
    "\n",
    "Modify the recursive implementation of `is_palindrome` below such that the doctests pass.\n",
    "\n",
    "You may use either of the strategies we discussed in class (or a third if you can think of others):\n",
    "* “clean” the string (remove spaces and normalize case) before settling down to comparison; or\n",
    "* add cases to the list of `if`s\n",
    "\n",
    "The [code from class](/notes/palindromes) includes a solution. Try it on your own first. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import doctest\n",
    "\n",
    "def is_palindrome(s):\n",
    "    \"\"\"Return true if s is a palindrome.\n",
    "    \n",
    "    A palindrome is a string that is the same reversed, ignoring punctuation and capitalization.\n",
    "    \n",
    "    >>> is_palindrome('divide')\n",
    "    False\n",
    "    >>> is_palindrome('redivider')\n",
    "    True\n",
    "    >>> is_palindrome('Bob')\n",
    "    True\n",
    "    >>> is_palindrome('Re-divider')\n",
    "    True\n",
    "    \"\"\"\n",
    "    if len(s) <= 1:\n",
    "        return True\n",
    "    if s[0] != s[-1]:\n",
    "        return False\n",
    "    return is_palindrome(s[1:-1])\n",
    "\n",
    "doctest.run_docstring_examples(is_palindrome, globals())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ## Three Questions Why\n",
    "\n",
    "Read [Three Questions About Each Bug You Find](http://www.multicians.org/thvv/threeq.html)\n",
    "\n",
    "Describe an area of difficulty involving software development. This can a bug in code you write, difficulty with the tools involved in software development, or difficulty setting up your environment.\n",
    "\n",
    "Apply the \"three questions\" to the area you've chosen. Use the space below.\n",
    "\n",
    "1. Is this mistake somewhere else also?\n",
    "2. What next bug is hidden behind this one?\n",
    "3. What should I do to prevent bugs like this?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "is_question": true,
    "problem": "Feedback"
   },
   "source": [
    "## Reading Journal feedback\n",
    "\n",
    "Leave comments on this Reading Journal in the space below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "feedback_response": true,
    "solution": "Feedback"
   },
   "source": [
    " "
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Visualize",
  "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
}