Python-01-Intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python for Absolute Beginners\n",
    "## Version check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python -V #The latest version is 3.7.0 (Release Date: 2018-06-27)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 6       ## set a variable in this interpreter session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'hi'    ## 'a' can hold a string just as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(a)      ## call the len() function on a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a + len(a) ## try something that doesn't work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a + str(len(a)) ## probably what you really wanted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo         ## try something else that doesn't work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'hi'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s[1])          ## ?\n",
    "print(len(s))        ## ?\n",
    "print(s + ' there')  ## ??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi = 3.14\n",
    "##text = 'The value of pi is ' + pi      ## NO, does not work\n",
    "text = 'The value of pi is '  + str(pi)  ## yes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Karl'\n",
    "with_quote = \"I ain't gonna\"\n",
    "longer = \"\"\"This string has been\n",
    "    multiple line\n",
    "    in it.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with_quote"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "longer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Quiz. How Do I Print?\n",
    "\n",
    "- He said, \"I'm sorry\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('He said, \"I\\'m sorry\"')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('''He said, \"I'm sorry\"''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"\"\"He said, \"I'm sorry\\\"\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Slices\n",
    "The \"slice\" syntax is a handy way to refer to sub-parts of sequences -- typically strings and lists. The slice s[start:end] is the elements beginning at start and extending up to but not including end. Suppose we have s = \"Hello\"\n",
    "![alt text](https://developers.google.com/edu/python/images/hello.png)\n",
    "\n",
    "- s[1:4] is 'ell' -- chars starting at index 1 and extending up to but not including index 4\n",
    "- s[1:] is 'ello' -- omitting either index defaults to the start or end of the string\n",
    "- s[:] is 'Hello' -- omitting both always gives us a copy of the whole thing (this is the pythonic way to copy a sequence like a string or list)\n",
    "- s[1:100] is 'ello' -- an index that is too big is truncated down to the string length\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Hello'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-5:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic string exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(got, expected):\n",
    "  if got == expected:\n",
    "    prefix = ' OK '\n",
    "  else:\n",
    "    prefix = '  X '\n",
    "  print('%s got: %s expected: %s' % (prefix, repr(got), repr(expected)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A. donuts\n",
    "# Given an int count of a number of donuts, return a string\n",
    "# of the form 'Number of donuts: <count>', where <count> is the number\n",
    "# passed in. However, if the count is 10 or more, then use the word 'many'\n",
    "# instead of the actual count.\n",
    "# So donuts(5) returns 'Number of donuts: 5'\n",
    "# and donuts(23) returns 'Number of donuts: many'\n",
    "def donuts(count):\n",
    "  # +++your code here+++%%\n",
    "  if count < 10:\n",
    "    return 'Number of donuts: ' + str(count)\n",
    "  else:\n",
    "    return 'Number of donuts: many'\n",
    "\n",
    "test(donuts(4), 'Number of donuts: 4')\n",
    "test(donuts(9), 'Number of donuts: 9')\n",
    "test(donuts(10), 'Number of donuts: many')\n",
    "test(donuts(99), 'Number of donuts: many')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# B. both_ends\n",
    "# Given a string s, return a string made of the first 2\n",
    "# and the last 2 chars of the original string,\n",
    "# so 'spring' yields 'spng'. However, if the string length\n",
    "# is less than 2, return instead the empty string.\n",
    "def both_ends(s):\n",
    "  # +++your code here+++\n",
    "  if len(s) < 2:\n",
    "    return ''\n",
    "  first2 = s[0:2]\n",
    "  last2 = s[-2:]\n",
    "  return first2 + last2\n",
    "\n",
    "test(both_ends('spring'), 'spng')\n",
    "test(both_ends('Hello'), 'Helo')\n",
    "test(both_ends('a'), '')\n",
    "test(both_ends('xyz'), 'xyyz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given a string s, return a string\n",
    "# where all occurences of its first char have\n",
    "# been changed to '*', except do not change\n",
    "# the first char itself.\n",
    "# e.g. 'babble' yields 'ba**le'\n",
    "# Assume that the string is length 1 or more.\n",
    "# Hint: s.replace(stra, strb) returns a version of string s\n",
    "# where all instances of stra have been replaced by strb.\n",
    "def fix_start(s):\n",
    "  # +++your code here+++\n",
    "  front = s[0]\n",
    "  back = s[1:]\n",
    "  fixed_back = back.replace(front, '*')\n",
    "  return front + fixed_back\n",
    "\n",
    "test(fix_start('babble'), 'ba**le')\n",
    "test(fix_start('aardvark'), 'a*rdv*rk')\n",
    "test(fix_start('google'), 'goo*le')\n",
    "test(fix_start('donut'), 'donut')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given strings a and b, return a single string with a and b separated\n",
    "# by a space '<a> <b>', except swap the first 2 chars of each string.\n",
    "# e.g.\n",
    "#   'mix', pod' -> 'pox mid'\n",
    "#   'dog', 'dinner' -> 'dig donner'\n",
    "# Assume a and b are length 2 or more.\n",
    "def mix_up(a, b):\n",
    "  # +++your code here+++\n",
    "  a_swapped = b[:2] + a[2:]\n",
    "  b_swapped = a[:2] + b[2:]\n",
    "  return a_swapped + ' ' + b_swapped\n",
    "  \n",
    "test(mix_up('mix', 'pod'), 'pox mid')\n",
    "test(mix_up('dog', 'dinner'), 'dig donner')\n",
    "test(mix_up('gnash', 'sport'), 'spash gnort')\n",
    "test(mix_up('pezzy', 'firm'), 'fizzy perm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "Python has a great built-in list type named \"list\". List literals are written within square brackets [ ]. Lists work similarly to strings -- use the len() function and square brackets [ ] to access data, with the first element at index 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = ['red', 'blue', 'green']\n",
    "print(colors[0])    ## red\n",
    "print(colors[2])    ## green\n",
    "print(len(colors))  ## 3"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](https://developers.google.com/edu/python/images/list1.png)\n",
    "Assignment with an = on lists does not make a copy. Instead, assignment makes the two variables point to the one list in memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = colors   ## Does not copy the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](https://developers.google.com/edu/python/images/list2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b[1]= 'white'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors # changed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = [1, 4, 9, 16, 25]\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares[0]  # indexing returns the item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares[-3:]  # slicing returns a new list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares + [36, 49, 64, 81, 100] ## Lists also support operations like concatenation:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike strings, which are immutable, lists are a mutable type, i.e. it is possible to change their content:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cubes = [1, 8, 27, 65, 125]  # something's wrong here\n",
    "4 ** 3  # the cube of 4 is 64, not 65!\n",
    "\n",
    "cubes[3] = 64  # replace the wrong value\n",
    "cubes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also add new items at the end of the list, by using the append() method (we will see more about methods later):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cubes.append(216)  # add the cube of 6\n",
    "cubes.append(7 ** 3)  # and the cube of 7\n",
    "cubes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n",
    "letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# replace some values\n",
    "letters[2:5] = ['C', 'D', 'E']\n",
    "letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now remove them\n",
    "letters[2:5] = []\n",
    "letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# clear the list by replacing all the elements with an empty list\n",
    "letters[:] = []\n",
    "letters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic list exercises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A. match_ends\n",
    "# Given a list of strings, return the count of the number of\n",
    "# strings where the string length is 2 or more and the first\n",
    "# and last chars of the string are the same.\n",
    "# Note: python does not have a ++ operator, but += works.\n",
    "def match_ends(words):\n",
    "  # +++your code here+++\n",
    "  count = 0\n",
    "  for word in words:\n",
    "    if len(word) >= 2 and word[0] == word[-1]:\n",
    "      count = count + 1\n",
    "  return count\n",
    "\n",
    "test(match_ends(['aba', 'xyz', 'aa', 'x', 'bbb']), 3)\n",
    "test(match_ends(['', 'x', 'xy', 'xyx', 'xx']), 2)\n",
    "test(match_ends(['aaa', 'be', 'abc', 'hello']), 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sorting\n",
    "The easiest way to sort is with the sorted(list) function, which takes a list and returns a new list with those elements in sorted order. The original list is not changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [5, 1, 4, 3]\n",
    "print(sorted(a))  ## [1, 3, 4, 5]\n",
    "print(a)  ## [5, 1, 4, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "strs = ['aa', 'BB', 'zz', 'CC']\n",
    "print(sorted(strs))  ## ['BB', 'CC', 'aa', 'zz'] (case sensitive)\n",
    "print(sorted(strs, reverse=True))   ## ['zz', 'aa', 'CC', 'BB']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Dict and File\n",
    "#### Dict Hash Table\n",
    "Python's efficient key/value hash table structure is called a \"dict\". The contents of a dict can be written as a series of key:value pairs within braces { }, e.g. dict = {key1:value1, key2:value2, ... }. The \"empty dict\" is just an empty pair of curly braces {}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Can build up a dict by starting with the the empty dict {}\n",
    "## and storing key/value pairs into the dict like this:\n",
    "## dict[key] = value-for-that-key\n",
    "dict = {}\n",
    "dict['a'] = 'alpha'\n",
    "dict['g'] = 'gamma'\n",
    "dict['o'] = 'omega'\n",
    "dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dict['a'])     ## Simple lookup, returns 'alpha'\n",
    "dict['a'] = 6       ## Put new key/value into dict\n",
    "dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print dict['z']                  ## Throws KeyError\n",
    "# if 'z' in dict: print(dict['z'])     ## Avoid KeyError\n",
    "print(dict.get('z'))  ## None (instead of KeyError)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A for loop on a dictionary iterates over its keys by default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict = {}\n",
    "dict['a'] = 'alpha'\n",
    "dict['g'] = 'gamma'\n",
    "dict['o'] = 'omega'\n",
    "dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key in dict:\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Exactly the same as above\n",
    "for key in dict.keys():\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Get the .keys() list:\n",
    "dict.keys()  ## ['a', 'o', 'g']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Likewise, there's a .values() list of values\n",
    "dict.values()  ## ['alpha', 'omega', 'gamma']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Common case -- loop over the keys in sorted order,\n",
    "## accessing each key/value\n",
    "for key in sorted(dict.keys()):\n",
    "    print(key, dict[key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## .items() is the dict expressed as (key, value) tuples\n",
    "print(dict.items())  ##  [('a', 'alpha'), ('o', 'omega'), ('g', 'gamma')]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## This loop syntax accesses the whole dict by looping\n",
    "## over the .items() tuple list, accessing one (key, value)\n",
    "## pair on each iteration.\n",
    "for k, v in dict.items():\n",
    "    print (k, '>', v)\n",
    "## a > alpha    o > omega     g > gamma"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise Incremental Development (Optional)\n",
    "Building a Python program, don't write the whole thing in one step. Instead identify just a first milestone, e.g. \"well the first step is to extract the list of words.\" Write the code to get to that milestone, and just print your data structures at that point, and then you can do a sys.exit(0) so the program does not run ahead into its not-done parts. Once the milestone code is working, you can work on code for the next milestone. Being able to look at the printout of your variables at one state can help you think about how you need to transform those variables to get to the next state. Python is very quick with this pattern, allowing you to make a little change and run the program to see how it works. Take advantage of that quick turnaround to build your program in little steps.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}