Lecture_02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lecture 2\n",
    "\n",
    "### Learning Objectives\n",
    "\n",
    "- Learn  about variables.\n",
    "- Learn about the variable types: integers (`int`); numbers (`float`); booleans (`bool`) and strings (`str`).\n",
    "- Learn about operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables\n",
    "Computer programs need to pass numbers around, manipulate them, save them and so on.  This is done by assigning values to variables ('Let x equal 2'). There are many variable types in Python, including: \n",
    "\n",
    "- integer (a number without a decimal),\n",
    "- floating point (a number with a decimal),\n",
    "- string (numbers and/or letters enclosed in quotation marks),\n",
    "- complex numbers, \n",
    "- booleans (`True` or `False`).  \n",
    "\n",
    "Before you can use a variable, it must be defined.   The following code block shows  how to define  variables in Python.  Click on the code block, then click on 'Run' in the above menu, to make these variables known.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remember that Python ignores everything on a line after a pound sign (#)\n",
    "# this is how you write \"comments\" in Python\n",
    "number = 1 # An integer\n",
    "Number = 1.0 # A floating point - notice the decimal point\n",
    "NUMBER = '1' # A string - notice the quotation marks\n",
    "ANOTHER_NUMBER = \"1\" # Double quotes are also ok\n",
    "comp = 1j # A complex number with imaginary part 1 \n",
    "more_complex = 3 + 1j # A complex number 3+1i \n",
    "python_is_aweseome = True # A boolean variable (True/False or 1/0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see what value has been assigned to a  variable, simply type: `print` and then the variable name in parentheses.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'another' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-2-00a3143c8ca0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumber\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0manother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'another' is not defined"
     ]
    }
   ],
   "source": [
    "print(number)\n",
    "print(another)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aha! a bug - Python didn't know what `another` was because we never defined it.  How would you fix this bug?  \n",
    "\n",
    "If you want to make `another` a variable you can do this: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "another number\n"
     ]
    }
   ],
   "source": [
    "another = 'another number'\n",
    "print(another)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variable Naming Restrictions\n",
    "\n",
    "1. Variable names are composed of alpha-numeric characters (A-z, 0-9) and the underscore ('\\_') character.\n",
    "\n",
    "2. Python (and thus variable names) are case sensitive: 'a' is not the same as 'A'.\n",
    "\n",
    "3. A variable name must start with a letter or an underscore. A variable name cannot start with a number.\n",
    "\n",
    "4. There are some _reserved keywords_ in Python (Python 3.6 defines 33 reserved keywords) that you are not allowed to use as a variable names because they have pre-defined meanings (for example,  `False` or `True`)\n",
    "\n",
    "Here is a list of reserved words: \n",
    "\n",
    "```python\n",
    "False    def     if       raise\n",
    "None     del     import   return\n",
    "True     elif    in       try\n",
    "and      else    is       while\n",
    "as       except  lambda   with\n",
    "assert   finally nonlocal yield\n",
    "break    for     not\n",
    "class    from    or\n",
    "continue global  pass\n",
    "```\n",
    "\n",
    "\n",
    "#### Variable Naming Guidelines\n",
    "\n",
    "There is a lot of leeway in choosing variable names in Python, but there are some guidelines and \"best practices\". \n",
    "Here are some tips about variable names:  \n",
    "\n",
    "_1. Do not use a variable which matches the name of built-in Python function._\n",
    "\n",
    "The language will let you do it, but it will come back to haunt you later with an unexpected (and annoying) error when you run your code.\n",
    "Below are some commonly-used Python functions which you should avoid as variable names:\n",
    "```python\n",
    "abs()    all()     any()    array() ascii()\n",
    "bool()   complex() dir()    eval()  exec()\n",
    "filter() float()   format() help()  id() \n",
    "input()  int()     len()    map()   max() \n",
    "min()    next()    object() pow()   print()\n",
    "open()   range()   set()    slice() sum() \n",
    "super()  type()    vars()\n",
    "```\n",
    "You should also avoid all names defined in commonly-used Python modules / libraries like: \n",
    "```python\n",
    "acos() asin()  atan() exp()\n",
    "fabs() floor() log()  log10()\n",
    "sin()  cos()   tan()  sqrt()\n",
    "pi e\n",
    "```\n",
    "\n",
    "_2. Use expressive words_ \n",
    "\n",
    "In general, longer more descriptive (expressive) words are better because they'll remind you what the variable stores (i.e. represents). \n",
    "\n",
    "_3. Utilize the Python standard for naming \"things\"_\n",
    "\n",
    "The Python community has a well established set of \"best practices\" for variable names, documented here\n",
    "\n",
    "https://www.python.org/dev/peps/pep-0008/#naming-conventions\n",
    "\n",
    "Learning these guideline (and adhering to them) will help you to more rapidly ingest Python code written by other people. \n",
    "\n",
    "Here are some popular choices recommended:  \n",
    "\n",
    "Use these lower case options for variables:\n",
    "- `lowercase`  \n",
    "- `lower_case_with_underscores`  \n",
    "- `mixedCase` \n",
    "\n",
    "Use these upper case options for constants:\n",
    "- `UPPERCASE`  \n",
    "- `UPPER_CASE_WITH_UNDERSCORES`\n",
    "\n",
    "Other options:\n",
    "- `CapitalizedWords` (or CapWords, or CamelCase -- so named because of the bumpy look of its letters). This is also sometimes known as StudlyCaps. - this style should be used for _classes_ which we will learn about later.  \n",
    "\n",
    "- `Capitalized_Words_With_Underscores`: Please do not use this style it is hard to read.\n",
    "\n",
    "Final pieces of advice:\n",
    "\n",
    "- Don't use characters 'l' (lowercase letter el), 'O' (uppercase letter oh), or 'I' (uppercase letter eye) as single character variable names. These are easily confused in some fonts with '1' (one), '0' (zero), for example.  If you really want a letter 'el', use 'L'.  \n",
    "\n",
    "- Don't use non-standard symbols like $^{\\circ}$ or $\\sim$.  \n",
    "\n",
    "- Be careful with special names that use leading or trailing underscores.  these are treated differently by Python and you have to know what you are doing before you use them.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operations\n",
    "\n",
    "Variables are lovely, but not very useful if we can't DO anything with them.  We use different _operations_ to manipulate variables. For example, addition, subtraction, etc.  \n",
    "\n",
    "|operation symbol|\tfunction\t|\n",
    "|----|-----|\n",
    "| `+`\t|addition |\n",
    "| `-` | subtraction |\n",
    "| `*` |  multiplication |\n",
    "| `/` | division |\n",
    "|  `%` | gives the remainder (this is called _modulo_) |\n",
    "| `**` | raise to a power|\n",
    "| `+=` | increment |\n",
    "| `-=` | decrement |\n",
    "| `==`  | test equality |\n",
    "| `!=` | test inequality |\n",
    "\n",
    "Parentheses determine order of operation.  Use lots of them.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Let's try using some operations on our variables. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number + number  # adding two integers produces an integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TIP:** One interesting tidbit here - if the LAST statement in the code block is not assigned to a variable, then your notebook will print the outcome.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number + number\n",
    "number + number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we could have also written it this way, to print out both statements: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(number + number)\n",
    "print(number + number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Moving on.... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "print(number + Number) # adding an integer and a float makes a float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usually Python is pretty clever about figuring out what type is required (in the case above, it is a float).  But you must be careful.  In Python 2.7 (version from a few years ago), if you multiply a float by an integer, you could convert the float to an integer when what you really wanted was a float! This seems to have been resolved in Python 3 (current version).  But to be sure,   if you want a float, use a decimal point.  Also in Python 3, division of two integers gives you a float, whereas in Python 2, it gave an integer.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "print(NUMBER + NUMBER) # adding two strings concatenates the strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-eaa027251ac3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumber\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mNUMBER\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# adding a number to a string makes python mad!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "print(number + NUMBER) # adding a number to a string makes python mad!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lesson learned: you can't add a number and a string. The types of the variables define what operations can be performed. You can influence the outcome (and possible success) of an operation by converting variable types using the built-in functions: `int(arg)`, `float(arg)`, and `str(arg)`. These will attempt to convert `arg` to an integer, floating point number, and string respectively. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0 1\n"
     ]
    }
   ],
   "source": [
    "print(Number, int(Number)) # makes an integer out of the floating point\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or you can go the other way by turning an integer into a float:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1.0\n"
     ]
    }
   ],
   "source": [
    "print(number, float(number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can turn a number (float or integer) into a string variable with the function `str()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1\n"
     ]
    }
   ],
   "source": [
    "print(number, str(number)) # makes a string out of the integer variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also turn (some) strings into floats, for example this is valid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33.3\n"
     ]
    }
   ],
   "source": [
    "my_string_value = \"33.3\"\n",
    "print(float(my_string_value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However you cannot convert any string into a number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "could not convert string to float: 'convert this'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-9efa7ade919e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmy_text\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"convert this\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_text\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: could not convert string to float: 'convert this'"
     ]
    }
   ],
   "source": [
    "my_text = \"convert this\"\n",
    "print(float(my_text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may have noticed that when printing string and integer variables the result looked the same. To \"see\" what the variable \"really\" is, try using the `repr()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 '1' '1' 1.0\n"
     ]
    }
   ],
   "source": [
    "print(repr(number), repr(str(number)), repr(NUMBER), repr(float(NUMBER)))\n",
    "# prints the representation of the variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We already mentioned another kind of variable called _boolean_. In Python these assume the type `bool`. The only valid value you can assign to a boolean is either `True` or `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_is_flexible = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Booleans have many uses but in particular can be used to control the flow of the program as we shall learn later.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TIP:  A really handy feature of Python is the built in `help()` function.  So if you see a function you aren't familiar with, you can look up what it does using `help()`.  For example, we just learned the function `repr()` but you might not know all it's features yet.  No worries!  Just call for `help()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function repr in module builtins:\n",
      "\n",
      "repr(obj, /)\n",
      "    Return the canonical string representation of the object.\n",
      "    \n",
      "    For many object types, including most builtins, eval(repr(obj)) == obj.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(repr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are other ways to get help.  One useful way is to type the command (or variable or other Python objects) with a question mark at the end:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "repr?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two question marks returns the actual code too, unless it is a compiled bit (as for repr??).   \n",
    "\n",
    "Note that $<$TAB$>$ is an autocompletion tool, so if (you do not know the exact name, but you know how it starts $<$TAB$>$ is your friend.  \n",
    "    \n",
    " Finally, an asterisk (*) will act as a wild card"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String operations\n",
    "\n",
    "Numbers are numbers. While there are more types of numbers (complex, etc.),\n",
    "strings are also interesting. They can be denoted with single, double or triple quotes: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spam\n"
     ]
    }
   ],
   "source": [
    "string1 = 'spam'\n",
    "print(string1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sam's spam\n"
     ]
    }
   ],
   "source": [
    "string2 = \"Sam's spam\"\n",
    "print(string2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  \n",
      "Hi there I can type as\n",
      "many lines as I want\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"\"\"  \n",
    "Hi there I can type as\n",
    "many lines as I want\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Strings can be added together: \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spamalot\n"
     ]
    }
   ],
   "source": [
    "newstring = 'spam' + 'alot'\n",
    "print(newstring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "They  can be sliced:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spa\n"
     ]
    }
   ],
   "source": [
    "newerstring = newstring[0:3]\n",
    "print(newerstring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the slice was from the first index (number 0) up to but NOT INCLUDING the last index (3), so it took elements 0, 1 and 2 but not 3. \n",
    "\n",
    "Strings CANNOT be changed in place: \n",
    "\n",
    "That means, you can't do this: \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-d56ace4745c0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnewstring\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'b'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "newstring[0] = 'b'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yup, that made Python mad.  \n",
    "\n",
    "\n",
    "To find more of the things you can and cannot do to strings, see: http://docs.python.org/tutorial/introduction.html#strings\n",
    "\n",
    "\n",
    "If you looked at it, you can see where the spam references came from. :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's play with some variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "b = 2\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "c = a + b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will recognize $a, b,$ and $c$ in the above session as _variables_ and $+$ as an _operation_.   And these examples are pretty straight-forward  math operations.  \n",
    "\n",
    "But programming operations are not the same as arithmetic ones. For example, this statement would get you flunked out of 5th grade, but it is perfectly acceptable in Python: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c = 4\n",
      "now c is: 5\n"
     ]
    }
   ],
   "source": [
    "print('c =', c)\n",
    "c = c + 1\n",
    "print('now c is:', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The trick here is that the right hand side gets evaluated first, then assigned to the left hand side.  \n",
    "\n",
    "And here is another funny looking statement, which is also perfectly valid (and does the same thing as c=c+1).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "now c is: 6\n"
     ]
    }
   ],
   "source": [
    "c += 1\n",
    "print('now c is:', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Until now we have defined variables one by one each on its own line.  But there is a more compact way to do this. In fact, we can combine any number of statements on a single line by separating them with semi-colons:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 2 4\n"
     ]
    }
   ],
   "source": [
    "a = 2; b = 2; c = a + b; c\n",
    "print(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here is another way to do the exact same thing: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 5 6\n"
     ]
    }
   ],
   "source": [
    "d, e, f = 4, 5, 6 \n",
    "print(d, e, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking the type of any Python variable\n",
    "\n",
    "The function `repr()` is useful, but sometimes not explicit enough, or easy to misread if you are not careful. To know with absolute certainty what the type of variable is, you can use the built-in function `type()`. Let's try it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "python_is_cool = True\n",
    "print(type(python_is_cool))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "my_integer = 66\n",
    "print(type(my_integer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "my_number = 33.3\n",
    "print(type(my_number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "my_string = \"Lecture 2 is nearly done\"\n",
    "print(type(my_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that is impossible to misinterpret. We will learn what the `class` keyword is in a later lecture."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now open your Practice Problem notebook for Lecture 2 and complete the exercises.\n",
    "Remember that programming is not a spectator sport - you only learn how to do it by doing it for yourself!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "1. Complete list of Python built-in functions: https://docs.python.org/3/library/functions.html\n",
    "2. Python naming conventions: https://www.python.org/dev/peps/pep-0008/#naming-conventions\n",
    "3. Everything you want to know about Python's string object: http://docs.python.org/tutorial/introduction.html#strings\n"
   ]
  }
 ],
 "metadata": {
  "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}