week02b-python-intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python\n",
    "\n",
    "This tutorial introduces basic Python syntax, commands and variable types. We will be using the Anaconda distribution of Python (see installation instructions [here](software-installation)).\n",
    "\n",
    "## Ways of using Python\n",
    "\n",
    "### 1. Interactive mode\n",
    "\n",
    "#### Using the Python interpreter\n",
    "\n",
    "There are different ways of using Python. One way is to enter one command at a time in an \"interactive\" mode.\n",
    "\n",
    "To start Python in interactive mode, execute `python` on the Terminal (Mac) or Anaconda Prompt (Windows)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```bash\n",
    "python\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will start the Python interpreter, where commands can entered one at a time. The chevrons `>>>` indicate an interactive command prompt, which is waiting for your input."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Python 3.7.2 (default, Dec 29 2018, 00:00:04)\n",
    "[Clang 4.0.1 (tags/RELEASE_401/final)] :: Anaconda, Inc. on darwin\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Hello, World\n",
    "Typically, the first program that people write when learning and new program is the \"Hello, World!\" program. This is a tradition that dates back to the 1970's, and it is useful for showing the basic syntax of a language."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "print('Hello, World!')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To exit the the Python interpreter, type `quit()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The IPython interpreter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Execute `ipython` on the Terminal (Mac) or Anaconda Prompt (Windows). Type the same `print('Hello, World!')` command at the interactive prompt. What differences do you notice?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Running a script file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python commands can also be saved in script files, which can be executed from the command line.\n",
    "\n",
    "Using Atom, Nano or any other text editor, create a file called `my_script.py`. In the file type the same `print('Hello, World!')` command. Now run the script be entering the following on the Terminal (Mac) or Anaconda Prompt (Windows):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```bash\n",
    "python my_script.py\n",
    "```\n",
    "\n",
    "Just like shell scripts, Python scripts can contain a series of different commands, and you do not have to type them in one at a time. When a filename is specified, Python executes the commands in that file instead of opening an interactive prompt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Notebooks \n",
    "\n",
    "Notebooks allow users to run code, display figures and type formatted text in one file. In this class, we will be using \"Jupyter Notebooks,\" which can be run in the Julia, Python and R languages (as well as many others).\n",
    "\n",
    "JupyterLab is an integrated development environment that provides an interface to navigate files, edit text files, run scripts and create notebooks. Start JupyterLab by typing on the Terminal (Mac) or Anaconda Prompt (Windows):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```bash\n",
    "jupyter lab\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This brings up a graphical user interface, which can be used to create a new notebook file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Syntax\n",
    "\n",
    "These are the rules of the language. Think of it as grammar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`'Hello, World!'` is an example of a __string__, which is a set of characters. Strings are indicated by enclosing them in quotes. They can be single quotes ' ' or double quotes \" \", but note a combination of the two.\n",
    "\n",
    "`print()` is an example of a __function__. A function is a self-contained program that can take input and return output, or just execute a set of instructions. The `print()` function takes whatever input is given between the parentheses and prints it to the screen. The `print()` function is an example of a built-in function. It is part of the Python language. Later, we will write our own functions, a powerful tool in programming.\n",
    "\n",
    "In addition to printing strings, the `print()` function can also print numerical values. If you do arithmetic inside the parentheses, those operations are executed first and the answer is printed to the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello MS263\n",
      "6\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print('Hello MS263')\n",
    "print(6)\n",
    "print(4+6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you get a `SyntaxError` it means Python can't handle something you've done because of incorrect syntax. In real life, we can sometimes break rules of syntax and get away with it. When communicating with computers in a language like Python, there is no room for error.\n",
    "\n",
    "##### Exercise\n",
    "\n",
    "The following lines of code will raise a `SyntaxError`, can you see why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "print('Hello, World!'\n",
    "\n",
    "print('Hello, World!'))\n",
    "\n",
    "print('Hello, World!\")\n",
    "\n",
    "print('Hello, World!)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# this is a comment\n",
    "# you can take notes\n",
    "# in comment lines\n",
    "# Python will ignore them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "A __variable__ is information that is stored and labeled with a symbolic name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code above, `a` is the name of the variable and `4` is a value being stored in the variable. You can think of a variable as a container for information, and the name of the variable is label on the container. \n",
    "\n",
    "Python commands like `print()` use the value of the variable, or the information that is being stored in the container. In this case the value `4` is printed rather than the name of the variable `a`.\n",
    "\n",
    "The equals sign = indicates __assignment__. It is used to assign a value to a variable. The variable name is always on the left side of the =, and the value is always on the right.\n",
    "\n",
    "Variable names do not have to be just one letter. The can contain can contain multiple characters, numbers and underscores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "var_1 = 8\n",
    "print(var_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Python does not try to interpret anything within a string as instructions. However, unlike comments, strings are not just ignored. A string is treated as information in the form of text characters, which can be used or manipulated.\n",
    "\n",
    "Characters not in quotes are interpreted as instructions, like `print()`, or variable names that are symbolic of underlying information, like `string_variable` in the code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc\n"
     ]
    }
   ],
   "source": [
    "string_variable = 'abc'\n",
    "print(string_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables cannot start with a number or contain special characters (except underscore \\_). The following code would therefore raise an error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "2& = 8 \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Excercise\n",
    "\n",
    "Without running any code, predict the output of the following three-line program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "a = 16 \n",
    "a = a+2  \n",
    "print(a)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### User input*\n",
    "\n",
    "Another example of a function that takes input and produces output is `input()`. This function waits for the user to type something, and then stores that input in a variable. This puts the user input into a container that can be used later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "i = input('give me information') \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is just one type of user input. Data files are another example of user input that can be read and maniplulated. Later we will learn multiple ways of reading files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Integer \n",
    "No decimal point. Exact."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "i = 4\n",
    "print(i)\n",
    "print(type(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Floating point\n",
    "\n",
    "Adding a decimal point creates a floating point number, which is stored on the computer in a completely different way and is only an approximation.  A floating point is what computer scientists call a number with a decimal point.  A floating point number is really an approximation of a number, compared to an integer which is an exact number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "f = 4.0\n",
    "print(f)\n",
    "print(type(f))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Complex numbers*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3+2j)\n",
      "<class 'complex'>\n",
      "real part 3.0\n",
      "imaginary part 2.0\n"
     ]
    }
   ],
   "source": [
    "c = 3 + 2j\n",
    "print(c)\n",
    "print(type(c))\n",
    "print('real part',c.real)\n",
    "print('imaginary part',c.imag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "s = 'hello'\n",
    "print(s)\n",
    "print(type(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can contain any type of charatcer, including numbers.  Quotes means it's a string that contains the number four.  It means we can do different operations with it as a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "s2 = '4'\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Converting between variable types\n",
    "\n",
    "Built-in Python functions can be used to convert a variable to a different type. For example, `int()` can convert a string to an integer (if the string is a number...if the string is letter characters, python will give an error)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = '16'\n",
    "si = int(s)\n",
    "print(si)\n",
    "type(si)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An integer can be coverted to a floating point number. The value is the same, but it is stored on the computer in a different way (with bits devoted to the sign, exponent and mantissa)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.0\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "sf = float(si)\n",
    "print(sf)\n",
    "print(type(sf))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Excercise\n",
    "\n",
    "What type of value is 3.4 + 5? How can you find out using Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adapted from:\n",
    "http://swcarpentry.github.io/python-novice-gapminder/03-types-conversion/index.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise\n",
    "\n",
    "What type of value (integer, floating point number, or character string) would you use to represent each of the following? There may be more than one good answer for each problem.\n",
    "\n",
    "1. Current population of a city.\n",
    "2. Average population of a city over time.\n",
    "3. Serial number of a piece of lab equipment.\n",
    "4. Time elapsed from the start of the year until now in days.\n",
    "\n",
    "Adapted from:\n",
    "http://swcarpentry.github.io/python-novice-gapminder/03-types-conversion/index.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Combining integers and floats\n",
    "\n",
    "Python easily allows integers and floats to be combined in mathematical calculations. The resulting number is a float. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.0\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "a = 4.0\n",
    "b = 2 \n",
    "print(a+b)\n",
    "print(type(a+b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Other mathematical calculations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "8.0\n",
      "16.0\n",
      "2.0\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "print(a-b)    # subtraction\n",
    "print(a*b)    # multiplication\n",
    "print(a**2)   # raise to power of 2\n",
    "print(a**0.5) # square root\n",
    "print(a/b)    # division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Division in Python\n",
    "\n",
    "The way Python divides two integers has actually changed between Python 2 and 3. Python 2 used to use floor division as the default method of dividing two integers.  Python 3 just creates a float from the two integers. The change in behavior of dividing two integers is one of the biggest differences between Python 2 and 3.\n",
    "\n",
    "The old Python 2 behavior was a holdover from compiled laguages like C, where types are __static__ and have to be explicitly defined. In this case, results of an operation involving two integers is another integer. In Python, types are __dynamic__ and do not have to be explicitly defined. Instead, the are implied, by adding a decimal point to a number (float) or surrounding with quotes (string)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6666666666666666\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "print(2/3)    # dividing two integers in Python 3 \n",
    "print(2//3)   # floor division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Order of operations\n",
    "\n",
    "The order in which mathematical operations are done follow the usual rules, including doing operations enclosed in parentheses first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "print( 3*(4+6) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### An example of round-off error\n",
    "\n",
    "For more information on errors in floating point arithmetic see:\n",
    "https://docs.python.org/3/tutorial/floatingpoint.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3\n",
      "0.30000000000000004\n"
     ]
    }
   ],
   "source": [
    "print(3.0/10.0)\n",
    "print(3*0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Concatenating strings\n",
    "\n",
    "The plus sign (+) does not just have one meaning. It can also be used to add one string to the end of anoather."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n"
     ]
    }
   ],
   "source": [
    "a = 'Py'\n",
    "b = 'thon'\n",
    "print(a+b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise\n",
    "\n",
    "The following variables are assigned in Python:\n",
    "\n",
    "```python\n",
    "first = 1.0\n",
    "second = \"1\"\n",
    "third = \"1.1\"\n",
    "```\n",
    "\n",
    "Which of the following will return the floating point number 2.0? Note: there may be more than one right answer.\n",
    "\n",
    "1. `first + float(second)`\n",
    "2. `float(second) + float(third)`\n",
    "3. `first + int(third)`\n",
    "4. `first + int(float(third))`\n",
    "5. `int(first) + int(float(third))`\n",
    "6. `2.0 * second`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "```{toggle}\n",
    "1. Correct\n",
    "2. Gives incorrect answer of 2.1\n",
    "3. Gives a value error because \"1.1\" cannot be converted to an integer\n",
    "4. Correct\n",
    "5. Gives the integer value 2, not a floating point\n",
    "6. Gives a type error because a string cannot be multiplied by a float\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### Lists\n",
    "\n",
    "* In many situations, we do want to store just one data value, we want to store a collection of data values. One way to do this is with a list. Square brackets denote this as a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "t = [5,3.9,4.2]\n",
    "print(type(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Lists can inlude both numbers and strings. Each element of a list has an index. Indices start at 0.\n",
    "* Indices can also be accessed from the back.  To call the last element, use [-1].  In this example, the last element can be accessed forwards with [2] or backwards [-1]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 3.9, 'a string']\n",
      "3.9\n",
      "a string\n",
      "a string\n"
     ]
    }
   ],
   "source": [
    "t = [5,3.9,'a string']\n",
    "print(t)\n",
    "print(t[1])\n",
    "print(t[2])\n",
    "print(t[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Indexing can be used to assign new values within lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 'new item', 'a string']\n"
     ]
    }
   ],
   "source": [
    "t[1] = 'new item'\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Lists can also be nested within lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 3.9, [1, 2, 3]]\n",
      "[1, 2, 3]\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "t2 = [5,3.9,[1,2,3]]\n",
    "print(t2)\n",
    "print(t2[2])\n",
    "print(t2[2][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Strings have indexing as well.  If you type s3[1:3] python will start at index 1, and include it and everything up to, but not including, index 3.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e\n",
      "ello\n",
      "h\n",
      "el\n",
      "ll\n"
     ]
    }
   ],
   "source": [
    "s3 = 'hello'\n",
    "print(s3[1])\n",
    "print(s3[1:])\n",
    "print(s3[:1])\n",
    "print(s3[1:3])\n",
    "print(s3[-3:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Some other basic built-in functions for lists. '__len__' is short for length, and a function that can be used for lots of different variable types.  It returns the number of items in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "5\n",
      "Help on built-in function len in module builtins:\n",
      "\n",
      "len(obj, /)\n",
      "    Return the number of items in a container.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "t = [0,2,3]\n",
    "print(len(t)) # length\n",
    "print(sum(t)) # sum\n",
    "help(len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise\n",
    "\n",
    "Use slicing to access only the last four characters of a string or entries of a list. The following variables have been created in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "string_for_slicing = \"Observation date: 02-Feb-2013\"\n",
    "list_for_slicing = [[\"fluorine\", \"F\"],\n",
    "                    [\"chlorine\", \"Cl\"],\n",
    "                    [\"bromine\", \"Br\"],\n",
    "                    [\"iodine\", \"I\"],\n",
    "                    [\"astatine\", \"At\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What Python code creates the following output? Would your solution work regardless of whether you knew beforehand the length of the string or list (e.g. if you wanted to apply the solution to a set of lists of different lengths)? If not, try to change your approach to make it more robust.\n",
    "\n",
    "```\n",
    "\"2013\"\n",
    "\n",
    "[[\"chlorine\", \"Cl\"], [\"bromine\", \"Br\"], [\"iodine\", \"I\"], [\"astatine\", \"At\"]]\n",
    "```\n",
    "\n",
    "Adapted from:\n",
    "http://swcarpentry.github.io/python-novice-inflammation/05-lists/index.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2013'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string_for_slicing[25:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['chlorine', 'Cl'], ['bromine', 'Br'], ['iodine', 'I'], ['astatine', 'At']]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_for_slicing[1:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "Tuples are immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tuple = (1,2,3)\n",
    "type(my_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code gives an error because you cannot change a tuple after it has been created.\n",
    "\n",
    "```python\n",
    "my_tuple[1] = 5\n",
    "```\n",
    "\n",
    "Why use a tuple? In certain situations, using a tuple is much more efficient than using a list. The main reason we are introducing it here is that some functions provide output in tuples, so it is good to know what they are."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "Dictionaries are like lists but use keys instead of numerical indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_town = {'name':'Moss Landing','state':'California'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Moss Landing'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_town['name']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_town['zip'] = 95039"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Moss Landing', 'state': 'California', 'zip': 95039}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_town"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise\n",
    "\n",
    "Modify the `my_town` dictionary to include a list of restaurants in Moss Landing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "my_town['restaurants'] = ['Whole Enchilada','Haute Enchilada','Phil\\'s']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Numpy\n",
    "\n",
    "NumPy (Numerical Python) is a __package__ that extends Python's basic capabilities and allows for more complex mathematical operations involving groups of numbers. Importing the numpy __module__ gives access to its functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use this package extensively, and this line of code will be at the top of nearly every program we write in this class. We give the numpy module a \"nickname,\" or __alias__, so it is quicker to type. Giving numpy the alias `np` is standard practice.\n",
    "\n",
    "The numpy library gives access to special mathematical functions, like square root."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4142135623730951\n"
     ]
    }
   ],
   "source": [
    "val = 2\n",
    "val_sr = np.sqrt(2)\n",
    "print(val_sr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list of mathematical functions available in NumPy can be found on the [SciPy documentation website](https://docs.scipy.org/doc/numpy/reference/routines.math.html).\n",
    "\n",
    "NumPy also gives access to a new variable type: the NumPy array. Arrays are similar to lists, but they contain only numbers. We will use NumPy arrays to store numeric data throughout this course. \n",
    "\n",
    "A list of numbers can be converted to an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "num_list = [1,2,3]\n",
    "num_arr = np.array(num_list)\n",
    "print(num_arr)\n",
    "print(type(num_arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays behave differently from lists. Multiplication and addition operatations _replicate_ lists, but these operations act on each individual _elements_ in an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print(num_list*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 6]\n"
     ]
    }
   ],
   "source": [
    "print(num_arr*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will learn more about arrays throughout the semester."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following array of numbers:\n",
    "\n",
    "`my_array = np.array([5.,7001.,-100,3.4,85.0004])`\n",
    "\n",
    "Write your own Python code to calculate the mean of `my_array`. Make sure your code still works if the contents of `my_array` are changed to have different values, or a different number of values.\n",
    "\n",
    "Check the results of your code with the results of the built-in Numpy function, `np.mean`:\n",
    "\n",
    "`np.mean(my_array)`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise\n",
    "\n",
    "Write your own Python code to calculate the standard deviation of `my_array`. Make sure your code still works if the contents of `my_array` are changed to have different values, or a different number of values.\n",
    "\n",
    "Check the results of your code with the results of the built-in Numpy function, `np.std`:\n",
    "\n",
    "`np.std(my_array)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tips\n",
    "* use variables instead of repeating the same commands\n",
    "* use descriptive variable names, i.e. `N=len(values)`\n",
    "* use `help()`"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}