{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Python Refresher for CS 237 and CS 132\n", "\n", "This document summarizes what you need to know about Python for CS 237 and CS 132. \n", "Even if you already know the language well, you should look this through,\n", "as I explain how to avoid nasty bugs in your coding this semester. \n", "\n", "\n", "NOTE: To see a video walk-through with my comments, check out my YouTube video here. " ] }, { "cell_type": "code", "execution_count": 152, "metadata": {}, "outputs": [], "source": [ "# Here are some imports which will be used in the code in the rest of the lab \n", "\n", "# Imports used for the code in CS 237\n", "\n", "import numpy as np # arrays and functions which operate on array\n", "import matplotlib.pyplot as plt # normal plotting\n", "import seaborn as sns # Fancy plotting \n", "import pandas as pd # Data input and manipulation\n", "\n", "from collections import Counter\n", "\n", "import math\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Basic Python Programming" ] }, { "cell_type": "code", "execution_count": 153, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "here is a definition\n" ] }, { "data": { "text/plain": [ "'Hi there, Paul'" ] }, "execution_count": 153, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(\"here is a definition\")\n", "\n", "def sayHi(name):\n", " return \"Hi there, \" + name\n", "\n", "sayHi('Paul')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Optional Arguments\n", "\n", "Python allows a lot of flexibility when you define functions; in particular,\n", "it allows you to define functions with a variable number of arguments,\n", "and optional arguments with default values. This simplifies the syntax\n", "when you have a function which you want to use in a variety of contexts;\n", "many of the statistical functions operation in this way, for example. " ] }, { "cell_type": "code", "execution_count": 154, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "All the arguments: (2, 2, 5, 4, 7, -3)\n", "Number of arguments: 6\n", "Last argument: -3\n", "Sum = 17\n", "\n", "All the arguments: (4,)\n", "Number of arguments: 1\n", "Last argument: 4\n", "Sum = 4\n", "\n", "All the arguments: ()\n", "Number of arguments: 0\n", "Sum = 0\n" ] } ], "source": [ "# Variable number of arguments, this looks a lot like how it is done in C\n", "\n", "# The following function collects together all its arguments into a tuple,\n", "# which can then be accessed as usual inside the function\n", "\n", "def my_sum(*args):\n", " print('All the arguments:', args)\n", " print('Number of arguments:', len(args))\n", " if len(args) > 0:\n", " print('Last argument:', args[-1])\n", " return sum(args)\n", " \n", "print('Sum = ', my_sum(2,2,5,4,7,-3))\n", "print()\n", "print('Sum = ', my_sum(4))\n", "print()\n", "print('Sum = ', my_sum())" ] }, { "cell_type": "code", "execution_count": 155, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x = 5 , a = 3 , m = 7 , b = 1\n", "2\n", "\n", "x = 5 , a = 2137 , m = 6827 , b = 0\n", "3858\n", "\n", "x = 15 , a = 23 , m = 6827 , b = 0\n", "345\n", "\n", "x = 15 , a = 7 , m = 11 , b = 0\n", "6\n", "\n" ] } ], "source": [ "# Optional Arguments with Default Values\n", "\n", "# You may give arguments with default values using\n", "# an initialization in the definition, as shown here:\n", "\n", "# x is a normal parameter, you MUST supply it \n", "# m is optional, if you leave it out it will get the default\n", "# b ditto\n", "def LC_Hash(x, a = 2137, m = 6827, b = 0):\n", " print('x =',x, ', a =',a, ', m =',m, ', b =',b)\n", " return ((a * x) % m) + b\n", "\n", "# Here we give all four values\n", "\n", "print( LC_Hash( 5, 3, 7, 1) ) # x <- 5, a <- 3, m <- 7, b <- 1\n", "print()\n", "\n", "# Here we give only first, rest will take optional values\n", "\n", "print( LC_Hash( 5 ) ) # x <- 5, a <- 3, m <- 7, b <- 1\n", "print()\n", "\n", "# Here we give first two\n", "\n", "print( LC_Hash( 15, 23 ) ) \n", "print()\n", "\n", "# Here we give only first three\n", "\n", "print( LC_Hash( 15, 7, 11 ) ) # x <- 5, a <- 3, m <- 7, b <- 1\n", "print()\n", "\n" ] }, { "cell_type": "code", "execution_count": 156, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x = 15 , a = 11 , m = 23 , b = 3\n", "7\n", "\n" ] } ], "source": [ "# Is best to give values for a prefix of the arguments, in order, and not skip around\n", "# When in doubt, use the name of the parameter\n", "\n", "print( LC_Hash( 15, 11, m = 23, b = 3 ) ) \n", "print()" ] }, { "attachments": { "Screen%20Shot%202020-01-31%20at%207.14.28%20PM.png": { "image/png": "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" } }, "cell_type": "markdown", "metadata": {}, "source": [ "Basically, Python matches the parameters and arguments by position, and THEN by\n", "name:\n", "
\n", "print( LC_Hash( 15, 11, m = 23, b = 3 ) ) \n", " \n", " by position: ****** |\n", " by name: | +++++++++++++\n", "\n", "\n", "\n", "\n", "\n", "If you try to do the reverse, it will complain:\n", "\n", "\n", "![Screen%20Shot%202020-01-31%20at%207.14.28%20PM.png](attachment:Screen%20Shot%202020-01-31%20at%207.14.28%20PM.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## List processing" ] }, { "cell_type": "code", "execution_count": 157, "metadata": {}, "outputs": [], "source": [ "A = [1,2,3,4]\n", "B = [\"hi\", \"there\", \"Paul\"]" ] }, { "cell_type": "code", "execution_count": 158, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4]" ] }, "execution_count": 158, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A" ] }, { "cell_type": "code", "execution_count": 159, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['hi', 'there', 'Paul']\n" ] } ], "source": [ "print(B)" ] }, { "cell_type": "code", "execution_count": 160, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Paul\n", "Paul\n" ] } ], "source": [ "# Pulling stuff out of lists\n", "\n", "print(B[2])\n", "\n", "# Using negative indices (going right to left)\n", "\n", "print(B[-1]) # last element of the list" ] }, { "cell_type": "code", "execution_count": 161, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['there', 'Paul']" ] }, "execution_count": 161, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B[1:]" ] }, { "cell_type": "code", "execution_count": 162, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "['hi', 'there']" ] }, "execution_count": 162, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B[:2]" ] }, { "cell_type": "code", "execution_count": 163, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['there', 'Paul']" ] }, "execution_count": 163, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B[1:3]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Adding, replacing, and finding elements and combining lists" ] }, { "cell_type": "code", "execution_count": 164, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 164, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Find location of an element\n", "B.index(\"there\")" ] }, { "cell_type": "code", "execution_count": 165, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['hi', 'there', 'Hagstrom']\n" ] } ], "source": [ "# Replacing an element\n", "B[2] = \"Hagstrom\"\n", "print(B)" ] }, { "cell_type": "code", "execution_count": 166, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['hi', 'there', 'Hagstrom', 'and', 'Wayne']\n" ] } ], "source": [ "# Appending two lists using +\n", "\n", "C = B + ['and', 'Wayne']\n", "print(C)" ] }, { "cell_type": "code", "execution_count": 167, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['hi', 'there', 'Hagstrom', 'and', 'Wayne', 'Snyder']\n", "['Well', 'hi', 'there', 'Hagstrom', 'and', 'Wayne', 'Snyder']\n", "['Well', 'hi', 'there', 'Paul', 'Hagstrom', 'and', 'Wayne', 'Snyder']\n" ] } ], "source": [ "# Adding a new element to end of list\n", "C = C + ['Snyder'] # could also write: C += ['Snyder']\n", "print(C)\n", "\n", "# Adding a new elements in the beginning of a list\n", "\n", "C = ['Well'] + C\n", "print(C)\n", "\n", "# Adding a new element in the middle of the list\n", "C = C[:3] + ['Paul'] + C[3:] # 3 is the location of the new element\n", "print(C)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### WARNING\n", "\n", "When you are changing a list, remember about the global memory. **Run \n", "the previous cell 4 or 5 times, and watch what happens!** (It should\n", "keep adding the elements over and over.)\n", "\n", "Again, you need to restart the kernel if you have some problem like this. \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### WARNING: There are list processing functions for permanently changing lists, for example by deleting element and moving everything over, or appending to the end of a list. These are notoriously hard to understand, and I STRONGLY advise you to not make changes to lists in place, but make new versions of the list. All the functions above will not disturb the original list. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The Four Most Important List-Processing Functions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Find the Length of a list" ] }, { "cell_type": "code", "execution_count": 168, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "8" ] }, "execution_count": 168, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(C)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Find the location of an element in a list" ] }, { "cell_type": "code", "execution_count": 169, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n" ] } ], "source": [ "print( B.index('there') ) # This shows another way of calling a function in Python, using object-oriented syntax.\n", "\n", "# Note: This will cause an error if the item is not in the list" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Sort a list\n", "\n", "There are two ways to sort a list, depending on whether you want to sort the original list *in place* (changing the order in your original list) or produce a *sorted copy* of a list (leaving the original list unchanged):" ] }, { "cell_type": "code", "execution_count": 170, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 7, 5, 2]\n", "[1, 2, 5, 7]\n", "\n", "[7, 5, 2, 1]\n", "\n", "[1, 2, 5, 7]\n", "[7, 5, 2, 1]\n" ] } ], "source": [ "X = [1,7,5,2]\n", "\n", "# Producing a sorted copy of a list\n", "Y = sorted(X)\n", "print(X)\n", "print(Y)\n", "print()\n", "\n", "# make a copy sorted in descending order\n", "Z = sorted(X,reverse=True)\n", "print(Z)\n", "print()\n", "\n", "# Sorting a list in place\n", "X.sort()\n", "print(X)\n", "\n", "# Sort into reverse order in place\n", "X.sort(reverse=True)\n", "print(X)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Copying a List" ] }, { "cell_type": "code", "execution_count": 171, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 7, 5, 2]" ] }, "execution_count": 171, "metadata": {}, "output_type": "execute_result" } ], "source": [ "X = [1,7,5,2]\n", "Y = X.copy()\n", "Y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Passing lists as parameters to functions\n", "\n", "Remember that parameter passing in python is by reference. Thus if you pass an array into\n", "a subroutine, and modify the array in the subroutine, the modifications will still be in effect after the subroutine exits\n", "(i.e., modifying an array creates side-effects).\n" ] }, { "cell_type": "code", "execution_count": 172, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3, 4]\n", "[5, 2, 3, 4]\n" ] } ], "source": [ "def changeList(L):\n", " L[0] = 5\n", " \n", "Lst = [1,2,3,4]\n", "\n", "print(Lst)\n", "changeList(Lst)\n", "print(Lst)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Shallow vs Deep Copies of Lists\n", "\n", "This discussion is based on the one found here.\n", "\n", "The question is:\n", "\n", "> How do you make a copy of a list?\n", "\n", "The answer depends on what you mean by a *copy*! If you mean another reference to the same list, that is called a **shallow copy** (like the fact that my oldest son is called \"John\" or \"JH\" -- two names for the same person),\n", "just assign the list to another name:" ] }, { "cell_type": "code", "execution_count": 173, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3, 4]\n", "[1, 2, 3, 4]\n" ] } ], "source": [ "A = [1,2,3,4]\n", "B = A\n", "print(A)\n", "print(B)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "But to see that there is only one list (which now has two names), just make changes to each:" ] }, { "cell_type": "code", "execution_count": 174, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['a', 2, 3, 4]\n", "['a', 2, 3, 4]\n", "\n", "['a', 2, 3, 'c']\n", "['a', 2, 3, 'c']\n" ] } ], "source": [ "A = [1,2,3,4]\n", "B = A\n", "\n", "A[0] = 'a'\n", "\n", "print(A)\n", "print(B)\n", "print()\n", "\n", "B[3] = 'c'\n", "\n", "print(A)\n", "print(B)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A shallow copy only copies the *reference* to the list, not the list contents:\n", " \n", " A = [1,2,3,4] \n", " A -> [1,2,3,4]\n", " \n", " B = A \n", " A -> [1,2,3,4] <- B\n", " \n", " A[0] = 'a'\n", " A -> ['a',2,3,4] <- B \n", " \n", " B[3] = 'c'\n", " A -> ['a',2,3,'c'] <- B \n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To make a **deep copy** of a list, making an entirely new list with new elements, you can use\n", "a slice, a list constructor, or Python3's `copy` function:" ] }, { "cell_type": "code", "execution_count": 175, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['a', 2, 3, 4]\n", "[1, 'b', 3, 4]\n", "[1, 2, 'c', 4]\n", "[1, 2, 3, 'd']\n" ] } ], "source": [ "A = [1,2,3,4]\n", "\n", "# Copying a list by slicing\n", "B = A[:]\n", "\n", "# Copying a list using the list constructor\n", "C = list(A)\n", "\n", "# Copying a list using Python3's copy function:\n", "D = A.copy()\n", "\n", "# These are all different lists:\n", "\n", "A[0] = 'a'\n", "B[1] = 'b'\n", "C[2] = 'c'\n", "D[3] = 'd'\n", "\n", "print(A)\n", "print(B)\n", "print(C)\n", "print(D)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A deep copy makes an entirely new list:\n", " \n", " A = [1,2,3,4] \n", " A -> [1,2,3,4]\n", " \n", " B = A[:] \n", " A -> [1,2,3,4] \n", " B -> [1,2,3,4] \n", " \n", " C = list(A)\n", " A -> [1,2,3,4] \n", " B -> [1,2,3,4] \n", " C -> [1,2,3,4]\n", " \n", " D = list(A)\n", " A -> [1,2,3,4] \n", " B -> [1,2,3,4] \n", " C -> [1,2,3,4] \n", " D -> [1,2,3,4]\n", " \n", " A[0] = 'a'\n", " A -> ['a',2,3,4] \n", " B -> [1,2,3,4] \n", " C -> [1,2,3,4] \n", " D -> [1,2,3,4]\n", "\n", " B[1] = 'b'\n", " A -> ['a',2,3,4] \n", " B -> [1,'b',3,4] \n", " C -> [1,2,3,4] \n", " D -> [1,2,3,4]\n", " \n", " --and so on--" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## List Comprehensions\n", "\n", "A list comprehension is a great way to create lists with a minimum of fuss and bugs. \n", "The basic idea is that instead of creating a list by specifying every step, say like this:" ] }, { "cell_type": "code", "execution_count": 176, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]" ] }, "execution_count": 176, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create a list of the first 10 squares\n", "\n", "L = [0] * 10 # create a list of 10 zeros\n", "\n", "for k in range(len(L)):\n", " L[k] = (k+1)**2\n", "L" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "you can do it all in one line:" ] }, { "cell_type": "code", "execution_count": 177, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n" ] } ], "source": [ "L1 = [ (k+1)**2 for k in range(len(L)) ]\n", "print(L1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The idea is to collect together all instances of the expression at the beginning, for all values of k produces\n", "by the for. Some examples may clarify. " ] }, { "cell_type": "code", "execution_count": 178, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0.4044216757044765, 0.0015464960773501346, 0.2995554765920614, 0.6614565365796136, 0.7507767879926917, 0.43036645074052493, 0.4162504140646396, 0.7651207176585524, 0.24706617964254396, 0.024107540359731394]\n" ] } ], "source": [ "from random import random # The function random() returns a random double in the range [0..1)\n", "\n", "L2 = [ random() for k in range(10) ]\n", "print(L2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can also use multiple for loops:" ] }, { "cell_type": "code", "execution_count": 179, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['0A', '0B', '0C', '0D', '0E', '1A', '1B', '1C', '1D', '1E', '2A', '2B', '2C', '2D', '2E', '3A', '3B', '3C', '3D', '3E', '4A', '4B', '4C', '4D', '4E']\n" ] } ], "source": [ "D = ['0','1','2','3','4']\n", "L = ['A','B','C','D','E']\n", " \n", "X = [ d + el for d in D for el in L ]\n", "print(X)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "List comprehensions can do a lot, especiallly if you use conditions in the \"loop\" part:" ] }, { "cell_type": "code", "execution_count": 180, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[63, 241, 7, 43, 99, 132, 6, -3, 71, 235, 24, 66]\n", "[7, 43, 6, -3, 24]\n", "[63, 241, 99, 132, 71, 235, 66]\n" ] } ], "source": [ "L3 = [63,241,7,43,99,132,6,-3,71,235,24,66] \n", "\n", "# let's pick 63 as the \"pivot\" for quicksort and partition the list into those\n", "# numbers less than 63 and those greater or equal:\n", "\n", "left = [ x for x in L3 if x < 63 ]\n", "right = [ x for x in L3 if x >= 63 ]\n", "\n", "print(L3)\n", "print(left)\n", "print(right)" ] }, { "cell_type": "code", "execution_count": 181, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[-3, 6, 7, 24, 43, 63, 66, 71, 99, 132, 235, 241]" ] }, "execution_count": 181, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# List comprehensions can be used to write very complicated algorithms with very few lines of code!\n", "\n", "def quicksort(L):\n", " if(L == []):\n", " return []\n", " else:\n", " pivot = L[0]\n", " left = [ x for x in L[1:] if x < pivot ] # partition list around pivot\n", " right = [ x for x in L[1:] if x >= pivot ] \n", " return ( quicksort(left) + [pivot] + quicksort(right) )\n", "\n", "quicksort(L3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Sets\n", "\n", "A set in mathematics is a collection of elements in which there are no duplicates and order does not matter.\n", "In Python, we can create sets, which are implemented by hash tables, and are much more efficient than lists, if\n", "a set is really what you want. \n" ] }, { "cell_type": "code", "execution_count": 182, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{2, 3, 4, 5}\n", "{3, 4}\n", "\n", "True\n", "True\n", "\n", "{2, 3, 4, 5, 7}\n", "{2, 4, 5, 7}\n", "\n", "A = {'d', 'a', 'c'}\n", "B = {2, 'd', 'c'}\n", "C = {1, 2, 3}\n", "\n", "A U B = {2, 'd', 'a', 'c'}\n", "B U C = {1, 2, 3, 'd', 'c'}\n", "A U B U C = {1, 2, 3, 'd', 'a', 'c'}\n", "A.union() = {'d', 'a', 'c'}\n", "\n", "A n B = {'d', 'c'}\n", "B n C = {2}\n", "A n C = set() <- this is how empty set can be represented\n", "C n A n B = set()\n", "\n", "A - B = {'a'}\n", "B - A = {2}\n", "A - C = {'d', 'a', 'c'}\n" ] } ], "source": [ "# create a set\n", "S= {2,3,4,5}\n", "print(S)\n", "\n", "# duplicates are ignored\n", "T = { 3, 4,3 }\n", "print(T)\n", "print()\n", "\n", "# membership test\n", "print( (3 in S) )\n", "\n", "# subset test\n", "print( (T.issubset(S)) )\n", "print()\n", "\n", "# add an element to a set\n", "S.add(7)\n", "print(S)\n", "\n", "# remove an element from a set\n", "S.remove(3)\n", "print(S)\n", "print()\n", "\n", "# create a new set using set operations union, intersection, and set difference\n", "\n", "A = {'a', 'c', 'd'}\n", "B = {'c', 'd', 2 }\n", "C = {1, 2, 3}\n", "\n", "print('A =',A)\n", "print('B =',B)\n", "print('C =',C)\n", "print()\n", "\n", "print('A U B =', A.union(B))\n", "print('B U C =', B.union(C))\n", "print('A U B U C =', A.union(B, C))\n", "print('A.union() =', A.union()) # just make a copy\n", "print()\n", "\n", "# return a new set which is the intersecction of others\n", "print('A n B =',B.intersection(A))\n", "print('B n C =',B.intersection(C))\n", "print('A n C =',A.intersection(C),' <- this is how empty set can be represented')\n", "print('C n A n B =',C.intersection(A, B))\n", "print()\n", "\n", "# return a new set which is the set difference with another\n", "print('A - B =',A.difference(B))\n", "print('B - A =',B.difference(A))\n", "print('A - C =',A.difference(C))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Dictionaries\n", "\n", "A dictionary is a data structures which stores (key,value) pairs (typically implemented as a hash table).\n", "This is a great data structure for storing information about objects without having to muck around with lists.\n" ] }, { "cell_type": "code", "execution_count": 183, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'a': 2, 'c': 8, 'b': 1}\n", "{}\n" ] } ], "source": [ "D = { 'a' : 2, 'c' : 8, 'b' : 1} # Dictionary storing, say, how many times a letter appears in a string\n", "print(D)\n", "E = {} # empty dictionary\n", "print(E)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Basic Dictionary Operations\n", "\n", "Most of the manipulation of dictionaries looks like array or list manipulation\n", "but using the keys instead of the position of the elements in the list. \n" ] }, { "cell_type": "code", "execution_count": 184, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "8" ] }, "execution_count": 184, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Find the value associated with a particular key\n", "D['c']" ] }, { "cell_type": "code", "execution_count": 185, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'a': 4, 'c': 8, 'b': 1, 'z': 23}" ] }, "execution_count": 185, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Insert a key-value pair \n", "D['a'] = 4\n", "D['z'] = 23\n", "D" ] }, { "cell_type": "code", "execution_count": 186, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'a': 4, 'c': 8, 'b': 1, 'z': 25}" ] }, "execution_count": 186, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# update a value associated with a key by doing both\n", "D['z'] = D['z'] + 2\n", "D" ] }, { "cell_type": "code", "execution_count": 187, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict_keys(['a', 'c', 'b', 'z'])\n", "['a', 'c', 'b', 'z']\n", "[4, 8, 1, 25]\n" ] } ], "source": [ "### Miscellaneous functions\n", "\n", "# get all keys\n", "print( D.keys() )\n", "print( list(D.keys()) ) # to just get a list\n", "\n", "# get all values\n", "print( list(D.values()) )" ] }, { "cell_type": "code", "execution_count": 188, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n" ] } ], "source": [ "# Default values for dictionaries\n", "\n", "# simplest: use the function get(...)\n", "x = D.get('q',0) # first argument to get is the key, the second is the default\n", " # value if the key is not in the dictionary\n", "print(x)" ] }, { "cell_type": "code", "execution_count": 189, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n", "0\n" ] } ], "source": [ "# The second way is to use a different kind of dictionary, which you have to import,\n", "# and then define a function to return the default value\n", "\n", "from collections import defaultdict\n", "\n", "def get_default():\n", " return 0\n", "\n", "A = defaultdict(get_default)\n", "\n", "A['a'] = 5\n", "print( A['a'] )\n", "print( A['b'] )" ] }, { "cell_type": "code", "execution_count": 190, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Counter creates a dictionary giving the frequency counts of each element in the list.\n", "Counter({3: 5, 4: 5, 2: 2, 5: 2, 8: 1})\n", "The list has 5 instances of the number 3.\n" ] } ], "source": [ "### Calculating frequency counts using a dictionary\n", "\n", "#from collections import Counter <- this was imported in the first code cell\n", "\n", "F = Counter([3,4,2,3,4,5,4,3,2,3,4,5,4,3,8])\n", "\n", "print(\"Counter creates a dictionary giving the frequency counts of each element in the list.\")\n", "print(F)\n", "\n", "n = 3\n", "print(\"The list has\",F[n], 'instances of the number '+ str(n) + '.')" ] }, { "attachments": { "Screen%20Shot%202021-05-24%20at%205.55.43%20PM.png": { "image/png": "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" } }, "cell_type": "markdown", "metadata": {}, "source": [ "### Floating-Point Arithmetic\n", "\n", "This section will summarize a few important points from the lecture notes in CS 132:\n", "\n", " https://www.cs.bu.edu/fac/snyder/cs132-book/L02Numerics.html\n", "\n", "Python has both integer and floating point types. Integers, as long as they are not too large, can be stored precisely; however, real numbers (such as $\\pi$), can only be approximated by storing the number in scientific notation in binary:\n", "\n", "![Screen%20Shot%202021-05-24%20at%205.55.43%20PM.png](attachment:Screen%20Shot%202021-05-24%20at%205.55.43%20PM.png)\n", "\n", "Because only a fixed number of bits are used, most real numbers cannot be represented exactly in a computer.\n", "\n", "Another way of saying this is that, usually, a floating point number is an approximation of some particular real number.\n", "\n", "Generally when we try to store a real number in a computer, what we wind up storing is the closest floating point number that the computer can represent.\n", "\n", "Problems arise when we work with floating point numbers and confuse them with real numbers, thereby forgetting that most of the time we are not storing the real number exactly, but only a floating point number that is close to it.\n", "\n", "Let’s look at some examples. First:" ] }, { "cell_type": "code", "execution_count": 191, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.0" ] }, "execution_count": 191, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# ((1/8)*8)-1\n", "a = 1/8\n", "b = 8\n", "c = 1\n", "(a*b)-c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It turns out that 1/8, 8, and 1 can all be stored exactly in IEEE-754 floating point format.\n", "\n", "So, we are storing the inputs exactly (1/8, 8 and 1), computing the results exactly, yielding \n", "\n", " $$(1/8)∗8=1$$\n", "\n", "and representing the result exactly (zero).\n", "\n", "OK, here is another example:" ] }, { "cell_type": "code", "execution_count": 192, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.0" ] }, "execution_count": 192, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# ((1/7)*7)-1\n", "a = 1/7\n", "b = 7\n", "c = 1\n", "a * b - c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here the situation is different.\n", "\n", "1/7 can not be stored exactly in floating point format.\n", "\n", "In binary, 1/7 is 0.001001⎯⎯⎯⎯⎯⎯⎯⎯⎯, an infinitely repeating pattern that clearly cannot be represented in a finite sequence of bits.\n", "\n", "Nonetheless, the computation (1/7)∗7 still yields exactly 1.0.\n", "\n", "Why? Because the rounding of 0.001001⎯⎯⎯⎯⎯⎯⎯⎯⎯ to its closest floating point representation, when multiplied by 7, yields a value whose closest floating point representation is 1.0.\n", "\n", "Now, let’s do something that seems very similar:" ] }, { "cell_type": "code", "execution_count": 193, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-1.3877787807814457e-17" ] }, "execution_count": 193, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# ((1/70)*7)-0.1\n", "a = 1/70\n", "b = 7\n", "c = 0.1\n", "a * b - c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this case, neither 1/70 nopr 0.1 can be stored exactly.\n", "\n", "More importantly, the process of rounding 1/70 to its closest floating point representation, then multiplying by 7, yields a number whose closest floating point representation is not 0.1\n", "\n", "However, that floating point representation is very close to 0.1.\n", "\n", "Let’s look at the difference: -1.3877787807814457e-17.\n", "\n", "This is about $−1\\cdot 10^{−17}$ = -0.0000000000000001.\n", "\n", "Compared to 0.1, this is a very small number. The relative error abs(-0.0000000000000001 / 0.1) is about $10^{−16}$.\n", "\n", "This suggests that when a floating point calculation is not exact, the error (in a relative sense) is usually very small." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Punchline 1: Do not compare floating point numbers for equality¶\n", "\n", "Two floating point computations that should yield the same result mathematically, may not do so due to rounding error.\n", "\n", "However, in general, if two numbers should be equal, the relative error of the difference in the floating point should be small.\n", "\n", "So, instead of asking whether two floating numbers are equal, we should ask whether the relative error of their difference is small." ] }, { "cell_type": "code", "execution_count": 194, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.3877787807814457e-16" ] }, "execution_count": 194, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = 7\n", "b = 1/10\n", "c = 1/a\n", "r1 = a * b * c\n", "r2 = b * c * a\n", "np.abs(r1-r2)/r1" ] }, { "cell_type": "code", "execution_count": 195, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "finfo(resolution=1e-15, min=-1.7976931348623157e+308, max=1.7976931348623157e+308, dtype=float64)" ] }, "execution_count": 195, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.finfo('float')" ] }, { "cell_type": "code", "execution_count": 196, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "False\n" ] } ], "source": [ "print(r1 == r2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Instead, when comparing floating-point values, we should test whether they\n", "are \"close enough.\" \n", "This test is needed often enough that numpy has a function that implements it:" ] }, { "cell_type": "code", "execution_count": 197, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 197, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.isclose(r1, r2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Punchline 2: Beware of ill-conditioned problems¶\n", "\n", "An ill-conditioned problem is one in which the outputs depend in a very sensitive manner on the inputs.\n", "\n", "That is, a small change in the inputs can yield a very large change in the outputs.\n", "\n", "The simplest example is computing 1/(𝑎−𝑏)." ] }, { "cell_type": "code", "execution_count": 198, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "r1 is 0.1\n", "r2 is very close to r1\n", "r3 is 0.1001\n", "1/(r1 - r2) = 7.205759403792794e+16\n", "1/(r3 - r2) = 9999.999999998327\n" ] } ], "source": [ "print(f'r1 is {r1}')\n", "print(f'r2 is very close to r1')\n", "r3 = r1 + 0.0001\n", "print(f'r3 is 0.1001')\n", "print(f'1/(r1 - r2) = {1/(r1 - r2)}')\n", "print(f'1/(r3 - r2) = {1/(r3 - r2)}')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If a is close to b, small changes in either make a big difference in the output.\n", "\n", "Because the inputs to your problem may not be exact, if the problem is ill-conditioned, the outputs may be wrong by a large amount.\n", "\n", "Later on in CS 132 we will see that the notion of ill-conditioning applies to matrix problems too, and in particular comes up when we solve certain problems involving matrices.\n", "\n", "### Punchline 3: Relative error can be magnified during subtractions¶\n", "\n", "Two numbers, each with small relative error, can yield a value with large relative error if subtracted.\n", "\n", "Let’s say we represent a = 1.2345 as 1.2345002 – the relative error is 0.0000002.\n", "\n", "Let’s say we represent b = 1.234 as 1.2340001 – the relative error is 0.0000001.\n", "\n", "Now, subtract a - b: the result is .0005001.\n", "\n", "What is the relative error? 0.005001 - 0.005 / 0.005 = 0.0002\n", "\n", "The relative error of the result is 1000 times larger than the relative error of the inputs.\n", "\n", "Here’s an example in practice:" ] }, { "cell_type": "code", "execution_count": 199, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "9e-08\n", "8.999999989711682e-08\n", "1.1431464011915431e-09\n" ] } ], "source": [ "a = 1.23456789\n", "b = 1.2345678\n", "print(0.00000009)\n", "print(a-b)\n", "print(np.abs(a-b-0.00000009)/ 0.00000009)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We know the relative error in the inputs is on the order of $10^{−16}$, but the relative error of the output is on the order of $10^{−9}$ – i.e., a million times larger.\n", "\n", "A good summary that covers additional issues is at https://docs.python.org/2/tutorial/floatingpoint.html." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Python in Notebooks\n", "\n", "Python (literally iPython) in Jupyter notebooks has become a \n", "standard in machine learning and data analysis, and so we\n", "will use this framework for submitting work in CS 237. The following\n", "introduces the major concepts that you need for CS 237. For a more\n", "complete introduction, read through the following tutorial\n", "up to Section 4.7.2:\n", "\n", "https://docs.python.org/3/tutorial/\n", "\n", "This tutorial assumes you have read or at least skimmed the\n", "above resource, and will concentrate on those part of Python\n", "that we need to know about for CS 237. \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Features/Bugs of Python to Watch out for\n", "\n", "There are three things about Python that you need to know, if you\n", "are more familiar with a language like Java or C. \n", "\n", "(1) Python is an **interpreted** language, which means it are processed\n", "in a \"Read-Eval-Print\" loop: \n", "input expressions or definitions or assignment statements are read, evaluated,\n", "and the result printed out, and then it starts all over again with the next expression. \n", "You can see the order in which the cells were evaluated by looking at the number in square braces to the left: \n", "\n", " In [87]:\n", "\n", "(2) Python is a **weakly-typed** language, which means that values have types (of course) but \n", "variables don't have to be declared with a type and only contain values of that type.\n", "Any variable can represent any type of value. \n", "\n", "\n", "(3) Python maintains a **global memory** of all definitions (function \n", "definitions, and assignment statements), which is maintained until\n", "you terminate or restart the kernel. This feature causes a lot of problems!\n", "\n", "Features (2) and (3) make it difficult to keep track of the variables\n", "in your program, and are the major source of bugs when you are\n", "first learning Python. Unfortunately, Jupyter notebooks do not\n", "help, and in fact make these features more difficult to handle. \n", "We will develop strategies to minimize\n", "these problems. \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Managing variables in a weakly-typed language (feature 2)\n", "\n", "\n", "Python does not force all variables to be declared with a type, as in Java and C,\n", "and this leads to problems. The main problem is that you create a variable\n", "accidentally with the same name, but different meaning. Here\n", "is a variable X being used in three different ways. Confusing? YES. " ] }, { "cell_type": "code", "execution_count": 200, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n", "hi\n", "['hi', 'folks']\n" ] } ], "source": [ "X = 4\n", "print(X)\n", "\n", "X = 'hi'\n", "print(X)\n", "\n", "X = [X, 'folks'] # The second X refers to the previous definition \n", "print(X)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You might think this is not a big deal, but if you make a habit of using only a small number of variable names\n", "such as X, Y, x, k, i, etc. and if these occur over the WHOLE range of your notebook, you will almost certainly have some confusion somewhere about what a variable means. \n", "\n", "Even worse, Python allows you to redefine the standard names of functions, so the following, if you uncomment the last two lines, \n", "creates a confusing bug:\n", "\n", "### TODO: \n", "\n", "In the next cell, remove the hash mark from the last two lines, to \"uncomment\" them. Run the cell, and observe that it\n", "seems fine. \n", "\n", "Now run it once more: it will generate a weird error, because the call to the constructor
list
\n",
"is now calling a list [2,5,4]. You've destroyed the binding between the variable list and its definition\n",
"in the standard library. \n",
"\n",
"Finally, put the hash marks back in, and hit `Restart & Run All` from the `Kernel` menu. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"NOTE: IF YOU GET A WEIRD BUG THAT MAKES NO SENSE, DO `Kernel -> Restart & Run All` BEFORE DOING ANYTHING ELSE. IT OFTEN FIXES THE PROBLEM. "
]
},
{
"cell_type": "code",
"execution_count": 201,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2 3 4]\n",
"[2, 3, 4]\n"
]
}
],
"source": [
"A = np.array([2,3,4])\n",
"print(A)\n",
"B = list(A) # the function list is a constructor for lists\n",
"print(B)\n",
"\n",
"#list = [2,5,4] # You are REDEFINING the variable list\n",
"#print(list)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Punchline: Use as few global variables as possible. Do NOT reuse common names (X, i, lst) as global variables. Do NOT use the `sum`, `list`, `sqrt` as variable names, as these are function names predefined in Python. \n",
"\n",
"Either write a function for each problem, storing everything as local variables, or give each global variable a unique name by adding the number of the problem. \n",
"\n",
"Example: Suppose you have the following code which is your solution to a Problem Four in a homework:"
]
},
{
"cell_type": "code",
"execution_count": 202,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2, 3, 4, 6]\n",
"[2, 5, 4]\n"
]
}
],
"source": [
"A = [2,3,4]\n",
"B = A + [6] \n",
"print(B)\n",
"\n",
"X = [2,5,4]\n",
"print(X)\n"
]
},
{
"cell_type": "code",
"execution_count": 203,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2, 3, 4, 6]\n",
"[2, 5, 4]\n"
]
}
],
"source": [
"# Here is a way of avoiding global variables by wrapping everything in a function (all variables local)\n",
"\n",
"def solution4():\n",
" A = [2,3,4]\n",
" B = A + [6] \n",
" print(B)\n",
"\n",
" X = [2,5,4]\n",
" print(X) \n",
" \n",
"solution4() # be sure to call it! \n"
]
},
{
"cell_type": "code",
"execution_count": 204,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2, 3, 4, 6]\n",
"[2, 5, 4]\n"
]
}
],
"source": [
"# Or simply add the problem number to the name:\n",
"\n",
"A4 = [2,3,4]\n",
"B4 = A4 + [6] \n",
"print(B4)\n",
"\n",
"X4 = [2,5,4]\n",
"print(X4)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Caveat: You do NOT need to do this for all variables, since local variables in for loops or functions\n",
"are not a problem. Use the usual variables x,y,i, X, etc. for local variables; there is\n",
"no problem with these. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Managing the global list of variable bindings (feature 3)\n",
"\n",
"Python is an interpreted language (feature 1) which uses a \"Read-Eval-Print\" loop to read\n",
"an expression, evaluate it, and print out the value. For definitions, such as\n",
"assignments and function definitions, there is also a change to the global master list\n",
"which holds all variable and function definitions. \n",
"\n",
"If you use unique global variable names, you should not have too much trouble with this,\n",
"but still there are strange things that happen if you don't know about this feature. \n",
"The problem is about \"old values\" which were stored in the past, even if you don't need them. \n",
"\n",
"Let us look at one example to show the problem, and you can keep a watch out for this.\n",
"\n",
"Suppose you write the following and run it:"
]
},
{
"cell_type": "code",
"execution_count": 205,
"metadata": {},
"outputs": [],
"source": [
"X = [1,2,3]"
]
},
{
"cell_type": "code",
"execution_count": 206,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3]"
]
},
"execution_count": 206,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"X"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now there is a binding in the global memory: X = [1,2,3]
\n",
"\n",
"But then suppose you change your mind and delete this statement. The problem is\n",
"that the binding is NOT removed unless you **Restart** the Kernel (in the Kernel menu). \n",
"\n",
"Thus, four hours later, you have completely forgotten about this X, and you write this\n",
"code, but you make a very small error, and leave out the '1' in 'X1'. It's hard\n",
"to see that the single character is missing, and when you run it, PYTHON \n",
"STILL HAS THE BINDING FOR X AND YOU WON'T KNOW ABOUT THE ERROR EXCEPT FOR THE RESULT\n",
"BEING WRONG. You'll have to see the missing '1'. "
]
},
{
"cell_type": "code",
"execution_count": 207,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 2]\n"
]
}
],
"source": [
"X1 = ['a','b','c','d','e','f','g']\n",
"\n",
"print( X[:2] ) # expecting to see ['a','b'] but Python finds the old value of X and doesn't complain"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### PUNCHLINE: If you have a nasty bug that you can't figure out, try Restart and Run All from the Kernel menu. ALWAYS Restart and Run All before submitting to make sure everything works as it is supposed to. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Plotting Points\n",
"\n",
"The scatter(...)
function is used to plot points from a list of x values and the associated y values. "
]
},
{
"cell_type": "code",
"execution_count": 208,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"This is the list of points: [(1, 2), (2, 3), (3, 6), (4, 8)]\n",
"They must be input to the function as separate lists:\n",
"\tX = [1, 2, 3, 4]\n",
"\tY = [2, 3, 6, 8] \n",
"\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"