{ "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", "" ] }, { "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", "\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": [
"plot(...)
instead of scatter(...)
you will display a curve created by connecting the points with straight lines. Essentially you can only plot straight lines between points, but if the points are close together, you will not notice, and it will look like a smooth curve. "
]
},
{
"cell_type": "code",
"execution_count": 209,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"bar(...)
we get a bar chart:"
]
},
{
"cell_type": "code",
"execution_count": 213,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"hist(...)
it will create a histogram counting how many of each value occur; this list can be unordered;\n",
"- You will get a cleaner display if you specify where the edges of the bins are, and make sure the edges of the bins are visible, as shown in this example:"
]
},
{
"cell_type": "code",
"execution_count": 216,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"