week00b-python-intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python\n",
    "\n",
    "This tutorial introduces basic Python syntax, commands and variable types. For now, we will start by using Python on a cloud based platform: [repl.it/languages/python3](http://repl.it/languages/python3). In the future, we will be using the Anaconda distribution of Python (see installation instructions [here](software-installation)).\n",
    "\n",
    "The white window on the left is an editor, where multiple lines of code can be entered and run all at once. We start by entering Python code line by line in the interpreter on the right.\n",
    "\n",
    "### 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": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print('Hello, World!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntax\n",
    "\n",
    "These are the rules of the language. Think of it as grammar.\n",
    "If you get a `SyntaxError` it means Python cant handle something you've done because of an error in the 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",
    "The following lines of code will raise a `SyntaxError`, can you see why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`print('Hello, World!'\n",
    "print('Hello, World!'))\n",
    "print('Hello, World!\")\n",
    "print('Hello, World!)`"
   ]
  },
  {
   "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": 206,
   "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": "code",
   "execution_count": 207,
   "metadata": {
    "collapsed": true
   },
   "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": 208,
   "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": 209,
   "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": 210,
   "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": [
    "`2& = 8 `"
   ]
  },
  {
   "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": [
    "`a = 16 \n",
    "a = a+2  \n",
    "print(a) `"
   ]
  },
  {
   "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": 211,
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "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": [
    "#### String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "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 integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "s = '16'\n",
    "si = int(s)\n",
    "print(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": 216,
   "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",
    "Write a program that asks the user to enter a number, adds 10, then prints out the new number."
   ]
  },
  {
   "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": 217,
   "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": 218,
   "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 a 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": 219,
   "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": 220,
   "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": 221,
   "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": 222,
   "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": [
    "### 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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 3.9, 'a string']\n",
      "3.9\n",
      "a string\n"
     ]
    }
   ],
   "source": [
    "t = [5,3.9,'a string']\n",
    "print(t)\n",
    "print(t[1])\n",
    "print(t[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can also be nested within lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "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.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "s3 = 'hello'\n",
    "print(s3[1])\n",
    "print(s3[1:])\n",
    "print(s3[:1])\n",
    "print(s3[1:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some other basic built-in functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "t = [0,2,3]\n",
    "print(len(t)) # length\n",
    "print(sum(t)) # sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise\n",
    "\n",
    "Consider the following list of numbers:\n",
    "    \n",
    "`[5.,7001.,-100,3.4,85.0004]`\n",
    "\n",
    "Write Python code to calculate the mean of these values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 227,
   "metadata": {
    "collapsed": 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": 228,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.41421356237\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": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "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": 230,
   "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": 231,
   "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": [
    "For the list of numbers in the previous exercise, write Python code to calculate the variance.\n",
    "\n",
    "Tips\n",
    "-use variables instead of repeating the same commands\n",
    "-use descriptive variable names(i.e. N=len(values)\n",
    "-help command\n"
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}