01-Intro-to-Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction to Python "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "hide_input": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format='retina'\n",
    "# import libraries\n",
    "import numpy as np\n",
    "import matplotlib as mp\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from importlib import reload\n",
    "from datetime import datetime\n",
    "from IPython.display import Image\n",
    "from IPython.display import display_html\n",
    "from IPython.display import display\n",
    "from IPython.display import Math\n",
    "from IPython.display import Latex\n",
    "from IPython.display import HTML;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This chapter will not be covered in lecture.  It's here to refresh the memory of those who haven't used python in a while.  \n",
    "\n",
    "For those that don't know python -- but do know programming -- this chapter will give you an idea of how python is similar to, and different from, your favorite programming language.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## How do I run code?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "There are four ways to run python code:\n",
    "\n",
    "1. put your code in a file (say program.py) and run `python program.py`\n",
    " * This is __not a good idea__ when you are first writing your code\n",
    " * Later, once your code is debugged, this is the way to go"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "2. type your code into the python interpreter\n",
    " * This __can really help in debugging__ since you interact with the interpreter and fix mistakes as they happen\n",
    " * good for writing the first version of some new code\n",
    " * Later you can put the code in a file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "3. type in an IDE (Spyder, VStudio) or cut/paste your code in `ipython`\n",
    " * This is a good method if you __really__ use the IDE\n",
    " * learn how to use the debugger!\n",
    " * But otherwise it's not better than option 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "4. run `ipython` in a browser, using the system called `jupyter notebook`\n",
    " * This is even better\n",
    " * All the advantages of `ipython` plus interleaved documentation and graphical output\n",
    " * That is what these slides are written in"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions and Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Function calls use standard syntax:\n",
    "\n",
    "    func(argument1, argument2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "However most things you interact with in python are **objects** and they have **methods**.  A method is a function that operates on an object:\n",
    "\n",
    "    object.method(argument1, argument2)\n",
    "    \n",
    "Note that the method might modify the object, or it might return a new, different object.   You just have to know the method and keep track of what it does."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "number_list = [1, 3, 5, 7]\n",
    "number_list.append(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 8]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['This', 'is', 'a', 'string']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string = 'This is a string'\n",
    "string.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a string'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Printing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "From the interactive python environment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "From a file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "#!/usr/bin/env python\n",
    "\n",
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Basic data types:\n",
    "\n",
    "1. Strings\n",
    "2. Integers\n",
    "3. Floats\n",
    "4. Booleans\n",
    "\n",
    "These are all objects in Python. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 7\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 3\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = 3.2\n",
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = True\n",
    "type(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Python **doesn't require explicitly declared variable types** like C and other languages.  Python is dynamically typed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a string\n",
      "2.3\n"
     ]
    }
   ],
   "source": [
    "myVar = 'I am a string'\n",
    "print(myVar)\n",
    "myVar = 2.3\n",
    "print(myVar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "String manipulation will be very important for many of the tasks we will do. Here are some important string operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A string uses either single quotes or double quotes.  Pick one option and be consistent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a string'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'This is a string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is also a string'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"This is also a string\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The '+' operator concatenates strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"Hello\"  \n",
    "b = \" World\" \n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Portions of strings are manipulated using indexing (which python calls 'slicing')."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'W'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"World\"\n",
    "\n",
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'d'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Worl'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"World\"[0:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dlroW'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Some important string functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H-e-l-l-o- -W-o-r-l-d'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"Hello World\"\n",
    "\"-\".join(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.startswith(\"Wo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.endswith(\"rld\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'He110 W0r1[)'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.replace(\"o\",\"0\").replace(\"d\",\"[)\").replace(\"l\",\"1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', 'World']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hell', ' W', 'rld']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.split('o')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Strings are an example of an **immutable** data type.  Once you instantiate a string you cannot change any characters in it's set.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "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-26-b5fa142bf995>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mstring\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"string\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mstring\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"y\"\u001b[0m  \u001b[0;31m# This will generate and error as we attempt to modify the string\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": [
    "string = \"string\"\n",
    "string[-1] = \"y\"  # This will generate and error as we attempt to modify the string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To create a string with embedded objects use the `.format()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The course CS506 has an enrollment of 90 and is 100.0 percent full.'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "course_name = 'CS506'\n",
    "enrollment = 90\n",
    "percent_full = 100.0\n",
    "'The course {} has an enrollment of {} and is {} percent full.'.format(\n",
    "    course_name,enrollment,percent_full)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A special formatting called an f-string allows you to print out variables very conveniently:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The course CS506 has an enrollment of 90 and is 100.0 percent full.'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'The course {course_name} has an enrollment of {enrollment} and is {percent_full} percent full.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Code Structure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Python uses indents and whitespace to group statements together.  To write a short loop in C, you might use:\n",
    "\n",
    " ```c\n",
    " for (i = 0, i < 5, i++){\n",
    "       printf(\"Hi! \\n\");\n",
    "    }\n",
    " ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Python does not use curly braces like C, so the same program as above is written in Python as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi\n",
      "Hi\n",
      "Hi\n",
      "Hi\n",
      "Hi\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(\"Hi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If you have nested for-loops, there is a further indent for the inner loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n",
      "0 1\n",
      "0 2\n",
      "This statement is within the i-loop, but not the j-loop\n",
      "1 0\n",
      "1 1\n",
      "1 2\n",
      "This statement is within the i-loop, but not the j-loop\n",
      "2 0\n",
      "2 1\n",
      "2 2\n",
      "This statement is within the i-loop, but not the j-loop\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    for j in range(3):\n",
    "        print(i, j)\n",
    "    \n",
    "    print(\"This statement is within the i-loop, but not the j-loop\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## File I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`open()` and `close()` are used to access files.  However if you use the `with` statement the file close is automatically done for you.   \n",
    "\n",
    "You should use `with`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "with open(\"example.txt\", \"w\") as f:\n",
    "    f.write(\"Hello World! \\n\")\n",
    "    f.write(\"How are you? \\n\")\n",
    "    f.write(\"I'm fine. OK.\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Reading from a file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello', 'World!']\n",
      "['How', 'are', 'you?']\n",
      "[\"I'm\", 'fine.', 'OK.']\n"
     ]
    }
   ],
   "source": [
    "with open(\"example.txt\", \"r\") as f:\n",
    "    data = f.readlines()\n",
    "    for line in data:\n",
    "        words = line.split()\n",
    "        print(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here is an example of counting the number of lines and words in a file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 3 lines and 8 words in the example.txt file.\n"
     ]
    }
   ],
   "source": [
    "lines = 0\n",
    "words = 0\n",
    "the_file = \"example.txt\"\n",
    "\n",
    "with open(the_file, 'r') as f:\n",
    "    for line in f:\n",
    "        lines += 1\n",
    "        words += len(line.split())\n",
    "print(f\"There are {lines} lines and {words} words in the {the_file} file.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lists, Tuples, Sets and Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Number and strings alone are not enough! We need data types that can hold multiple values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Lists "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A list is a collection of data items, which can be of differing types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here is an empty list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "groceries = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A list is **mutable**, meaning that it can be altered.\n",
    "\n",
    "Adding to the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['oranges', 'meat', 'asparagus']"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "groceries.append(\"oranges\")  \n",
    "groceries.append(\"meat\")\n",
    "groceries.append(\"asparagus\")\n",
    "groceries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Accessing list items by index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oranges'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "groceries[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'asparagus'"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "groceries[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(groceries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Sort the items in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['asparagus', 'meat', 'oranges']"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "groceries.sort()\n",
    "groceries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Remove an item from a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['meat', 'oranges']"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "groceries.remove('asparagus')\n",
    "groceries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because lists are mutable, you can arbitrarily modify them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['peanut butter', 'oranges']"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "groceries[0] = 'peanut butter'\n",
    "groceries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### List Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A **list comprehension** makes a new list from an old list.  \n",
    "\n",
    "It is __incredibly__ useful (learn how to use it!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['asparagus', 'oranges']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "groceries = ['asparagus', 'meat', 'oranges']\n",
    "veggie = [x for x in groceries if x != \"meat\"]\n",
    "veggie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This is the same as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['asparagus', 'oranges']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "newlist = []\n",
    "for x in groceries:\n",
    "    if x != 'meat':\n",
    "        newlist.append(x)\n",
    "newlist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Recall the mathematical notation:\n",
    "\n",
    "$$L_1 = \\left\\{x^2 : x \\in \\{0\\ldots 9\\}\\right\\}$$\n",
    "\n",
    "$$L_2 = \\left\\{1, 2, 4, 8,\\ldots, 2^{12}\\right\\}$$\n",
    "\n",
    "$$M = \\left\\{x \\mid x \\in L_1 \\text{ and } x \\text{ is even}\\right\\}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L1 is [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "L2 is [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]\n"
     ]
    }
   ],
   "source": [
    "L1 = [x**2 for x in range(10)]\n",
    "L2 = [2**i for i in range(13)]\n",
    "print(f'L1 is {L1}')\n",
    "print(f'L2 is {L2}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M is [0, 4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "M = [x for x in L1 if x % 2 == 0]\n",
    "print('M is {}'.format(M))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A sort-of \"Sieve of Eratosthenes\" in list comprehensions.\n",
    "\n",
    "Basic idea: generate all composite numbers, remove them from the set of all numbers, and what is left are the prime nnumbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "composites = [i*j for i in range(2,8) for j in range(2,8)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 5, 7, 11, 13, 17, 19, 22, 23, 26, 27, 29, 31, 32, 33, 34, 37, 38, 39, 40, 41, 43, 44, 45, 46, 47, 48]\n"
     ]
    }
   ],
   "source": [
    "primes = [x for x in range(1,50) if x not in composites]\n",
    "print(primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Notice how much more concise and clear the list comprehension is.  It's more efficient too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A set is a collecton of items that cannot contain duplicates.  \n",
    "\n",
    "Sets handle operations like sets in mathematics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 5, 7, 9}"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = range(10)\n",
    "numbers = set(numbers)\n",
    "\n",
    "evens = {0, 2, 4, 6, 8}\n",
    "\n",
    "odds = numbers - evens\n",
    "odds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Sets also support the use of union (|), and intersection (&)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A dictionary is a map of keys to values.  \n",
    "\n",
    "**Keys must be unique**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'data-mining tools'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simple_dict = {}\n",
    "\n",
    "simple_dict['cs506'] = 'data-mining tools'\n",
    "\n",
    "simple_dict['cs506']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Creating an already-initialized dictionary.   Note the use of curly braces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "classes = {\n",
    "    'cs506': 'data-mining tools',\n",
    "    'cs565': 'data-mining algorithms'\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Check if item is in dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'cs530' in classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Add new item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'algorithms'"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classes['cs530'] = 'algorithms'\n",
    "classes['cs530']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Get just the keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['cs505', 'cs565', 'cs530'])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classes.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Get just the values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['data-mining tools', 'data-mining algorithms', 'algorithms'])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classes.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Get the items in the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('cs505', 'data-mining tools'), ('cs565', 'data-mining algorithms'), ('cs530', 'algorithms')])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classes.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Get dictionary pairs another way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cs505 data-mining tools\n",
      "cs565 data-mining algorithms\n",
      "cs530 algorithms\n"
     ]
    }
   ],
   "source": [
    "for key, value in classes.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Dictionaries can be combined to make complex (and very useful) data structures.\n",
    "\n",
    "Here is a list within a dictionary within a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "professors = {\n",
    "    \"prof1\": {\n",
    "        \"name\": \"Evimaria Terzi\",\n",
    "        \"interests\": [\"algorithms\", \"data mining\", \"machine learning\"]\n",
    "    },\n",
    "    \"prof2\": {\n",
    "        \"name\": \"Mark Crovella\",\n",
    "        \"interests\": [\"computer networks\", \"data mining\", \"biological networks\"]\n",
    "    },\n",
    "    \"prof3\": {\n",
    "        \"name\": \"George Kollios\",\n",
    "        \"interests\": [\"databases\", \"data mining\"]\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evimaria Terzi is interested in algorithms.\n",
      "Mark Crovella is interested in computer networks.\n",
      "George Kollios is interested in databases.\n"
     ]
    }
   ],
   "source": [
    "for prof in professors:\n",
    "    print('{} is interested in {}.'.format(\n",
    "            professors[prof][\"name\"],\n",
    "            professors[prof][\"interests\"][0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Tuples are an **immutable** type. Like strings, once you create them, you cannot change them.  \n",
    "\n",
    "Because they are immutabile you can use them as keys in dictionaries.  \n",
    "\n",
    "However, they are similar to lists in that they are a collection of data and that data can be of differing types.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here is a tuple version of our grocery list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('orange', 'meat', 'asparagus', 2.5, True)"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "groceries = ('orange', 'meat', 'asparagus', 2.5, True)\n",
    "groceries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'asparagus'"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "groceries[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "What will happen here?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' 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-107-9f9c178174f0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mgroceries\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'milk'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "groceries[2] = 'milk'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Iterators and Generators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can loop over the elements of a list using **for**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in range(4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "When we use **for** for dictionaries it loops over the keys of the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "evimaria\n",
      "george\n"
     ]
    }
   ],
   "source": [
    "for k in {'evimaria': 'terzi', 'george': 'kollios'}:\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "When we use **for** for strings it loops over the letters of the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n",
      " \n",
      "i\n",
      "s\n",
      " \n",
      "m\n",
      "a\n",
      "g\n",
      "i\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "for l in 'python is magic':\n",
    "    print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "What do these cases all have in common?   All of them are **iterable** objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['evimaria', 'george']"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list({'evimaria': 'terzi', 'george': 'kollios'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['p', 'y', 't', 'h', 'o', 'n', ' ', 'i', 's', ' ', 'm', 'a', 'g', 'i', 'c']"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list('python is magic')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'e-v-i-m-a-r-i-a'"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'-'.join('evimaria')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a-b-c'"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'-'.join(['a','b','c'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Defining Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Larry and I am 40 years old.\n"
     ]
    }
   ],
   "source": [
    "def displayperson(name,age):\n",
    "    print(\"My name is {} and I am {} years old.\".format(name,age))\n",
    "    return\n",
    "    \n",
    "displayperson(\"Larry\",\"40\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functional Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<img src=figs/Functional-Homer.png width=400px>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Functional programming is particularly valuable and common when working with data.  \n",
    "\n",
    "We'll see more sophisticated examples of this sort of programming later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Lambda functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Python supports the creation of anonymous functions (i.e. functions that are not bound to a name) at runtime, using a construct called `lambda`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    return x**2\n",
    "f(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = lambda x: x**2\n",
    "g(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x: x**2)(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The above pieces of code are all equivalent! Note that there is no `return` statement in the `lambda` function.  Instead there is just a single expression, which defines what the function returns.\n",
    "\n",
    "A `lambda` function can take multiple arguments.   However it has to get all its work done in a single line of code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = lambda x, y : x + y\n",
    "f(2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A `lambda` function does not need to be assigned to variable, but it can be used within the code wherever a function is expected."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here is an example of 'currying': a function that returns a new function, with some of the original arguments bound."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.multiply.<locals>.<lambda>(x)>"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def multiply (n): \n",
    "    return lambda x: x*n\n",
    " \n",
    "f = multiply(2)\n",
    "g = multiply(6)\n",
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "90"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply(3)(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Our first example of functional programming will be the **map** operator:\n",
    "\n",
    "`r = map(func, s)`\n",
    "\n",
    "`func` is a function and `s` is a sequence (e.g., a list). \n",
    "\n",
    "`map()` returns an object that will apply function `func` to each of the elements of `s`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[89.0, 178.0, 267.0, 356.0]"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def dollar2euro(x):\n",
    "    return 0.89*x\n",
    "def euro2dollar(x):\n",
    "    return 1.12*x\n",
    "\n",
    "amounts= (100, 200, 300, 400)\n",
    "dollars = map(dollar2euro, amounts)\n",
    "list(dollars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[112.00000000000001,\n",
       " 224.00000000000003,\n",
       " 336.00000000000006,\n",
       " 448.00000000000006]"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "amounts= (100, 200, 300, 400)\n",
    "euros = map(euro2dollar, amounts)\n",
    "list(euros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[89.0, 178.0, 267.0, 356.0]"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: 0.89*x, amounts))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**map** can also be applied to more than one list as long as they are of the same size and type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 22, 33, 44, 55]"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1,2,3,4,5]\n",
    "b = [10, 20 , 30, 40, 50]\n",
    "\n",
    "l1 = map(lambda x,y: x+y, a,b)\n",
    "list(l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The next functional operator is **filter**.  \n",
    "\n",
    "`filter(function, list)` returns a new list containing all the elements of `list` for which `function()` evaluates to `True.` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<filter object at 0x7fd620ab9550>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[2,\n",
       " 4,\n",
       " 6,\n",
       " 8,\n",
       " 10,\n",
       " 12,\n",
       " 14,\n",
       " 16,\n",
       " 18,\n",
       " 20,\n",
       " 22,\n",
       " 24,\n",
       " 26,\n",
       " 28,\n",
       " 30,\n",
       " 32,\n",
       " 34,\n",
       " 36,\n",
       " 38,\n",
       " 40,\n",
       " 42,\n",
       " 44,\n",
       " 46,\n",
       " 48,\n",
       " 50,\n",
       " 52,\n",
       " 54,\n",
       " 56,\n",
       " 58,\n",
       " 60,\n",
       " 62,\n",
       " 64,\n",
       " 66,\n",
       " 68,\n",
       " 70,\n",
       " 72,\n",
       " 74,\n",
       " 76,\n",
       " 78,\n",
       " 80,\n",
       " 82,\n",
       " 84,\n",
       " 86,\n",
       " 88,\n",
       " 90,\n",
       " 92,\n",
       " 94,\n",
       " 96,\n",
       " 98]"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nums = [i for i in range(100)]\n",
    "even = filter(lambda x: x%2==0 and x!=0, nums)\n",
    "print(even)\n",
    "list(even)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The last functional operator is **`reduce()`**.\n",
    "\n",
    "The job of `reduce(function,list)` is to return a single value that combines all the elements of the list.\n",
    "\n",
    "`reduce(function, list)` sequentially applies `function()` to its previously returned value, and the next element of `list`.  \n",
    "\n",
    "For example if `list = [a1,a2,a3,...,a10],` then the first step of \n",
    "`reduce(function, list)` will compute `[function(a1,a2),a3,...,a10]`, and so on.\n",
    "\n",
    "The function supplied to reduce is typically commutative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "reduce(lambda x,y: x+y, [x for x in range(10)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce (lambda x,y: x if x>y else y, [1, 15, 26, -27])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Python is a high-level open-source language.  But the _Python world_ is inhabited by many packages or libraries that provide useful things like array operations, plotting functions, and much more. \n",
    "\n",
    "We can (and we will) import many different libraries of functions to expand the capabilities of Python in our programs.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "109"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "myList = [2, 109, False, 10, \"data\", 482, \"mining\"]\n",
    "random.choice(myList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 1, 8, 5, 3, 7, 0, 9, 6]"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from random import shuffle\n",
    "x = list(range(10))\n",
    "shuffle(x)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## APIs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "For example, there are libraries that make it easy to interact with RESTful APIs.  \n",
    "\n",
    "A RESTful API is a service available on the Internet that uses the HTTP protocol for access."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Response [200]>\n"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "\n",
    "width = '200'\n",
    "height = '300'\n",
    "response = requests.get('http://loremflickr.com/' + width + '/' + height)\n",
    "\n",
    "print(response)\n",
    "\n",
    "with open('img.jpg', 'wb') as f:\n",
    "    f.write(response.content)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "image/jpeg": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image(filename=\"img.jpg\")"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}