18-WrapUp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Wrap Up\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Some (extra) Python\n",
    "\n",
    "- string formatting (`format`)\n",
    "- sets\n",
    "- `collections`\n",
    "- args & kwargs\n",
    "- list comprehensions\n",
    "- map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "...or: a day of shortcuts\n",
    "\n",
    "Note: Shortcuts make *your* life easier, but your code *less* understandable to beginners."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "It's hard to search for things you don't know exist.\n",
    "\n",
    "Today's goal : let you know these things exist.\n",
    "\n",
    "NOT today's goal : teach you all the details."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "You do *not* need to incorporate these into your project, but if they'll help you, go for it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import antigravity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## String Formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Use the `format` method to manipulate and format strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "name = \"Eric\"\n",
    "job = \"Lecturer\"\n",
    "topic = \"Python\"\n",
    "\n",
    "\"Hello! My name is {}. My job is {}, and I work on {}\".format(name, job, topic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sets "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Sets are a variable type that store **only unique entries**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_set = set([1, 1, 2, 3, 4])\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Like lists, they are iterable & mutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_set.add(2)\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Reminder that if you add a value that is already in the set...the set will not change"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Collections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `collections` module has a number of useful variable types, with special properties. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "These are \"special editions\" of collections we've discussed before (lists, tuples, and dictionaries)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# count how many elements there are in collection\n",
    "# return values in a dictionary\n",
    "Counter([1, 0, 1, 2, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "collections.Counter([1, 0, 1, 2, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# can count how many of each letter are in there\n",
    "Counter(\"I wonder how many times I use the letter 'e'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Think back to our encryption scheme! \n",
    "\n",
    "The most common letter in the English language is 'e'.\n",
    "\n",
    "If you just move each letter over by 1 position, you can just use a Counter to crack the code.\n",
    "\n",
    "Why we moved to a variable encoder!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `args` & `kwargs`\n",
    "\n",
    "- allow you to pass a variable number of arguments to a function\n",
    "    - `*args` - allow any number of extra arguments (including zero)\n",
    "    - `**kwargs` - allow any number of *keyword* arguments to be passed (as a dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### `*args`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# use *arguments to demonstrate args\n",
    "def tell_audience(*arguments):\n",
    "    for arg in arguments:\n",
    "        print(arg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tell_audience('asdf', 'hello', 'bleargh')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "tell_audience(\"Hello!\", \n",
    "              \"My name is Eric.\", \n",
    "              \"My job is Lecturer.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### `**kwargs`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def tell_audience_kwargs(**info):\n",
    "    print(\"type: \", type(info), '\\n')\n",
    "    \n",
    "    for key, value in info.items():\n",
    "        print(\"key: \", key)\n",
    "        print(\"value: \", value, \"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "tell_audience_kwargs(first='Eric', \n",
    "                     last='Morgan', \n",
    "                     email='e1morgan@ucsd.edu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "List comprehensions allow you to run loops and conditionals, *inside lists*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The general format is :\n",
    "\n",
    "`[ expression for item in list if conditional ]`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# NOT a list comprehension\n",
    "# how we've been doing it\n",
    "input_list = [0, 1, 2]\n",
    "output_list = []\n",
    "\n",
    "for ind in input_list:\n",
    "    output_list.append(ind + 1)\n",
    "    \n",
    "# look at output\n",
    "output_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# This list comprehension is equivalent to the cell above\n",
    "# note the square brackets on the outside\n",
    "[ind + 1 for ind in [0, 1, 2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# You can also include conditionals inside a list comprehension\n",
    "[val for val in [1, 2, 3, 4, 5] if val % 2 == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Note: there are also tuple & dictionary comprehensions. They're just used less frequently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Regular Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Regular expressions allow you to work with **specified patterns in strings**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_string = \"If 12 Python programmers try to complete 14 tasks in 16 minutes, why?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# can just search for a letter - note that the 'r' in front of the string \n",
    "# changes it to a \"raw string literal\", needed to avoid complaints by re when using backslashes\n",
    "re.findall(r'o', my_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# but the patterns are where these shine\n",
    "re.findall(r'\\d\\d', my_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lambda Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Lambda functions are small, anonymous functions. \n",
    "\n",
    "Can define them in line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "increment = lambda a: a + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "increment(56)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# not a lambda function\n",
    "def lambda_equivalent(a):\n",
    "    \n",
    "    output = a + 1\n",
    "    \n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "lambda_equivalent(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example - here we are trying to sort a list of pairs by the second value in the pair:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def find_key(x):\n",
    "    return x[1]\n",
    "\n",
    "a = [(1, 7), (4, 2), (3, 8), (1, 5)]\n",
    "a.sort(key=find_key)\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = [(1, 7), (4, 2), (3, 8), (1, 5)]\n",
    "a.sort(key=lambda x: x[1])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`map` applies a given function to each element in a collection. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# create a function\n",
    "def double_it(val):\n",
    "    return val * 2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# map function to each element of list\n",
    "my_list = [1, 2, 3, 4]\n",
    "list(map(double_it, my_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# the above example is equivalent to:\n",
    "new_list = []\n",
    "for item in my_list:\n",
    "    new_list.append(double_it(item))\n",
    "    \n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Note - we can use lambda functions with map|\n",
    "list(map(lambda x: x *2, my_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python file operations:\n",
    "\n",
    "### Opening a file:\n",
    "\n",
    "`with open('workfile', 'r+', encoding=\"utf-8\") as f:\n",
    "    line = f.readline()`\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "filepath = '../temp/'\n",
    "filename = 'myniftyfile.txt'\n",
    "\n",
    "with open(filepath + filename, 'r+', encoding=\"utf-8\") as f:\n",
    "    for line in f:\n",
    "        print(line)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "open?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "line = 'blahblah,stuff\\n'\n",
    "line = line.rstrip()\n",
    "line = line.split(',')\n",
    "print(line)\n",
    "line[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Other file-related terms:\n",
    "- JSON: file format for transferring typical datatypes between programs and/or saving data in a standardized way\n",
    "- Pickle: Python-based method for storing complex python objects into files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Goal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To teach you a skill - of how to do things with Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "You've been more formally trained than *many* people out in the world programming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Where We've Been:\n",
    "\n",
    "- Python & Jupyter\n",
    "- Variables\n",
    "- Operators\n",
    "- Conditionals\n",
    "- Functions\n",
    "- Lists, Tuples & Dictionaries\n",
    "- Loops\n",
    "- Objects & Classes\n",
    "- Command Line\n",
    "- Scientific Computing\n",
    "- Documentation, Code Style, Code Testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Class Question #1\n",
    "\n",
    "After COGS 18, I feel \\_\\_\\_\\_\\_\\_\\_\\_\\_\\_\\_\\_ my Python programming abilities\n",
    "\n",
    "- A) very confident in\n",
    "- B) somewhat confident in\n",
    "- C) middle-of-the-road about\n",
    "- D) somewhat unsure about\n",
    "- E) very unsure about\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Class Question #2\n",
    "\n",
    "After COGS 18, I feel the following about my future Python programming:\n",
    "\n",
    "- A) will use again for sure\n",
    "- B) may use again\n",
    "- C) unsure if will use again\n",
    "- D) probably won't use again\n",
    "- E) definitely won't use again\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## How to Continue with Coding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Write Code\n",
    "- Read Code\n",
    "- Learn and follow standard procedures\n",
    "- Do code reviews\n",
    "- Interact with the community\n",
    "- Build a code portfolio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Powered by Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This course used:\n",
    "- Python Programming Language\n",
    "- Jupyter Notebooks\n",
    "- RISE Jupyter Slides\n",
    "- nbgrader\n",
    "- Jupyter Book\n",
    "- scipy stack & many other 3rd party modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Where do you go from here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- if want_more_data_science:\n",
    "    - go to COGS 9\n",
    "- if you want *to do* more_data_science:\n",
    "    - ...*and* Python: take COGS 108\n",
    "    - ...*and* R: take COGS 137\n",
    "- if interested_in_research:\n",
    "    - look for labs, tell them you can code\n",
    "- if you want_something_else:\n",
    "    - go do it!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Acknowledgments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Thank you to Tom for his original design of this course, and Shannon for her work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Thank you to the TAs and IAs for their tireless work on this class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Thank you students for you time, effort and patience. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><h1> The End "
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.12.5"
  },
  "rise": {
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}