EECS 110: Lec 8: Lists of Lists Aleksandar Kuzmanovic Northwestern University

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)



if len(L) < 1:

return L

else:

return [maxFun(L)] + sort(removeOne( maxFun(L), L ))

Will this work?

sort(L, maxFun)



if len(L) < 1:

return L

else:

return [maxFun(L)] + sort(removeOne( maxFun(L), L ), maxFun)

sort(L, 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/

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




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))



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




>>> 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]?




>>> 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


[ 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) ]


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

http://www.colorschemer.com/online.html

http://www.drpeterjones.com/colorcalc/

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.


"Quiz“




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])



"Quiz“




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])


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 )







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



90

ASCII

VALUES



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



90

ASCII

VALUES



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



90

ASCII

VALUES

What is chr( ord('i')+13 )'v'


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



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



return chr(ord('a')+neword-ord('z')-1)

elif

else:


Rot 13



return chr(ord('a')+neword-ord('z')-1)

elif 'A' <= c <= 'Z': # same as above, only use 'A' and 'Z' else:

return c


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')


>>> 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…


>>> decipher('gv vw dtwvg')'od de lbedo'

Caesar Brutus



(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


>>> decipher('gv vw dtwvg')'et tu brute'

Caesar Brutus



(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!'

EECS 110: Lec 8: Lists of Lists Aleksandar Kuzmanovic Northwestern University

Documents

Transcript of EECS 110: Lec 8: Lists of Lists Aleksandar Kuzmanovic Northwestern University