py4e_ch9-10_dictionaries_tuples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ch 9: Dictionaries\n",
    "\n",
    "The index in a list is an integer, additionally, all indexes are consecutively occopied and order matters. That is great for some data. But other data make more sense to index by something else.\n",
    "\n",
    "Dictionaries provide a key-value pair where the index, or key, can be a variety of types and is associated with a value. There is no inherent order to a dictionary.\n",
    "\n",
    "The text shows the `dict()` function to create an empty dictionary, you can also just use {} or start by assigning a key-value pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eng2sp = dict()\n",
    "type(eng2sp)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test={}\n",
    "type(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test2={'one':'uno'}\n",
    "type(test2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'one': 'uno', 'two': 'dos', 'three': 'tres'}\n"
     ]
    }
   ],
   "source": [
    "eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
    "print(eng2sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:** On p. 108, the text states there isn't a set order. This has changed recently. As of Python 3.7, dictionary order is the insertion order of the key-value pairs.\n",
    "\n",
    "That shouldn't matter too much, but sometimes helps. But for the most part, you will access items with their index, as in lists, **but the index is the key**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dos\n"
     ]
    }
   ],
   "source": [
    "print(eng2sp['two'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `words.txt` file is in `/ufrc/bsc4452/share/Class_Files/Py4E_files/code3`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.1 Dictionary as a set of counters\n",
    "\n",
    "Cool stuff here...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "{'b': 1, 'r': 2, 'o': 2, 'n': 1, 't': 1, 's': 2, 'a': 1, 'u': 2}\n"
    }
   ],
   "source": [
    "word = 'brontosaurus' \n",
    "d = {} # Seems easier to me than dict()\n",
    "for c in word:\n",
    "    if c not in d: \n",
    "        d[c] = 1\n",
    "    else:\n",
    "        d[c] = d[c] + 1\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the insertion order being retained!\n",
    "\n",
    "### `get`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "100\nTim isn't here\n"
    }
   ],
   "source": [
    "counts = { 'chuck' : 1 , 'annie' : 42, 'jan': 100}\n",
    "print(counts.get('jan', 0))\n",
    "\n",
    "print(counts.get('tim', \"Tim isn't here\"))  # get takes a key and default value\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'b': 1, 'r': 2, 'o': 2, 'n': 1, 't': 1, 's': 2, 'a': 1, 'u': 2}\n"
     ]
    }
   ],
   "source": [
    "word = 'brontosaurus' \n",
    "d = dict()\n",
    "for c in word:\n",
    "    d[c] = d.get(c,0) + 1\n",
    "print(d)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.3 Looping and dictionaries (p. 111)\n",
    "\n",
    "Here's the example in the text:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chuck 1\n",
      "annie 42\n",
      "jan 100\n"
     ]
    }
   ],
   "source": [
    "counts = { 'chuck' : 1 , 'annie' : 42, 'jan': 100} \n",
    "for key in counts:\n",
    "    print(key, counts[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But what if we wanted the output to be sorted alphabetically?\n",
    "\n",
    "The text makes a list of the keys, sorts that, and loops over the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['chuck', 'annie', 'jan']\n",
      "annie 42\n",
      "chuck 1\n",
      "jan 100\n"
     ]
    }
   ],
   "source": [
    "lst = list(counts.keys())\n",
    "print(lst)\n",
    "lst.sort()\n",
    "for key in lst:\n",
    "    print(key, counts[key])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But Python has a `sorted()` function that makes this easier..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "annie 42\n",
      "chuck 1\n",
      "jan 100\n"
     ]
    }
   ],
   "source": [
    "for key in sorted(counts):\n",
    "    print(key, counts[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also sort by values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "matt 0\n",
      "chuck 1\n",
      "annie 42\n",
      "jan 100\n"
     ]
    }
   ],
   "source": [
    "counts['matt']=0\n",
    "for key in sorted(counts, key=counts.__getitem__):\n",
    "    print(key, counts[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 9.4 Advanced text parsing (p. 113)\n",
    "\n",
    "Take a look at this.\n",
    "\n",
    "Note the string.punctuation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import string\n",
    "string.punctuation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check out `count2.py`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ch 10: Tuples\n",
    "\n",
    "I don't use these a lot, but there are some good things in this chapter.\n",
    "\n",
    "One is the idea of tuple assigment...\n",
    "\n",
    "## Section 10.3 Tuple assignment\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "have\n",
      "fun\n"
     ]
    }
   ],
   "source": [
    "m=['have', 'fun']\n",
    "x,y=m\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is frequently used with functions that return multiple values!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "4 8 16\n"
    }
   ],
   "source": [
    "def powers(x):\n",
    "    square=x**2\n",
    "    cube=x**3\n",
    "    quad=x**4\n",
    "    return square,cube,quad\n",
    "\n",
    "x,y,z=powers(2)\n",
    "print(x,y,z)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As noted at the start of the chapter, you don't need to have the parentheses around the x,y,z to create tuple--stylistically, the \"pythonic\" way is to not use them in this case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "error",
     "ename": "ValueError",
     "evalue": "not enough values to unpack (expected 4, got 3)",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-31ecd1a5cfd5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Be careful with number of variables on the left\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mz\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mpowers\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: not enough values to unpack (expected 4, got 3)"
     ]
    }
   ],
   "source": [
    "# Be careful with number of variables on the left\n",
    "(x,y,z,a)=powers(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sections 10.4 & 10.5: Dictionaries and tuples\n",
    "\n",
    "This goes into the `items` method of dictionaries that returns a list of tuples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('a', 10), ('b', 1), ('c', 22)]\n",
      "('a', 10)\n",
      "\n",
      "-------------------\n",
      "\n",
      "dict_items([('a', 10), ('b', 1), ('c', 22)])\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'dict_items' object does not support indexing",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-409b650e9f18>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'dict_items' object does not support indexing"
     ]
    }
   ],
   "source": [
    "d = {'a':10, 'b':1, 'c':22}\n",
    "t=list(d.items())\n",
    "print(t)\n",
    "print(t[0])\n",
    "\n",
    "print('\\n-------------------\\n')\n",
    "# Note the list() above and what happens without it\n",
    "t=d.items()\n",
    "print(t)\n",
    "\n",
    "print(t[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10.5 Multiple assignment with dictionaries (p. 122)\n",
    "\n",
    "This section shows the reasoning behing a common Python construct...Combining `items` with tuple multiple assignment and a `for` loop (interestingly, we don't need, but can use, the `list()` here):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 a\n",
      "1 b\n",
      "22 c\n"
     ]
    }
   ],
   "source": [
    "for key, val in d.items():\n",
    "    print(val,key)"
   ]
  }
 ],
 "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.8.2-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}