notebooks/ch12-tuples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 12: Tuples\n",
    "***\n",
    "__Contents__\n",
    "- [Tuples are immutable](#Tuples-are-immutable)\n",
    "- [Tuple assignment](#Tuple-assignment)\n",
    "- [Tuples as return values](#Tuples-as-return-values)\n",
    "- [Variable-length argument tuples](#Variable-length-argument-tuples)\n",
    "- [Lists and tuples](#Lists-and-tuples)\n",
    "- [Dictionaries and tuples](#Dictionaries-and-tuples)\n",
    "- [Comparing tuples](#Comparing-tuples)\n",
    "- [Sequences of sequences](#Sequences-of-sequences)\n",
    "- [Debugging](#Debugging)\n",
    "- [Exercises](#Exercises)\n",
    "***\n",
    "\n",
    "_This notebook is based on \"Think Python, 2Ed\" by Allen B. Downey_ <br>\n",
    "[https://greenteapress.com/wp/think-python-2e/](https://greenteapress.com/wp/think-python-2e/)\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples are immutable\n",
    "- A __tuple__ is a sequence of values\n",
    "- They values can be any type and are index by integers\n",
    "- They are similar to lists, except:\n",
    "    - Tuples are immutable\n",
    "    - Tuples values usually have different types (unlike lists which generally hold only a single type)\n",
    "- There are multiple ways to create a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_tuple = ( 'a', 'b', 'c', 'd', 'e' )\n",
    "a_tuple = 'a', 'b', 'c', 'd', 'e'\n",
    "a_tuple = 'a',\n",
    "\n",
    "type( a_tuple )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- If you want to create a tuple with a single value, add a comma (``,``) after the value, but don’t add parenthesis\n",
    "- You can also use the built in function ``tuple``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "('l', 'u', 'p', 'i', 'n', 's')\n"
     ]
    }
   ],
   "source": [
    "a_tuple = tuple()\n",
    "print( a_tuple )\n",
    "a_tuple = tuple( 'lupins' )\n",
    "print( a_tuple )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Most list operators (e.g., bracket and slice) work on tuples\n",
    "- If you try to modify one of the elements, you get an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('b', 'c')\n",
      "('a', 'b', 'c')\n",
      "('b', 'c', 'd', 'e')\n"
     ]
    }
   ],
   "source": [
    "a_tuple = ( 'a', 'b', 'c', 'd', 'e' )\n",
    "print( a_tuple[1:3] )\n",
    "print( a_tuple[:3] )\n",
    "print( a_tuple[1:] )\n",
    "\n",
    "# Uncomment to see error\n",
    "# a_tuple[0] = 'z'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple assignment\n",
    "- Often, you may want to swap the values of two variables\n",
    "- This is done conventionally using a temporary variable for storage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 5\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 6\n",
    "\n",
    "# Conventional value swap\n",
    "temp = a\n",
    "a = b\n",
    "b = temp\n",
    "\n",
    "print( a, b )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Python allows you to do it using a __tuple assignment__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 6\n"
     ]
    }
   ],
   "source": [
    "a, b = b, a\n",
    "print( a, b )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On the left is a tuple of varaibles and on the right is a tuple of expressions\n",
    "- Note that the number on each side of the equality sign must be the same\n",
    "- The right side can be any kind of sequence (e.g., a string or list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "monty\n",
      "python.org\n"
     ]
    }
   ],
   "source": [
    "addr = 'monty@python.org'\n",
    "uname, domain = addr.split( '@' )\n",
    "print( uname )\n",
    "print( domain )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples as return values\n",
    "- A function can only return one value\n",
    "- However, if we make that value a tuple, we can effectively return multiple values\n",
    "- For example, the ``divmod`` function takes two (2) arguments and retunrs a tuple of two (2) values, the quotient and remainder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "quotient, remainder = divmod( 7, 3 )\n",
    "print( quotient )\n",
    "print( remainder )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Note the use of a tuple assignment\n",
    "- Here is how to build a function that returns a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "def min_max( a_tuple ):\n",
    "    return min( a_tuple ), max( a_tuple )\n",
    "\n",
    "numbers = ( 13, 7, 55, 42 )\n",
    "min_num, max_num = min_max( numbers )\n",
    "print( min_num )\n",
    "print( max_num )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Note that ``min`` and ``max`` are built-in functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable-length argument tuples\n",
    "- All the functions we have built and used required a specific number of arguments\n",
    "- You can use tuples to build functions that accept a variable number of arguments\n",
    "- Prepend the argument’s variable name with an ``*`` to do this\n",
    "- It is referred to as the __gather__ operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2.0, '3')\n"
     ]
    }
   ],
   "source": [
    "def printall( *args ):\n",
    "    print( args )\n",
    "\n",
    "printall( 1 , 2.0 , '3' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The complement is the __scatter__ operator\n",
    "- It allows you to pass a sequence of values as individual arguments to the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 1)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_tuple = ( 7, 3 )\n",
    "# divmod( a_tuple ) # Uncomment to see error\n",
    "divmod( *a_tuple )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists and tuples\n",
    "- The ``zip`` function takes two or more sequences and \"zips\" them into a list of tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 0)\n",
      "('b', 1)\n",
      "('c', 2)\n"
     ]
    }
   ],
   "source": [
    "a_string = 'abc'\n",
    "a_list = [ 0, 1, 2 ]\n",
    "for element in zip( a_string, a_list ):\n",
    "    print( element )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Essentially, it returns an __iterator__ over a list of tuples\n",
    "- If the sequences aren't the same length, the result has the length of the shorter one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('P', 'T')\n",
      "('e', 'o')\n",
      "('t', 'n')\n",
      "('e', 'y')\n"
     ]
    }
   ],
   "source": [
    "for element in zip( 'Peter', 'Tony' ):\n",
    "    print( element )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- You can also use tuple assignment to get the individual values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 0\n",
      "b 1\n",
      "c 2\n"
     ]
    }
   ],
   "source": [
    "a_list = [ ('a', 0), ('b', 1), ('c', 2) ]\n",
    "for letter, number in a_list:\n",
    "    print( letter, number )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- You can combine ``zip``, ``for`` and tuple assignment to traverse two (or more) sequences at the same time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def has_match( tuple1, tuple2 ):\n",
    "    result = False\n",
    "    for x, y in zip( tuple1, tuple2 ):\n",
    "        if( x == y ):\n",
    "            result = True\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- If you need the indices, use the ``enumerate`` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 a\n",
      "1 b\n",
      "2 c\n"
     ]
    }
   ],
   "source": [
    "for index , element in enumerate( 'abc' ):\n",
    "    print( index, element )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries and tuples\n",
    "- The method ``items`` returns a tuple of key-value pairs from a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict_items'>\n",
      "dict_items([('a', 0), ('b', 1), ('c', 2)])\n",
      "('a', 0)\n",
      "('b', 1)\n",
      "('c', 2)\n"
     ]
    }
   ],
   "source": [
    "a_dict = { 'a': 0, 'b':1, 'c':2 }\n",
    "dict_items = a_dict.items()\n",
    "\n",
    "print( type( dict_items ) )\n",
    "print( dict_items )\n",
    "\n",
    "for element in dict_items:\n",
    "    print( element )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Remember that there is no particular ordering in a dictionary\n",
    "- You can also add a list of tuples to a dictionary using the update method\n",
    "- Using ``items``, tuple assignment, and a ``for`` loop is an easy way to traverse the keys and values of a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 0\n",
      "b 1\n",
      "c 2\n"
     ]
    }
   ],
   "source": [
    "for key, value in a_dict.items():\n",
    "    print( key, value )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Since tuples are immutable, you can even use them as keys in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob Smith 555-1234\n",
      "Jane Doe 555-9786\n"
     ]
    }
   ],
   "source": [
    "directory = dict()\n",
    "directory[ 'Smith', 'Bob' ] = '555-1234'\n",
    "directory[ 'Doe', 'Jane' ] = '555-9786'\n",
    "\n",
    "for last, first in directory:\n",
    "    print( first, last, directory[last, first] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Examples of a state diagram for a tuple can be found on pg. 121"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparing tuples\n",
    "- Relational operators work with tuples as well\n",
    "- The process is:\n",
    "    1. Compare the first item\n",
    "    1. If they are equal, go on to the next one\n",
    "    1. Continue until elements that differ are found\n",
    "    1. Subsequent elements are ignored"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sequences of sequences\n",
    "- In many situations, the different kinds of sequences (i.e., strings, lists, and tuples) can be used interchangeably\n",
    "- _When do you choose one over the other?_\n",
    "- Strings are more limited since they are immutable and the elements have to be characters\n",
    "- Lists are more common than tuples (mainly because they are mutable)\n",
    "- Prefer tuples when:\n",
    "     - It is syntactically easier to create a tuple (like a ``return`` statement)\n",
    "     - You want to use a sequence as a dictionary key. If so, you need to use a string or a tuple since they are immutable\n",
    "     - If you passing a sequence as an argument to a function, using tuples reduces the potential for unexpected behavior due to aliasing\n",
    "- Since tuples aren’t immutable, you can’t ``sort`` or ``reverse`` them\n",
    "- However, there are the functions sorted and reversed which return a new sequence with the ordering changed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Debugging\n",
    "- Lists, dictionaries and tuples are known generically as __data structures__\n",
    "- We dive into these data structures more in other courses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "- Many of the built-in functions use variable-length argument tuples.  For example, ``max`` and ``min`` can take any number of arguments, but ``sum`` does not. Write a function called ``sum_all`` that takes any number of arguments and returns their sum.\n",
    "- Write a function called ``print_all`` that takes a variable number of arguments and prints each one on its own line.\n",
    "- Write a function called ``distance`` that takes two (2) two-dimensional points and returns the distance between them. Then, extend your function to use three-dimensional points.  Can you generalize it to take two points of any dimension?\n",
    "-  Write a function called ``merge`` that takes two (2) sorted tuples and returns a new tuple that contains all the elements in the two tuples in sorted order. Write both a recursive and an iterative solution."
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}