Upload
gyles-owen
View
216
Download
0
Embed Size (px)
Citation preview
EECS 110: Lec 8: Lists of Lists
Aleksandar Kuzmanovic
Northwestern University
http://networks.cs.northwestern.edu/EECS110-s15/
Midterm and Final (officially)
• Midterm:– Wednesday 4/29/2015– 9:30am – 11:30am– Tech L361
• Final:– Wednesday 6/3/2015– 9:30am – 11:30am– Tech L361
Hw #3 due Sunday…
hw3pr1.py
EECS 110 today
'Krphzrun 3, Sureohp 3: Wkh Fhdvdu Flskhu'
hw3pr2.py
Computing with language
Computing with images
hw3pr3.py
"Quiz"
def bestNumber( L ): """ returns the # in L closest to 42 """
def mode( L ): """ returns the element appearing most often in L """
Name(s):Nothing but the best!
Hint: Consider defining a helper function !
Hints: abs( x ) is built-in to PythonUse bestWord as a guide:
Write this function using max/min or recursively :
Write this function however you like:
def bestWord( L ): """ example code """ LOL = [ [scsc(w), w] for w in L ] bestPair = max( LOL ) return bestPair[1]
"Quiz" Solutions…
def bestNumber( L ): """ returns the # in L closest to 42 ""“ LOL = [ [abs(w-42), w] for w in L ] bestPair = min( LOL ) return bestPair[1]
Write this function using max/min:
Hints: abs( x ) is built-in to PythonUse bestWord as a guide:
def bestWord( L ): """ example code """ LOL = [ [scsc(w), w] for w in L ] bestPair = max( LOL ) return bestPair[1]
"Quiz" Solutions…
def mode( L ): """ returns the element appearing most often in L """ LOL = [[numberOfTimes(w,L),w] for w in L] return max(LOL)[1]
Hint: Consider defining a helper function !Write this function however you like:
def numberOfTimes( w, L ): """ returns the # in times w repeats in L """ return sum([k==w for k in L])
Sorting a List
Sorting a List
What data do we need to keep track of?
What is the input/output of the function?
Sorting a List
Sorting a List
If we had an easy way to find the maximum of the list, how could we use this to sort the list?
Taking only one…
def removeOne( e, L ): """ this function removes one element e from the top level of the list L """ if len(L) == 0: return L # L is empty
elif e == L[0]: return L[1:] # remove this one else: return L[0:1] + removeOne(e,L[1:]) # keep the non-e element and then keep going
removeOne(42, [5,7,42,8,42])[5,7,8,42]
removeOne('p', 'computer programming') 'comuter programming'
sort(L)
def sort( L ):
""" a list of elements in L, sorted from hi to low """
if len(L) < 1:
return L
else:
sort(L)
def sort( L ):
""" a list of elements in L, sorted from hi to low """
if len(L) < 1:
return L
else:
return [max(L)] + sort(removeOne( max(L), L ))
sort(L, maxFun)
def sort( L, maxFun ):
""" a list of elements in L, sorted using maxFun """
if len(L) < 1:
return L
else:
return
sort(L, maxFun)
def sort( L, maxFun ):
""" a list of elements in L, sorted using maxFun """
if len(L) < 1:
return L
else:
return [maxFun(L)] + sort(removeOne( maxFun(L), L ))
Will this work?
sort(L, maxFun)
def sort( L, maxFun ):
""" a list of elements in L, sorted using maxFun """
if len(L) < 1:
return L
else:
return [maxFun(L)] + sort(removeOne( maxFun(L), L ), maxFun)
sort(L, maxFun)
def sort( L, maxFun ):
""" a list of elements in L, sorted using maxFun """
if len(L) < 1:
return L
else:
return [maxFun(L)] + sort(removeOne( maxFun(L), L ), maxFun)
What happens if you call
>>>sort( L, min )
Lights On!
http://www.whitman.edu/mathematics/lights_out/
Comprehending List Comprehensions
def runGenerations( L ): """ runGenerations keeps running evolve... """ print( L ) # display the list, L time.sleep(0.5) # pause a bit newL = evolve( L ) # evolve L into newL runGenerations( newL ) # recurse
def evolve( L ): """ evolve takes in a list of integers, L, and returns a new list of integers considered to be the "next generation" """ N = len(L) # N now holds the size of the list L return [ setNewElement( L, i ) for i in range(N) ]
def setNewElement( L, i, x=0 ): """ setNewElement returns the NEW list's ith element input L: any list of integers input i: the index of the new element to return input x: an extra, optional input for future use """ return L[i] + 1
Comprehending List Comprehensions
def evolve( L ): """ evolve takes in a list of integers, L, and returns a new list of integers considered to be the "next generation" """ N = len(L) # N now holds the size of the list L return [ setNewElement( L, i ) for i in range(N) ]
def setNewElement( L, i, x=0 ): """ setNewElement returns the NEW list's ith element input L: any list of integers input i: the index of the new element to return input x: an extra, optional input for future use """ return L[i] + 1
L>>> L = [42, 43, 44, 45, 46]>>> evolve(L)
0 1 2 3 4 5
42 43 44 45 46 47
N 5 (i.e., len(L))
Comprehending List Comprehensions
def evolve( L ): """ evolve takes in a list of integers, L, and returns a new list of integers considered to be the "next generation" """ N = len(L) # N now holds the size of the list L return [ setNewElement( L, i ) for i in range(N) ]
def setNewElement( L, i, x=0 ): """ setNewElement returns the NEW list's ith element input L: any list of integers input i: the index of the new element to return input x: an extra, optional input for future use """ return L[i] + 1 L>>> L = [42, 43, 44, 45, 46]>>> evolve(L)
0 1 2 3 4
N 5 (i.e., len(L))[ setNewElement( L, i ) for i in range(5) ]
[0, 1, 2, 3, 4]
[42, 43, 44, 45, 46]
[ , , , , ]0 1 2 3 4i
Comprehending List Comprehensions
def evolve( L ): """ evolve takes in a list of integers, L, and returns a new list of integers considered to be the "next generation" """ N = len(L) # N now holds the size of the list L return [ setNewElement( L, i ) for i in range(N) ]
def setNewElement( L, i, x=0 ): """ setNewElement returns the NEW list's ith element input L: any list of integers input i: the index of the new element to return input x: an extra, optional input for future use """ return L[i] + 1
>>> L = [[42, 43], [44, 45]]>>> evolve(L)[[43, 44], [45, 46]]
[ setNewElement( L, i ) for i in range(2) ]
L0 1
N 2 (i.e., len(L))
[[42, 43], [44, 45]]
What is i? What is L[i]?
Comprehending List Comprehensions
def evolve( L ): """ evolve takes in a list of integers, L, and returns a new list of integers considered to be the "next generation" """ N = len(L) # N now holds the size of the list L return [ setNewElement( L, i ) for i in range(N) ]
def setNewElement( L, i, x=0 ): """ setNewElement returns the NEW list's ith element input L: any list of integers input i: the index of the new element to return input x: an extra, optional input for future use """ return L[i] + 1
>>> L = [[42, 43], [44, 45]]>>> evolve(L)[[43, 44], [45, 46]]
[ setNewElement( L, i ) for i in range(2) ]
L0 1
N 2 (i.e., len(L))
[[42, 43], [44, 45]]
What is i? What is L[i]?
Going deeper
Comprehending List Comprehensions
[ L[j][0] for j in range(2) ] L [[42, 43], [44, 45]]
[ [L[0][i]] for i in range(2) ]
[ [ L[j][i]+1 for i in range(2) ] for j in range(2) ]
Comprehending List Comprehensions
L [[42, 43], [44, 45]]
[ setNewElement2d( L, i, j ) for i in range(2) ] for j in range(2) ]
def setNewElement2d( L, i, j, x=0, y=0 ): """ setNewElement returns the NEW list's ith element input L: any list of integers input i: the index of the new element to return input x: an extra, optional input for future use """ return L[j][i] + 1
Representing Pictures
Digital representations of pictures
Grid of Pixels—each Pixelhas a color
But how is color represented?
RGB Model for Representing Color
• Most popular, but not only one
• Each pixel represented in three parts
(100, 0, 0)
R G B
Color “levels”
• Each color component or “channel” is represented with a single byte– 1 byte = 8 bits; which can represent numbers from 0
to 255 (2^8 – 1)– Each RGB value is between 0 and 255– Examples…
http://www.colorschemer.com/online.html
http://www.drpeterjones.com/colorcalc/
(255, 255, 255): white
(150, 150, 150): gray
Brightening a Picture
def modify(pic): """ modify modifies an image to make it brighter """ pixels = getPixels(pic) if len(pixels) == 0: return newPixels = [ [setNewPixel( pixels, row, col ) for col in range(len(pixels[0]))] for row in range(len(pixels))] setPixels(pic, newPixels)
def setNewPixel( pixels, row, col ): """ setNewPixel returns the NEW imanges (row, col) (r,g,b) value input pixels: a 2D list containing RGB information in the
pixels in a picture input row: the row of the pixel in question input col: the column of the pixel in question """ rval= min(pixels[row][col][0]+30, 255) gval = min(pixels[row][col][1]+30, 255) bval = min(pixels[row][col][2]+30, 255) return (rval, gval, bval)
Representing the Pixels in a Picture
pixels:[ [(3, 10, 100), (3, 11, 110)], [(3, 10, 200), (10, 110, 290)] ]
Width: len(pixels[0])
Height: len(pixels)
2x2 pixel image
Tuples vs. Lists
[ [(3, 10, 100), (3, 11, 110)], [(3, 10, 200), (10, 110, 290)] ]
Tuples use ( ); lists use [ ]But otherwise, they are the same…
(for now, almost)
>>> t = (1, 2, 3)>>> t[1]2>>> t[1:](2, 3)>>> (x, y, z) = t>>> x1 >>> y2
def modify(pic): """ modify modifies an image to make it brighter """ pixels = getPixels(pic) if len(pixels) == 0: return newPixels = [ [setNewPixel( pixels, row, col ) for col in range(len(pixels[0]))] for row in range(len(pixels))] setPixels(pic, newPixels)
def setNewPixel( pixels, row, col ): """ setNewPixel returns the NEW imanges (row, col) (r,g,b) value input pixels: a 2D list containing RGB information in the
pixels in a picture input row: the row of the pixel in question input col: the column of the pixel in question """ rval= min(pixels[row][col][0]+30, 255) gval = min(pixels[row][col][1]+30, 255) bval = min(pixels[row][col][2]+30, 255) return (rval, gval, bval)
Brightening a Picture
"Quiz“
Want more? How would you turn only the sky red?
Name(s):It's all clear to me now!
Write a function that tints the top half of the picture red (how red is up to you):
def setNewPixel( pixels, row, col ): """ setNewPixel returns the NEW image's (row, col) (r,g,b) value """
Write a function that copies the top half of an image to the bottom half.
def setNewPixel( pixels, row, col ): """ setNewPixel returns the NEW image's (row, col) (r,g,b) value """
"Quiz“
Want more? How would you turn only the sky red?
Name(s):It's all clear to me now!
Write a function that tints the top half of the picture red (how red is up to you):
def setNewPixel( pixels, row, col ): """ setNewPixel returns the NEW image's (row, col) (r,g,b) value """ if row <= len(pixels)//2:
rval = min(pixels[row][col][0]+75,255) else:
rval = pixels[row][col][0] return (rval, pixels[row][col][1], pixels[row][col][2])
Write a function that copies the top half of an image to the bottom half.
def setNewPixel( pixels, row, col ): """ setNewPixel returns the NEW image's (row, col) (r,g,b) value """
"Quiz“
Want more? How would you turn only the sky red?
Name(s):It's all clear to me now!
Write a function that tints the top half of the picture red (how red is up to you):
def setNewPixel( pixels, row, col ): """ setNewPixel returns the NEW image's (row, col) (r,g,b) value """ if row <= len(pixels)//2:
rval = min(pixels[row][col][0]+75,255) else:
rval = pixels[row][col][0] return (rval, pixels[row][col][1], pixels[row][col][2])
Write a function that copies the top half of an image to the bottom half.
def setNewPixel( pixels, row, col ): """ setNewPixel returns the NEW image's (row, col) (r,g,b) value """ if row > len(pixels)//2:
return pixels[row-len(pixels)//2][col] else:
return pixels[row][col]
…
Caesar Cipher: encipher
encipher( 'gv vw dtwvg' , 0 )
encipher( 'gv vw dtwvg' , 1 )
encipher( 'gv vw dtwvg' , 2 )
encipher( 'gv vw dtwvg' , 3 )
encipher( 'gv vw dtwvg' , 4 )
encipher( 'gv vw dtwvg' , 5 )
encipher( 'gv vw dtwvg' , 25 )
returns
returns
returns
returns
returns
returns
returns
'gv vw dtwvg'
'hw wx euxwh'
'ix xy fvyxi'
'jy yz gwzyj'
'kz za hxazk'
'la ab iybal'
'fu uv csvuf'
encipher( S , n )should return the string s with each
alphabetic character shifted/wrapped by n places in the alphabet
How Strings are Represented and Stored?
ASCII is a table that tells the
computer how to represent
characters as bits!
8 bits = 1 byte
The SAME bits represent integers, if the variable has type int instead of
str
American Standard Code for Information Interchange
type: str
type: int
00101010
00101010
bits
bits
name:
name:
value:
value:
'*'
42
Identical bits are stored in each
variable!
The types determine how to interpret the bits; the names don't matter at all…
ASCII
ASCII is a table that tells the
computer how to represent
characters as #s
American Standard Code for Information Interchange
chr
ordconvert to number
convert to char.
chr and ord
chr( n )
ord( c )
Input: an integer in range(255)
Input: a string of one character, c
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZASCII
VALUES
Output: a one-char. string of that ASCII value
Output: an integer, the ASCII value of cCONVERTERS
97 122
65 90
99 101 103 105 107 109 111 113 115 117 119
67 69 71 73 75 77 79 81 83 8785
[ [i,chr(i)] for i in range(128) ]
[ ord(i) for i in '**** CS! ****' ]
try these!
chr and ord
chr(66) is ?
ord('a') is ?
abcdefghijklmnopqrstuvwxyz97 122
65ABCDEFGHIJKLMNOPQRSTUVWXYZ
90
ASCII
VALUES
What is chr( ord('i')+13 ) ?
What is chr( ord('P')+13 ) ?
99 101 103 105 107 109 111 113 115 117 119
67 69 71 73 75 77 79 81 83 8785
chr and ord
chr(66) is ?
ord('a') is 97
abcdefghijklmnopqrstuvwxyz97 122
65ABCDEFGHIJKLMNOPQRSTUVWXYZ
90
ASCII
VALUES
What is chr( ord('i')+13 ) ?
What is chr( ord('P')+13 ) ?
99 101 103 105 107 109 111 113 115 117 119
67 69 71 73 75 77 79 81 83 8785
chr and ord
chr(66) is 'B'
ord('a') is 97
abcdefghijklmnopqrstuvwxyz97 122
65ABCDEFGHIJKLMNOPQRSTUVWXYZ
90
ASCII
VALUES
What is chr( ord('i')+13 ) ?
What is chr( ord('P')+13 ) ?
99 101 103 105 107 109 111 113 115 117 119
67 69 71 73 75 77 79 81 83 8785
chr and ord
chr(66) is 'B'
ord('a') is 97
abcdefghijklmnopqrstuvwxyz97 122
65ABCDEFGHIJKLMNOPQRSTUVWXYZ
90
ASCII
VALUES
What is chr( ord('i')+13 )'v'
What is chr( ord('P')+13 ) ?
99 101 103 105 107 109 111 113 115 117 119
67 69 71 73 75 77 79 81 83 8785
chr and ord
chr(66) is 'B'
ord('a') is 97
abcdefghijklmnopqrstuvwxyz97 122
65ABCDEFGHIJKLMNOPQRSTUVWXYZ
90
ASCII
VALUES
What is chr( ord('i')+13 )'v'
What is chr( ord('P')+13 ) ']'
How can we wrap this around?
99 101 103 105 107 109 111 113 115 117 119
67 69 71 73 75 77 79 81 83 8785
Rot 13
def adv13( c ): """ rotates c by 13 chars, "wrapping" as needed NON-LETTERS DO NOT CHANGE! """ if 'a' <= c <= 'z': neword = ord(c) + 13 if neword <= ord('z'):
return chr(neword) # no wrapping else:
return
elif
else:
How would you rotate an entire string?
Rot 13
def adv13( c ): """ rotates c by 13 chars, "wrapping" as needed NON-LETTERS DO NOT CHANGE! """ if 'a' <= c <= 'z': neword = ord(c) + 13 if neword <= ord('z'):
return chr(neword) # no wrapping else:
return chr(ord('a')+neword-ord('z')-1)
elif
else:
How would you rotate an entire string?
Rot 13
def adv13( c ): """ rotates c by 13 chars, "wrapping" as needed NON-LETTERS DO NOT CHANGE! """ if 'a' <= c <= 'z': neword = ord(c) + 13 if neword <= ord('z'):
return chr(neword) # no wrapping else:
return chr(ord('a')+neword-ord('z')-1)
elif 'A' <= c <= 'Z': # same as above, only use 'A' and 'Z' else:
return c
How would you rotate an entire string?
Caesar Cipher: decipher
>>> decipher('Bzdrzq bhogdq? H oqdedq Bzdrzq rzkzc.')'Caesar cipher? I prefer Caesar salad.'
>>> decipher('Hu lkbjhapvu pz doha ylthpuz hmaly dl mvynla '\ 'lclyfaopun dl ohcl slhyulk.')'An education is what remains after we forget everything we have learned.'
But how ?
>>> decipher('Uifz xpsl ju pvu xjui b qfodjm!')
>>> decipher('gv vw dtwvg')
Caesar Cipher: decipher
>>> decipher('gv vw dtwvg')
Caesar Brutus
Strategy using max:(1) consider all possible answers
(2) give them each a score
(3) use our techniques to get max
gv vw dtwvghw wx euxwhix xy fvyxijy yz gwzyjkz za hxazkla ab iybalmb bc jzcbmnc cd kadcnod de lbedope ef mcfepqf fg ndgfqrg gh oehgrsh hi pfihsti ij qgjituj jk rhkjuvk kl silkvwl lm tjmlwxm mn uknmxyn no vlonyzo op wmpozap pq xnqpabq qr yorqbcr rs zpsrcds st aqtsdet tu brutefu uv csvufall 26 possibilities
Score for "Englishness"?
up to you…
Caesar Cipher: decipher
>>> decipher('gv vw dtwvg')'od de lbedo'
Caesar Brutus
Strategy using max:(1) consider all possible answers
(2) give them each a score
(3) use our techniques with max
[0, 'cr rs zpsrc'][0, 'gv vw dtwvg'][0, 'jy yz gwzyj'][0, 'mb bc jzcbm'][0, 'qf fg ndgfq'][0, 'wl lm tjmlw'][1, 'bq qr yorqb'][1, 'ds st aqtsd'][1, 'nc cd kadcn'][1, 'vk kl silkv'][1, 'xm mn uknmx'][2, 'ap pq xnqpa'][2, 'hw wx euxwh'][2, 'ix xy fvyxi'][2, 'kz za hxazk'][2, 'rg gh oehgr'][2, 'sh hi pfihs'][2, 'uj jk rhkju'][2, 'yn no vlony'][3, 'fu uv csvuf'][3, 'pe ef mcfep'][3, 'ti ij qgjit'][3, 'zo op wmpoz'][4, 'et tu brute'][4, 'la ab iybal'][4, 'od de lbedo']all 26 possibilities
won't always be correct!
number-of-vowels score
Caesar Cipher: decipher
>>> decipher('gv vw dtwvg')'et tu brute'
Caesar Brutus
Strategy using max:(1) consider all possible answers
(2) give them each a score
(3) use our techniques with max
[0.4680, 'jy yz gwzyj'][0.4960, 'mb bc jzcbm'][0.5420, 'uj jk rhkju'][0.5567, 'ix xy fvyxi'][0.5597, 'qf fg ndgfq'][0.5718, 'fu uv csvuf'][0.5753, 'bq qr yorqb'][0.5833, 'kz za hxazk'][0.5859, 'xm mn uknmx'][0.5880, 'gv vw dtwvg'][0.5902, 'vk kl silkv'][0.6110, 'ap pq xnqpa'][0.6304, 'zo op wmpoz'][0.6318, 'wl lm tjmlw'][0.6717, 'cr rs zpsrc'][0.6735, 'hw wx euxwh'][0.6963, 'nc cd kadcn'][0.7153, 'ti ij qgjit'][0.7398, 'la ab iybal'][0.7442, 'yn no vlony'][0.7867, 'pe ef mcfep'][0.7880, 'sh hi pfihs'][0.7918, 'rg gh oehgr'][0.8213, 'ds st aqtsd'][0.8609, 'od de lbedo'][0.9082, 'et tu brute']all 26 possibilities
letter- probability
scorenot always correct, but
better!
'Weet bksa ed Xecumeha 3!'