python_1.2_data_types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python: Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reminder of how to use these notebooks\n",
    "As a reminder, you're reading this text in a Jupyter notebook, and each of the blocks of code you see below are called cells. In fact, even the parts with text are called cells. When you are in a Jupyter environment, it is possible for you to double click on cells to edit them.  The text in Jupyter cells is written using Markdown syntax, so the text will look a little strange when a cell is in editing mode.  When you are done editing a cell or if you double-click a cell by accident, press the \"Run\" button above to render the text and make it look pretty again.  <mark>**Don't forget that every time I provide a code example here, you should open up your Spyder IDE and type the commands yourself into the IPython console in Spyder to make sure you can produce the same output that you see here.**</mark> If you don't try writing the code yourself, you'll be unlikely to retain the material."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Required Reading\n",
    "1. [Variables, expressions, and statements](https://www.py4e.com/html3/02-variables) from Python for Everybody by Charles Severance. Supplementary videos are [available here](https://www.py4e.com/lessons/memory)\n",
    "2. [Strings](https://www.py4e.com/html3/06-strings) from Python for Everybody by Charles Severance. Supplementary videos are [available here](https://www.py4e.com/lessons/logic)\n",
    "3. [Lists](https://www.py4e.com/html3/08-lists) from Python for Everybody by Charles Severance. ([lists videos](https://www.py4e.com/lessons/lists))\n",
    "4. [Tuples](https://www.py4e.com/html3/10-tuples) from Python for Everybody by Charles Severance. ([tuples videos](https://www.py4e.com/lessons/tuples))\n",
    "5. [Dictionaries](https://www.py4e.com/html3/09-dictionaries) from Python for Everybody by Charles Severance. ([dictionary videos available here](https://www.py4e.com/lessons/dictionary))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data types are the building blocks of our program that form the \"raw materials\" that we process with our programs. In Python there are a number of built in data types that are commonly used, all of which will be described more fully below. This section will provide you with working knowledge of the basic Python data types:\n",
    "\n",
    "- Numeric data types (**integers** and **floats**)\n",
    "- **Booleans** (a logical data type that takes on one of two possible values: `True` or `False`)\n",
    "- **Strings** (sequence of characters)\n",
    "- Collections – data types that may contain any kind of object (including other collections)\n",
    "    - **Lists** (sequences that are mutable, or changable)\n",
    "    - **Tuples** (sequences that are immutable, or static)\n",
    "    - **Dictionaries** (mappings from a key to a value)\n",
    "    \n",
    "The data type your data is stored as will define the operations that can be done on the data, the meaning of the data, and the way values of that type can be stored, so it's important to know how to identify what kind of objects you are working with when you are programming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numbers\n",
    "There are two primary numerical data types in Python that you'll see: integers and floats. Integers are whole numbers (e.g. 1,2,3,60000,-12,0). Floats (or floating point numbers) are numbers with decimal points."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you say in the readings, two of the core numerical data types are integers (int) and floating point numbers (float). It's good to reinforce a few key points from those readings for clarity.\n",
    "\n",
    "We can create examples of those and ask Python to tell us their type using the `type()` function. We'll talk about functions more later, but for now, just know that for many functions, you feed in an argument (in this case, `x`) and you get out some output, in this case the data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3.4\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we also saw in the reading the `print()` function can be used to print output onto the screen. In the examples above using the `type()` function, we saw that it printed the output to the screen. However, it only does this for the last line in the code. If we wanted to put both of the above cells of code into one and run it, we only get the result of the second `type()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3\n",
    "type(x)\n",
    "x = 3.4\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can fix this by printing the output to the screen, which will use to print multiple outputs from one cell. They print in order from top to bottom as shown below. Using the print command, we actually get a little more information about `x` showing that when is assigned `x` an integer value like 3, it belongs to a class of numbers called `int`. We'll talk much more about what classes are later in this course as well as the more advanced applications of the `print()` function, but we want to try to demystify some of the little challenges along the way early on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "print(type(x))\n",
    "x = 3.4\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's get back to our main discussion about data types. When you divide two integers, the result is a float. Since not all integers divide evenly, the data type is transformed through the division operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'int'>\n",
      "3.5\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "a = 7\n",
    "b = 2\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "\n",
    "c = a / b\n",
    "print(c)\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Booleans\n",
    "Booleans are data type objects that can take on two values, `True` or `False`, and are extremely useful for logical operations. If we want to use our code to ask whether or not one value is greater than another value, as we might in many data analysis settings, Booleans are the tool that we use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = True\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "Strings are sequences of characters. For example 'Data Science' contains 12 characters including one space in a particular order (or sequence)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 'Data Science'\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Collections: lists and tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Collections (or sequences) can hold multiple basic data types (integers, floats, Booleans, strings). Lists are defined with brackets [], and tuples are defined with parentheses (). Either can contain any other data type including other lists or tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1,2,3]\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = (1,2,3)\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also mix and match data types in these collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'this', True]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,'this',True]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 'this', True)\n"
     ]
    }
   ],
   "source": [
    "x = (1,2,'this',True)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These collections can even contain other collections!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, [2, 3, 4], 'this', ('this', 2), True]\n"
     ]
    }
   ],
   "source": [
    "x = [1,[2,3,4],'this',('this',2),True]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, [2, 3, 4], 'this', ('this', 2), True)\n"
     ]
    }
   ],
   "source": [
    "x = (1,[2,3,4],'this',('this',2),True)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In practice, we'll most commonly see these lists with more homogeneous data types, (e.g. all numbers, or all text) and tuples with more heterogeneous sequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = [1,2,6,32,7,8,4,3]\n",
    "y = (10, 'Downing Street', 'London', 'United Kingdom')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mutable means changeable or dynamic (think the word \"mutation\"). Immutable means unable to be changed, or static. An example of a mutable data type is a list. \n",
    "\n",
    "*Side note: Remember, to access a specific element of an array, you index that array. Python's indexing starts at 0, which represents the first value in a list. The second value in the list would be indexed with a 1 and so on.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[99, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,4,5]\n",
    "x[0] = 99\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples, on the other hand, are immutable, and you'll get an error if you try to change one of their elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-efef77817f23>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m99\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "x = (1,2,3,4,5)\n",
    "x[0] = 99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One last comment on indexing. We discussed how the first value in a list is indexed by 0, the second value in the list is indexed by 1, etc., as shown below..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,4,5]\n",
    "print(x[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(x[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access the last value in a collection by indexing it by 1 less than the length of the collection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(x[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A shortcut to get the index the last value is to use the index `-1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(x[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can similarly index the second-to-last value by `-2` and so on..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(x[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then there are dictionaries. Think about how a tradition paper dictionary works. You want to search for a definition (we'll call these values), and the definition is connected with a particular word (we'll call these keys). You open up the dictionary, search for the key, and by doing so are able to retrieve the corresponding value. That's how a dictionary works here: it *maps* keys to values.\n",
    "\n",
    "Let's start with an example with two key-value pairs. Let's assume we are representing the ages of two people, Sheila, age 34, and Robert, age 17. We can represent this with the following dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Sheila': 34, 'Robert': 17}\n"
     ]
    }
   ],
   "source": [
    "age = {'Sheila': 34, 'Robert': 17}\n",
    "print(age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to know what Sheila's age is, just look it up as you would in a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age['Sheila']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, dictionaries are also mutable, so they can be changed after being created. Let's adjust Robert's age to 18. Let's also add Polly, age 42, to the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Sheila': 34, 'Robert': 18, 'Polly': 42}\n"
     ]
    }
   ],
   "source": [
    "age['Robert'] = 18\n",
    "age['Polly']  = 42\n",
    "print(age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll notice different types of brackets are used for different types of collections. Dictionaries use `{}`, lists use `[]`, and tuples use `()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable names\n",
    "Now that we've discussed our data types that our Python variables can be, we generally saw that we can make up our own names for them. However, there are a few names we cannot use, and there are many more we shouldn't use.\n",
    "\n",
    "There are a few rules around naming variables. You cannot name variables starting with a number, so `1000miles` is not a valid variable name. You can use numbers in variable names, but they just can't begin the name. So `miles1000` is legal syntax. You can use letters, numbers, and underscores, but not other symbols. Therefore, `eat@joes` is not a valid name.\n",
    "\n",
    "There are also a number of reserved words for the Python language that you cannot use as variable names:\n",
    "\n",
    "| | | | | |\n",
    "|----------|----------|----------|----------|-------|\n",
    "|and       |del       |from      |None      |True   |\n",
    "|as        |elif      |global    |nonlocal  |try    |\n",
    "|assert    |else      |if        |not       |while  |\n",
    "|break     |except    |import    |or        |with   |\n",
    "|class     |False     |in        |pass      |yield  |\n",
    "|continue  |finally   |is        |raise     |       |\n",
    "|def       |for       |lambda    |return    |       |\n",
    "\n",
    "Aside from names that simply will not work, there are many others that are less clear to the reader of your code than others. We'll talk more about style later, but generally, you'll want to make these variable names meaningful. Let's say you were trying to represent the speed of a train. You could use a variable `s`, but `s` could mean a lot of things. A better (and more descriptive) name would be `speed`, and better still would be `speed_of_train`. Now, you want this to be within a reasonable length, so `speed_of_train_from_boston_to_new_york_through_new_haven_and_providence` is not an ideal name because it's far too long. Use common sense and above all, make your code readable so someone else could easily pick it up, understand it, and use it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next\n",
    "Now that we have the \"raw material\" of our functions: variables and basic data types, next we will explore how to put these to work using Python code. "
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}