data_containers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Python types and containers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-1-7d76320d8f62>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-7d76320d8f62>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    Like most computer languages, Python allows one to work with numbers and text.  Let's start with numbers.  The following is *not* intended to be comprehensive; it is intended to give you enough information and examples to get started.  Then it is up to you to learn by experimenting, by looking in the documentation, by looking at more code examples, and by asking questions.\u001b[0m\n\u001b[0m         ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "Like most computer languages, Python allows one to work with numbers and text.  Let's start with numbers.  The following is *not* intended to be comprehensive; it is intended to give you enough information and examples to get started.  Then it is up to you to learn by experimenting, by looking in the documentation, by looking at more code examples, and by asking questions.\n",
    "\n",
    "Note: in this notebook we are working with functionality that comes with Python itself; we will introduce the numpy package and other key components for scientific computing in the subsequent notebooks. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numbers and Booleans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's system of numbers is quite simple: there are integers, floating point numbers, complex numbers, and Boolean (`True` or `False`) types, together with their associated operations.  The types are determined dynamically, so operations involving integers and floating point numbers yield floating point numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 + 2 =  3\n",
      "1.0 + 2 = 3.0\n"
     ]
    }
   ],
   "source": [
    "print(\"1 + 2 = \", 1 + 2)\n",
    "print(\"1.0 + 2 =\", 1.0 + 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Division can be tricky because traditional computer languages use integer division on integers.  This was the case by default with Python 2, but there it can be changed via the first line in the following block, which you will often see in code written for both Python versions.  Python 3 uses \"true division\" for '/' and integer division only with the explicit integer division operator, '//'.  Notice that the even with '//' the type of the number returned is a float if either of the arguments is a float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 / 3 =  1.3333333333333333\n",
      "4.0 / 3 = 1.3333333333333333\n",
      "4 // 3 =  1\n",
      "4.0 // 3 =  1.0\n",
      "3.0\n"
     ]
    }
   ],
   "source": [
    "from __future__ import division # get Py3 behavior if on Py2\n",
    "print(\"4 / 3 = \", 4 / 3) # would return 1 on Py2 without the import\n",
    "print(\"4.0 / 3 =\", 4.0 / 3)\n",
    "print(\"4 // 3 = \", 4 // 3)\n",
    "print(\"4.0 // 3 = \", 4.0 // 3)\n",
    "y = 10 // 3.0\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are some built-in functions that operate on numbers, e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1.3333333333\n",
      "0.7999999999999998\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "print(int(4/30))\n",
    "print(round(4/3, 10))\n",
    "print(abs(4.2 - 5)) # Note binary floating point inability\n",
    "                    # to represent a decimal number exactly.\n",
    "print(pow(2, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arithmetic operators include exponentiation with the following notation as an alternative to the `pow()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "print(2*3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more math functions, one can import the `math` module from the standard library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8414709848078965\n",
      "1.4142135623730951\n",
      "-1.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(math.sin(1))\n",
    "print(math.sqrt(2))\n",
    "print(math.remainder(3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will rarely use the `math` module, however, because `numpy` provides the same functionality and much more."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Complex numbers use this notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "complex number: (1+2.3j)\n",
      "(3+9j)\n"
     ]
    }
   ],
   "source": [
    "print(\"complex number:\", 1.0 + 2.3j)\n",
    "print(1+2j+2+7j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boolean values are either `True` or `False`, and result from conditional expressions like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 > 2 is False but 1 < 2 is True\n"
     ]
    }
   ],
   "source": [
    "print(\"1 > 2 is\", 1 > 2, \"but 1 < 2 is\", 1 < 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a more complex conditional expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(1 > 2 or 3 < 4)\n",
    "print(1>=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Much computer programming requires working with text. A piece of text is held in an object called a `string`. There is an additional layer of complexity, and of difference between Python 2 and 3, associated with how text is represented internally (in memory) versus externally (on the page or screen).  This is the dreaded \"unicode\".  We will blissfully ignore it for now.\n",
    "\n",
    "Python strings can be created with the `str()` function, and as literals using single quotes, double quotes, triple single quotes, or triple double quotes.  The triples can enclose blocks of text spanning multiple lines. The following are all valid strings, each assigned to a variable name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Single quotes\n",
      "Double quotes\n",
      "a string that has 'single quotes' inside it\n",
      "This is a multiline\n",
      "sentence string, ending with a linefeed.\n",
      "\n",
      "3\n",
      "\n",
      "This is also valid. It starts and ends with a linefeed.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = 'Single quotes'\n",
    "b = \"Double quotes\"\n",
    "c = \"a string that has 'single quotes' inside it\"\n",
    "d = \"\"\"This is a multiline\n",
    "sentence string, ending with a linefeed.\n",
    "\"\"\"\n",
    "e = '''\n",
    "This is also valid. It starts and ends with a linefeed.\n",
    "'''\n",
    "for example in (a, b, c, d, 3, e):\n",
    "    print(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can be added (concatenated):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'str' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-52-0a469352c482>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0me\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0ma\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: unsupported operand type(s) for -: 'str' and 'str'"
     ]
    }
   ],
   "source": [
    "print(d + e + a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jargon alert: Any particular string is an *object* that is an *instance* of a *class* (or *type*), and therefore operations on it can be performed by invoking *methods* of that class (``str``).\n",
    "Methods are invoked using \"dot\" syntax, e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The variable 'a' is an instance of the <class 'str'> class\n",
      "Converted to upper case: SINGLE QUOTES\n",
      "Does it end with 'quotes'? True\n",
      "Split into a list of words: ['Single', 'quotes']\n",
      "['Single', 'quotes']\n",
      "Single quotes\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"The variable '%s' is an instance of the %s class\" % ('a', a.__class__))\n",
    "print(\"Converted to upper case:\", a.upper())\n",
    "print(\"Does it end with 'quotes'?\", a.endswith(\"quotes\"))\n",
    "print(\"Split into a list of words:\", a.split())\n",
    "ggg=a.split()\n",
    "print(ggg)\n",
    "print(a.capitalize())\n",
    "a.istitle()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reminder: to see a list of methods for \"a\", you can enter \"a.\" and then hit the Tab key. Try it in the cell above, or make a new cell for testing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A string is a sequence of characters; as with any Python sequence, we can use indexing to access parts of the sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-83-78ac7d89c5f8>, line 7)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-83-78ac7d89c5f8>\"\u001b[0;36m, line \u001b[0;32m7\u001b[0m\n\u001b[0;31m    p=(1..10)\u001b[0m\n\u001b[0m         ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(a[-1:1])\n",
    "print(a[-5:])\n",
    "print(a[0])\n",
    "print(a[-1])\n",
    "print(a[::2])\n",
    "p=(1..10)\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More jargon: Strings are *immutable*--that is, unchangeable--so you cannot alter an existing string object, but you can make a new string object out of parts of an old one.  That is what indexing is doing in the example above.\n",
    "\n",
    "Based on these examples, see if you can figure out how Python's indexing syntax works."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's consider two other sequence objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sequences: tuples and lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples and lists are very general sequences--that is, they are containers that preserve order, and they can contain any kind of object at all.  There is one big practical difference: tuples are *immutable*, lists are *mutable*.  One might wonder why we need tuples at all.  In most cases, if you need a general sequence type in your program, you can use a list, regardless of whether you plan to change its contents.  It turns out that in more advanced work there are situations where only a tuple will do, however---specifically, dictionary keys must be immutable, so a tuple can be used as a dictionary key but a list cannot. We will introduce dictionaries shortly, but first we need to become comfortable with tuples and lists.\n",
    "\n",
    "To create a tuple from scratch, use round parentheses and commas; for lists, use square parentheses:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "print(\"tuple with one element (the comma is required):\", (1,))\n",
    "print(\"tuple:\", (1, 2)\n",
    "print(\"tuple:\", (3, (4, 5), 7, 8, \"some string\"))\n",
    "print(\"list with one element (trailing comma is optional):\", [1])\n",
    "print(\"another list:\", [\"first element\", 2, 3, \"last element\"])\n",
    "\n",
    "(1,)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists have many methods, and support addition and multiplication:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adding is concatenation: ['list1', 1, 2, 'list2', 3, 4]\n",
      "multiplication is repetition: ['list1', 1, 2, 'list1', 1, 2]\n",
      "We extended a by tacking list b on the end: ['list1', 1, 2, 'list2', 3, 4]\n",
      "  (This is identical to the sum, a + b, above.\n",
      "Then we added a string: ['list1', 1, 2, 'list2', 3, 4, 'added to end']\n",
      "(1, 2)\n",
      "['list1', 1, 2, 'list2', 3, 4, 'added to end']\n",
      "[1, 90]\n"
     ]
    }
   ],
   "source": [
    "a = [\"list1\", 1, 2]\n",
    "b = [\"list2\", 3, 4]\n",
    "print(\"adding is concatenation:\", a + b)\n",
    "print(\"multiplication is repetition:\", a * 2)\n",
    "c = a.extend(b) # assigning to c only to suppress printing\n",
    "print(\"We extended a by tacking list b on the end:\", a)\n",
    "print(\"  (This is identical to the sum, a + b, above.\")\n",
    "c = a.append(\"added to end\")\n",
    "print(\"Then we added a string:\", a)\n",
    "\n",
    "d=(1,2)\n",
    "f=(2,3)\n",
    "print(d)\n",
    "print(a)\n",
    "(d+(2,))\n",
    "f*5\n",
    "g=[1]\n",
    "h=[90]\n",
    "(g.extend(h))\n",
    "print(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sequences: indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists, tuples, and strings all support the same indexing syntax.\n",
    "\n",
    "- Python indexing starts from zero.\n",
    "- A sequence of N elements therefore has indices ranging from 0 through N-1.\n",
    "- Negative indices count backwards from the end; they are handled by adding N to the negative index, so -1 is the last element, -2 the one before that, etc.\n",
    "- Basic indexing accesses a single element or a range (*slice*).\n",
    "- A slice *includes* the start of a range but *excludes* the end.\n",
    "- A slice has an optional step, for subsampling a range.\n",
    "\n",
    "The zero-based indexing and the exclusion of the end of a range may seem odd if you are coming from Matlab, but they work very well in practice, often leading to simpler code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]\n",
      "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]\n"
     ]
    }
   ],
   "source": [
    "# Using the built-in \"range\" function,\n",
    "# make a list on which we can practice indexing:\n",
    "x = list(range(0, 100, 10))\n",
    "print(x)\n",
    "print(list(range(0,99,2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Take the first 5 values, then the last 5 values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 10, 20, 30, 40]\n",
      "[0, 10, 20, 30, 40]\n",
      "[50, 60, 70, 80, 90]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]\n",
      "11\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
      "[27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2]\n",
      "3\n",
      "4\n",
      "[1]\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(x[0:5])\n",
    "print(x[:5])\n",
    "print(x[-5:])\n",
    "\n",
    "g=list(range(1,30,1))\n",
    "print(g)\n",
    "print(g[10]) # ELEVENTH value!?\n",
    "print(g[:10]) # first TEN values!\n",
    "print(g[None:None:-1])\n",
    "print(g[-3:0:-1])\n",
    "print(g[2])\n",
    "print(g[3])\n",
    "print(g[None:1])\n",
    "print(g[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See how easy that was?\n",
    "Now take every second value starting from the second (index 1):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x[1::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the order is *start*, *stop*, *step*, separated by colons.  If a value is the default, it can be omitted.  The default *step* is 1.  When the *step* is positive, the default *start* is 0, and the default *stop* is one past the last.  Remember, the slice *includes* the *start*, but *not* the *stop*.\n",
    "\n",
    "When the *step* is negative, the indices are selected in descending order, so the default *start* is the highest index. The default *stop*, to include the zero index, is `None`.  (One might guess it would be `0` minus `1`, so `-1`, but that would not work, because the index `-1` refers to the *last* element in the array.)\n",
    "\n",
    "Let's illustrate the negative *step* first with a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dcba\n",
      "dcba\n",
      "dcba\n",
      "cb\n"
     ]
    }
   ],
   "source": [
    "print('abcd'[::-1])\n",
    "print('abcd'[:None:-1])\n",
    "print('abcd'[-1:None:-1])\n",
    "print('abcd'[-2:0:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Back to the list, showing indexing backwards by two, then a case with only one element, and then with none:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]\n",
      "[90, 70, 50, 30, 10]\n",
      "10\n",
      "20\n",
      "[10]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "x = list(range(0, 100, 10))\n",
    "print(x)\n",
    "print(x[::-2])\n",
    "print(x[1]) # second value\n",
    "print(x[2]) # third value\n",
    "print(x[1:2]) # first to second values?????\n",
    "print(x[1:1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above examples we are indexing a list with a slice, so we are getting a list back, even if it has only one element in it, or if it is empty.  If we want to get an element from the list, then we index with a single integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "90\n"
     ]
    }
   ],
   "source": [
    "print(x[0])\n",
    "print(x[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is one thing that you might like to do, but cannot do directly with native Python types (though you can with Numpy arrays, as we will see later): that is to index with an arbitrary set of indices.\n",
    "\n",
    "You can do it indirectly, however, using a powerful construct called a *list comprehension*, which is easier to understand and use than its name might suggest.  Here are some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]\n",
      "[30, 70, 20, 10]\n",
      "[0, 10, 20, 80, 90]\n",
      "[0, 400, 1600, 3600, 6400]\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "xlist = list(range(0, 100, 10))\n",
    "print(xlist)\n",
    "# arbitrary set of indices we want to select:\n",
    "ilist = [3, 7, 2, 1] \n",
    "\n",
    "xi = [xlist[i] for i in ilist]\n",
    "print(xi)\n",
    "\n",
    "# More list comprehension examples:\n",
    "print([x for x in xlist if x < 30 or x > 70])\n",
    "print([x ** 2 for x in xlist if x % 20 == 0])\n",
    "\n",
    "print(101 % 9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because lists are *mutable*, you can alter an element in a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20, 30, 40]\n",
      "[20, 30, -40]\n",
      "[20, 30, 0]\n",
      "[0, 30, 0]\n"
     ]
    }
   ],
   "source": [
    "xlist = list(range(20, 50, 10))\n",
    "print(xlist)\n",
    "xlist[-1] = - xlist[-1]  # flipped the sign\n",
    "print(xlist)\n",
    "xlist[2]=0\n",
    "print(xlist)\n",
    "xlist[0]=xlist[-1]\n",
    "print(xlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Items in tuples and lists can be found easily only based on their locations, that is, their indices.  In a dictionary, items can be located efficiently based on their keys--and this is as true of a Python `dict` as it is of the Oxford English Dictionary.  Dictionaries are central to the internal workings of Python, and to much code written in Python.  They can be very small, very large, or anywhere in between.  Keys are usually strings (text), but can be any *immutable* Python object, such as a tuple.  Here are some examples of dictionary creation and indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'yes': True, 'no': False}\n",
      "True\n",
      "False\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "yesno = dict(yes=True, no=False)\n",
    "print(yesno)\n",
    "print(yesno['yes'])\n",
    "print(yesno['no'])\n",
    "\n",
    "dum=dict(aaa=0, bb=1)\n",
    "print(dum['aaa'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: True, 0: False, 'yes': True, 'no': False}\n",
      "True True\n"
     ]
    }
   ],
   "source": [
    "# Use an alternative syntax for initializing a dictionary:\n",
    "responses = {1 : True, 0 : False, 'yes' : True, 'no' : False}\n",
    "print(responses)\n",
    "print(responses[1], responses['yes'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The two examples above illustrate the two basic ways of creating a dictionary.  The first calls a function with keyword arguments; it works only when the keys are strings.  The second uses curly brackets, and works for any valid keys (immutable objects)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Jan': 'January', 'Feb': 'February', 'Mar': 'March', 'Apr': 'April', 'May': 'May', 'Jun': 'June'}\n"
     ]
    }
   ],
   "source": [
    "month_by_abbrev = dict(Jan=\"January\", Feb=\"February\", Mar=\"March\",\n",
    "                       Apr=\"April\", May=\"May\", Jun=\"June\") # etc...\n",
    "print(month_by_abbrev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entries can be retrieved, and new entries added, by indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "April\n",
      "{'Jan': 'January', 'Feb': 'February', 'Mar': 'March', 'Apr': 'April', 'May': 'May', 'Jun': 'June', 'Jul': 'July'}\n"
     ]
    }
   ],
   "source": [
    "print(month_by_abbrev[\"Apr\"])\n",
    "month_by_abbrev[\"Jul\"] = \"July\"\n",
    "print(month_by_abbrev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries have their own methods, of course; refer to the [Python docs](http://docs.python.org/2/library/stdtypes.html#mapping-types-dict)\n",
    "for a full list.  Here is just one example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list of keys: dict_keys(['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul'])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dict_items([('yes', True), ('no', False)])"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"list of keys:\", month_by_abbrev.keys())\n",
    "yesno.keys()\n",
    "yesno.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: dictionaries *do not* preserve the order in which the key-value pairs were added.  Usually this doesn't matter; but if it does, then you can use an [OrderedDict](http://docs.python.org/3/library/collections.html?highlight=ordered#collections.OrderedDict)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Membership testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings, tuples, lists, and dictionaries all support a simple syntax for testing whether a given item is present.  In the case of dictionaries, it is sought in the keys, not the values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# membership in strings: looks for substrings\n",
    "print(\"any\" in \"many\")\n",
    "print(\"few\" in \"many\")\n",
    "\"asdaassdfsg\" in \"s\"\n",
    "\"s\" in \"sasdasdasd\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# membership in a dictionary tests the presence of a key:\n",
    "print(\"Apr\" in month_by_abbrev)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dict_values(['January', 'February', 'March', 'April', 'May', 'June', 'July'])"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# To check for a value in a dictionary, use the values() method:\n",
    "print(\"April\" in month_by_abbrev.values())\n",
    "print(\"Mars\" in month_by_abbrev.values())\n",
    "print(\"Apr\" in month_by_abbrev.values())\n",
    "month_by_abbrev.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}