01IntroductionToPython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting Started\n",
    "\n",
    "## Using Jupyter Notebooks\n",
    "\n",
    "To evaluate a cell, highlight the cell and press Shift+Enter. \n",
    "\n",
    "To create a new cell, hit the + button in the toolbar above.\n",
    "\n",
    "To create a cell for writing (as opposed to code) such as this one, highlight the cell and switch its type to \"Markdown\" in the dropdown menu above.\n",
    "\n",
    "Some useful shortcuts:\n",
    "\n",
    "In a cell, type esc, m, enter to go into change a cell to \"Markdown\".\n",
    "\n",
    "Click to the left of a cell to enter Command Mode. In Command Mode, type:\n",
    "    \n",
    "    a   to add cell above\n",
    "    \n",
    "    b   to add cell below\n",
    "    \n",
    "    d,d to delete cell\n",
    "\n",
    "Other useful shortcuts can be found here: http://maxmelnick.com/2016/04/19/python-beginner-tips-and-tricks.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Expressions\n",
    "\n",
    "Python handles several types of expressions; e.g., string, numerical and list expressions. \n",
    "\n",
    "In the following cell, below the green text, type a number then evaluate it. This is a numerical expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type a numerical expression below this line:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Statements following a pound sign are 'comments' which are not evaluated by Python. Try evaluating the following cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Evaluating this cell does nothing!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Commenting\" your code is EXTREMELY IMPORTANT. It will help others to follow your code. It will also help you when you go back to look at your code. \n",
    "\n",
    "Please include extensive comments on your code --- it may not be necessary for these first simple pieces of code, but it is good to get in the habit for when you start writing more complex code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the following cells:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2.009 # Numerical expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'abcd' # String expression. Note the quotation marks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"abcd\" # Double quotes also produces a string expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abcd \n",
    "# Without quotes, we get an error. \n",
    "# Python wants to treat this as a variable (see next section)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remark: As you learn to code, you will spend a lot of time sorting through error messages. (In my experience, this is something that will persist even as you become a more proficient programmer.) \n",
    "\n",
    "It's a good idea to start paying attention to the structure of error messages. This is meant to help you fix your code. Google is your friend here!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[2,3,4,5] # List expression. Elements of the list are numerical expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "['a','b','c','defg'] # A list expression whose elements are string expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists can contain different types of expressions.\n",
    "# Create a list below this line containing a mixture of numerical and string expressions:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[['a','b','c'],[123],'1',2] # Lists can contain lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operations\n",
    "\n",
    "There are several operations that can be performed on each type of expression. Let's explore some possiblilites."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numerical Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type 2+3 and evaluate:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 + 3 \n",
    "# Spaces can be placed between arguments and operators.\n",
    "# This has no effect on the output, but improves readability of the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2     +        3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2*3 # Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2**3 # Exponentiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2**1000 # Large integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type some combination of numerical operations below and evaluate. \n",
    "# The usual order of operations applies.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "By playing around with examples, determine the numerical operation performed by the following symbols:\n",
    "/ // and %"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'abcd'+'efgh' # Concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a sentence by concatenating a few strings:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[1,2,3]+[4,5,6] # This is also concatenation, not vector addition!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It makes sense that the above is concatenation, since it should make sense for lists of string expressions. It also makes sense for lists of different sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "['a','b','c']+['cat','dog']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To perform vector operations, we need to use a package. A package is a collection of functions which need to be imported in order to use. A common package for linear algebra is called `numpy`.\n",
    "\n",
    "Note: Specialized packages need to be installed. Your installation of Anaconda came with numpy already installed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy # Use this command to import numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get vectors, we enter them as a new type of expression: `numpy` arrays. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numpy.array([1,2,3]) # Syntax: use the 'array' function from the package 'numpy'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numpy.array([1,2,3])+numpy.array([4,5,6]) \n",
    "# Addition of numpy arrays works like vector addition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numpy.array(['a','b','c'])+numpy.array(['cat','dog']) # This does not make sense!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also represent matrices as `numpy` arrays and perform standard operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numpy.array([[1,2,3],[4,5,6]]) # A 2x3 matrix. Note the syntax here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numpy.array([[1,2,3],[4,5,6]])+numpy.array([[1,0,0],[0,0,0]]) # Matrices can be added"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numpy.array([[1,2,3],[4,5,6]])*numpy.array([[2,1,0],[0,1,0]]) \n",
    "# This is not matrix multiplication. It multiplies matrices entry-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The symbol @ denotes matrix multiplication. Type an example and evaluate it:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will see below how to multiply matrices in `numpy`. This is demonstrated in the \"Functions\" section.\n",
    "In general, we will use the numpy package extensively in this course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "In the operations above, we typed out the expression in each line. It is much more economical to store expressions in variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2 \n",
    "# We define the variable \"a\" to represent the number 2.\n",
    "# Notice that there is no output when we evaluate the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a*b # We can now perform operations on the variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a**b # We can also define new variables by performing operations on the old ones\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since an output is not automatically produced when we define a variable, we included the command `print(c)` to display the value of the variable. `print()` is an example of a function, which we will discuss below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store another number in a variable d. \n",
    "# Then write and evaluate an expression involving numerical operations and a,b,c,d\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also store strings as variables\n",
    "string1 = 'cat'\n",
    "string2 = 'dog'\n",
    "string1+string2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Virtually any string of numbers and letters can be used as a variable. Some symbols are reserved, however. For example, we can't use \"2\" to denote a variable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for = 5 \n",
    "# 'for' is reserved to denote a command in a 'for loop'. This will be discussed below. \n",
    "# We get an error message if we attempt to use 'for' as a variable name. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use variables to store any type of expression, such as lists or numpy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = ['a','b','c','d']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L + ['e','f']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aa = numpy.array([[3,2],[1,1]])\n",
    "bb = numpy.array([[2,2],[3,3]])\n",
    "aa+bb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables can be redefined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "a = 2\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables can be redefined recursively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = a+1\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `=` doesn't play its usual mathematical role (otherwise the statement `a=a+1` doesn't make sense). In Python, `=` has a directionality. The previous command should be read as 'the new value of `a` is defined to be the previous value of `a` plus 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = L + ['p','q','r','s']\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More String Operations\n",
    "\n",
    "Now that we can store strings in a variable, let's look at another string operation: 'slicing'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'abcdef'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Determine the operation performed by the commands text[:4] and text[2:]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More List Operations\n",
    "\n",
    "Now that we can store a list in a variable, let's look at a few more operations that we can do on lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = ['cat','dog','fish','bird'] # Redefine the variable L as a new list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# We can pull out entries from the list by their index\n",
    "print(L[0]) # !!!! Note that in Python, indexing starts at 0 !!!!\n",
    "print(L[1])\n",
    "print(L[2])\n",
    "print(L[3])\n",
    "print(L[4]) # This will give an error message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Determine the behavior of commands `L[-1]`, `L[-2]`, `L[1:3]`, `L[:]`, `L[-3:-1]`, `L[-2:]`\n",
    "\n",
    "Find a single command which will replace 'fish' with 'hamster' in the list.\n",
    "\n",
    "Find a single command which will replace the last two entries of the list with 'mouse' and 'ferret', respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions, Conditionals, Loops\n",
    "## Functions\n",
    "Python has many built-in functions. These are rules which take one (or several) expression(s) to (an)other expression(s), possibly of different types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len('abc') # For example, \"len()\" is a function which takes a string to an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string1 = 'abc123xyz' # Functions can be applied to variables.\n",
    "len(string1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = ['cat','dog','mouse'] # len() can also take a list as input\n",
    "len(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The 'type()' function takes an expression and outputs the expression's type (string, integer, etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(2) # Notice that 2 is a numerical expression, but is in particular an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(2.09) # The numerical expression 2.09 is \"float\" type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(numpy.array([1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"str()\" is a function which converts a numerical expression to a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str(12345)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can be composed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(str(123))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Integers can be converted to floating point expressions via \"float()\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float('abc') # We can't convert strings to floats."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Determine the appropriate inputs for the following functions, and what the functions do.\n",
    "\n",
    "`abs()`\n",
    "\n",
    "`min()`\n",
    "\n",
    "`sum()`\n",
    "\n",
    "`sorted()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining functions\n",
    "\n",
    "We will see many more examples of built-in functions below. Before that, we should discuss the real power of learning a programming language: the ability to define your own functions! \n",
    "\n",
    "The syntax that is used to define a function is illustrated below.\n",
    "\n",
    "We point out the important parts of the syntax in the comments.\n",
    "\n",
    "This tells us that we define a function named `square` with a single input `x`. The function returns the input times itself. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(x): # Functions are always defined with 'def function_name(inputs):' The colon at the end is required!\n",
    "    return x*x\n",
    "# Python code is organized by tab indents. The indent in the function definition is required!\n",
    "# The output of the function is given by 'return function_output'. A return line is required!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "square(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "square(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can define functions which take/return any combination of expression(s)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_punctuation(string,punctuation_mark): # Descriptive function names are highly recommended.\n",
    "    return string+punctuation_mark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add_punctuation('Hello','!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add_punctuation(123,'.') # This will give an error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function Naming and Style \n",
    "\n",
    "As you create more complex code, it becomes increasingly important to make your code readable and well-commented. \n",
    "\n",
    "Note that in the above function definition, we used descriptive names for the function and the inputs. There are certain styles that are generally accepted for naming functions. \n",
    "\n",
    "Other acceptable names for this function would be 'AddPunctuation' or 'addPunctuation'.\n",
    "\n",
    "A BAD name for the function would be something like 'ap' or 'F', just because these are not descriptive at all.\n",
    "\n",
    "General naming conventions in Python can be found here: https://www.python.org/dev/peps/pep-0008/#naming-conventions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "Define a function 'digits()' which takes a positive integer and returns its number of digits. E.g., 'digits(321)' should return '3'. Use it to compute the number of digits in 2**1000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More Built-In Functions\n",
    "\n",
    "Let's now continue to explore some useful built-in functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions on lists\n",
    "\n",
    "Some functions have different syntax. For example, the 'append' function adds entries to lists as follows. Note that this syntax redefines the variable storing the list automatically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = ['a','b','c']\n",
    "L.append('d')\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The 'pop' function removes the last term from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L.pop()\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we include a positive integer argument in 'pop' then it removes the term at the indicated index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What does L.pop(k) do, where k is an integer? \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions on Strings\n",
    "\n",
    "There are many useful functions for string manipulation. Here are a few with the same sort of syntax as the list functions above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'CatDog'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a.lower()\n",
    "a, b # Notice that .lower() doesn't change the contents of a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a.upper()\n",
    "a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a.replace('Cat','Dog')\n",
    "a, b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions in the math package\n",
    "Other basic numerical operations are not included in basic Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get access to these operations, we can import a package. In this case, we use the \"math\" package. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use a function in the math package, we use the syntax \"math.function()\". This tells Python to use the function \"function\" from the package \"math\". For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "math.log(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will import packages frequently. Here are some tricks which are commonly used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as ma # Use an abbreviation for the imported package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma.sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma.log(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import specific functions from a package. We can abbreviate the function names if we want"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sqrt(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can be composed (as long as inputs/outputs make sense). Let's compose sqrt with our squaring function above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sqrt(square(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "square(sqrt(2)) # Here we see the numerical error in the square root function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions in the numpy Package\n",
    "Let's import numpy with an abbreviation. Common packages have \"standard\" abbreviations. That is, if you look at someone else's code, you will frequently see numpy imported as \"np\". "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.array([[1,2,3],[4,5,6]])\n",
    "Y = np.array([[1,0],[1,1],[0,1]])\n",
    "print(X)\n",
    "print(Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basically any standard operation from linear algebra is implemented in numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Z = np.transpose(Y) # Transpose of a matrix\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.linalg.det(X@Y) \n",
    "# Determinant of a (square) matrix. \n",
    "# Note that we call the determinant function from 'linalg'.\n",
    "# This is a subcollection of functions (called a 'module') in the numpy package."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals\n",
    "We can write more interesting functions using conditionals. The output of the function can depend on whether or not a given condition holds. The syntax of a conditional is demonstrated by the following example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_this_a_string(x):\n",
    "    if type(x) == str:       # Notice the double equals and the colon\n",
    "        return 'Yes'\n",
    "    else:                  # Colon appears here too\n",
    "        return 'No'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "is_this_a_string(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "is_this_a_string('abc')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several conditional expressions which can be used in an 'if' statement, such as <, != (not equal) or 'in'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contains_exclamation_point(string):\n",
    "    if '!' in string:\n",
    "        return 'Yes'\n",
    "    else:\n",
    "        return 'No'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contains_exclamation_point('abc!DD819')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contains_exclamation_point('abdcd0987')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditionals can involve multiple conditions by using \"elif\", which means \"else, if\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sign(x):  # Input is a float\n",
    "    if x < 0:\n",
    "        return 'The number '+str(x)+' is negative'\n",
    "    elif x>0:\n",
    "        return 'The number '+str(x)+' is positive'\n",
    "    else:\n",
    "        return 'The number '+str(x)+' is neither positive nor negative'  \n",
    "    # In the last step we just use \"else\", since all other possibilities have been ruled out. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sign(-100))\n",
    "print(sign(234.234))\n",
    "print(sign(0.00))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditionals can be nested, and we can use combinations of conditions linked by logical connectors ('or', 'and', 'if', 'not', etc). The next function illustrates these ideas. The function takes a number and decides whether it lies between zero and one. We also create a custom error message if the user inputs something which isn't a number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_between_zero_and_one(x):\n",
    "    if type(x)==int or type(x)==float: # First conditional checks whether input makes sense\n",
    "        if x > 0 and x < 1: # For a correct input, check whether it lies in the interval\n",
    "            return 'Yes'\n",
    "        else:\n",
    "            return 'No'\n",
    "    else:\n",
    "        return 'Must enter a number!'\n",
    "\n",
    "# Note that the nested conditionals are indented according to their level of nesting. This is required!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(is_between_zero_and_one(0))\n",
    "print(is_between_zero_and_one(0.1))\n",
    "print(is_between_zero_and_one(0.99999))\n",
    "print(is_between_zero_and_one(100))\n",
    "print(is_between_zero_and_one('a'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Write a function 'punctuation_check' which takes a string and returns the appropriate message:\n",
    "\n",
    "\"Contains exclamation point.\"\n",
    "\n",
    "\"Contains question mark.\"\n",
    "\n",
    "\"Contains both.\"\n",
    "\n",
    "\"Contains neither.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "Loops are an essential part of programming. They allow you to tell the computer to perform an operation repeatedly. The number of times to repeat the operation can be given specifically by a \"for loop\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First define a function to iterate in the 'for loop'\n",
    "def collatz(n):\n",
    "    if n % 2 == 0:\n",
    "        return n//2\n",
    "    else:\n",
    "        return 3*n + 1\n",
    "\n",
    "k = 17; # We initialize some value of k\n",
    "for i in range(0,20): # \"range\" is a function which produces a list containing the integers within the specified range\n",
    "    print(i, k) \n",
    "    k = collatz(k)\n",
    "# Each iteration of this for loop prints the pair (i,k) then updates k. \n",
    "# The iteration is performed for i = 0,1,2,...,19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rerun the 'for loop' above with different seeds k. Do you notice any pattern emerging?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some more basic examples of things you can do with for loops are shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will compute 1 + 2 + ... + 10\n",
    "\n",
    "sum = 0\n",
    "for i in range(1,11):\n",
    "    sum = sum + i\n",
    "sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will invest money at 3% interest for 10 years:\n",
    "\n",
    "sum = 100\n",
    "for i in range(0,11):\n",
    "    print(i, sum)\n",
    "    sum = 1.03*sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's compute the sum of the first n terms of the harmonic series\n",
    "# 1 + 1/2 + 1/3 + ... + 1/n\n",
    "\n",
    "sum = 0\n",
    "for n in range(1,100):\n",
    "    sum = sum + 1.0/n\n",
    "sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many other forms of conditional expressions and ways to iterate 'for loops'. Try experimenting with different options."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = ['cat','dog','bird','fish']\n",
    "M = ['dog','fish']\n",
    "\n",
    "for word in L:\n",
    "    if word not in M:\n",
    "        print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Define a function called 'uniquefy' which takes a list and removes all repeated entries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Define a function called 'isUnique' which takes a list and returns 'True' if the list contains no repeated entries and 'False' otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While Loops\n",
    "You can also tell Python to iterate an operation until a stopping condition is met. This is called a \"while loop\". Before you run a while loop, make sure that the stopping condition will actually be met! Otherwise you might cause your computer to crash."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's find out how many terms we need in the harmonic series to get sum >= 10.\n",
    "n = 1\n",
    "sum = 0\n",
    "while sum < 10:\n",
    "    sum = sum + 1.0/n\n",
    "    n = n + 1\n",
    "\n",
    "n-1 \n",
    "# The term we want is actually n-1. \n",
    "# This is because n iterates one last time before the while loop terminates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could make a list of terms of this form. The result agrees with the following entry in the Online Encyclopedia of Integer Sequences https://oeis.org/search?q=1%2C4%2C11%2C31%2C83&sort=&language=english&go=Search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = []\n",
    "for k in range(1,16):\n",
    "    sum = 0\n",
    "    n = 1\n",
    "    while sum < k:\n",
    "        sum = sum + 1.0/n\n",
    "        n = n + 1\n",
    "    L.append(n-1)\n",
    "\n",
    "L  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eventually the computation will start to take a long time. If you want to interrupt a computation in a Jupyter notebook, select 'Interrupt' from the 'Kernel' menu above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If you evaluate this cell, you may want to interrupt the computation!\n",
    "n = 1\n",
    "sum = 0\n",
    "while sum < 19:\n",
    "    sum = sum + 1.0/n\n",
    "    n = n + 1\n",
    "\n",
    "n-1\n",
    "\n",
    "# The answer is 100210581."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's find out how long it takes to pay off a loan:\n",
    "import math \n",
    "balance = 5000.00\n",
    "annual_rate = 0.09\n",
    "monthly_rate = math.exp(math.log(1 + annual_rate)/12.0) - 1\n",
    "monthly_factor = 1 + monthly_rate\n",
    "monthly_payment = 150\n",
    "month = 0\n",
    "\n",
    "print(\"Monthly rate: \" + str(monthly_rate))\n",
    "\n",
    "while balance > 0:\n",
    "    print(str(month)+': '+str(balance))\n",
    "    balance = monthly_factor*balance - monthly_payment\n",
    "    month = month + 1\n",
    "    \n",
    "print(str(month) + \" months to pay off your loan\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could define a function to perform the previous calculation for different parameters. We define our function to take in a loan balance, monthly payment and annual percentage rate. For the output, let's supress the monthly balances and just print the total amount of time to repay the loan.\n",
    "\n",
    "Notice in the function definition, we write annual_rate=0.09. When evaluating the function, if we don't specify an annual rate then the function assumes the rate of 0.09."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loan_repayment_time(balance,monthly_payment,annual_rate=0.09):\n",
    "    monthly_rate = math.exp(math.log(1 + annual_rate)/12.0) - 1\n",
    "    monthly_factor = 1 + monthly_rate\n",
    "    month = 0\n",
    "    while balance > 0:\n",
    "        balance = monthly_factor*balance - monthly_payment\n",
    "        month = month + 1\n",
    "\n",
    "    return month  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now test our function for various inputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(loan_repayment_time(5000,150)) # In this example, annual rate is taken as the default 9%\n",
    "print(loan_repayment_time(4000,46.86,0.15))\n",
    "# In the second example, the first monthly interest amount is $4000*0.15 ~ $46.8596.\n",
    "# If the monthly payment is less than this, then the loan will never be repaid. \n",
    "# In this case, the while loop will never terminate. \n",
    "# To stop the calculation, hit the stop button in the menu above!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Some implementations of a function are better than others! The 'loan_repayment_time' function above has a major issue in that it may never terminate. Write a better version of this function, which will never get stuck in an infinite while loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}