EECS 110: Lec 12: Mutable Data Aleksandar Kuzmanovic Northwestern University

>>> diff([7, 0, 6, 4]) 1 "Quiz" Print a list of strings with the specified format def diff( L ): Return the min difference between any 2 elements in L You need determine each element's index… Example: You can assume at least 2 elements in the list Only consider unsigned differences. >>> items = [“coke”, “pepsi”, “sprite”] >>> printItems(items) 0 : coke 1 : pepsi 2 : sprite def printItems( items ): Name(s):_______________________________ Hint: use a NESTED loop

"Quiz" part 1: Print Items >>> items = [“coke”, “pepsi”, “sprite”] >>> printItems(items) 0 : coke 1 : pepsi 2 : sprite

"Quiz" part 1: Print Items >>> items = [“coke”, “pepsi”, “sprite”] >>> printItems(items) 0 : coke 1 : pepsi 2 : sprite def printItems(items): for x in range(len(items)): print(x,”:”,items[x])

"Quiz" part 1: Print Items >>> items = [“coke”, “pepsi”, “sprite”] >>> printItems(items) 0:coke 1:pepsi 2:sprite def printItems(items): for x in range(len(items)): print(str(x)+”:”+items[x])

>>> diff([7, 0, 6, 4]) 1 "Quiz" Part 2 def diff( L ): Return the min difference between any 2 elements in L Example: You can assume at least 2 elements in the list Only consider unsigned differences. Hint: use a NESTED loop

>>> diff([7, 0, 6, 4]) 1 "Quiz" Part 2 def diff( L ): mindif = abs(L[1] – L[0]) for i in range(len(L)-1): for j in range(i+1,len(L)): d = abs(L[i]-L[j]) if d < mindiff: mindiff = d return mindif Return the min difference between any 2 elements in L Example: You can assume at least 2 elements in the list Only consider unsigned differences. Hint: use a NESTED loop

EECS 110 Today infinitely nested structure… HW 5 Preview: Pr 1 (Lab): The Game of Life Pr 2: Markov Text Generation required optional Pr 3: ASCII Art Pr 4: A program that reads Pr 5: Gaussian Elimination

Mutable vs. Immutable data Changeable types: dictionary Unchangeable types: list tuple string int float bool

Functions and (immutable) Variables def fact(a): result = 1 while a > 0: result *= a a -= 1 return result >>> x = 5 >>> y = fact(x) >>> x ??

Functions and (immutable) Variables def fact(a): result = 1 while a > 0: result *= a a -= 1 return result >>> x = 5 >>> y = fact(x) >>> x 5

Functions and (immutable) Variables def swap(a, b): temp = a a = b b = temp >>> x = 5 >>> y = 10 >>> swap(x, y) >>> print(x, y) ?? x y a b temp

Functions and (immutable) Variables def swap(a, b): temp = a a = b b = temp >>> x = 5 >>> y = 10 >>> swap(x, y) >>> print(x, y) 5, 10 x y a b temp

Functions and Mutable Types def swap(L, i1, i2): temp = L[i1] L[i1] = L[i2] L[i2] = temp >>> MyL = [2, 3, 4, 1] >>> swap(myL, 0, 3) >>> print(myL) ?? RAM MyL L i1 i

Functions and Mutable Types def swap(L, i1, i2): temp = L[i1] L[i1] = L[i2] L[i2] = temp >>> MyL = [2, 3, 4, 1] >>> swap(myL, 0, 3) >>> print(myL) [1,3,4,2] RAM MyL L i1 i

Reference vs. Value Mutable types: dictionary Unmutable types: list tuple string int float bool L L[0]L[1]L[2] Reference, Pointer, id L = [5,42,'hi'] L 5 42 'hi' 42 L = 42

“Pass By Value” def main(): """ calls conform """ print(" Welcome to Conformity, Inc. ”) fav = 7 conform(fav) print(" My favorite number is", fav) def conform(fav): """ sets input to 42 """ fav = 42 return fav 7 fav

7 “Pass By Value” def main(): """ calls conform """ print " Welcome to Conformity, Inc. " fav = 7 conform(fav) print " My favorite number is", fav def conform(fav): """ sets input to 42 """ fav = 42 return fav 7 fav PASS BY VALUE “Pass by value” means that data is copied when sent to a method 42

Passing lists by value… def main() """ calls conform2 """ print " Welcome to Conformity, Inc. " fav = [ 7, 11 ] conform2(fav) print " My favorite numbers are", fav def conform2(fav) """ sets all of fav to 42 """ fav[0] = 42 fav[1] = 42 What gets passed by value here? fav L[0]L[1] 7 11 fav

Passing lists by value… def main(): """ calls conform2 """ print " Welcome to Conformity, Inc. " fav = [ 7, 11 ] conform2(fav) print " My favorite numbers are", fav def conform2(fav): """ sets all of fav to 42 """ fav[0] = 42 fav[1] = 42 fav L[0]L[1] 7 11 fav can change data elsewhere! The reference is copied!

The conclusion You can change the contents of lists in functions that take those lists as input. Those changes will be visible everywhere. (actually, lists or any mutable objects) (immutable objects are safe, however)

More examples def zeroOdd1( L ): for i in range(len(L)): if L[i] % 2 == 1: L[i] = 0 def zeroOdd2( L ): for i in L: if i % 2 == 1: i = 0 >>> L = [1, 2, 3, 4, 5] >>> zeroOdd1(L) >>> L ?? >>> L = [1, 2, 3, 4, 5] >>> zeroOdd2(L) >>> L

More examples def zeroOdd1( L ): for i in range(len(L)): if L[i] % 2 == 1: L[i] = 0 def zeroOdd2( L ): for i in L: if i % 2 == 1: i = 0 >>> L = [1, 2, 3, 4, 5] >>> zeroOdd1(L) >>> L [0,2,0,4,0] >>> L = [1, 2, 3, 4, 5] >>> zeroOdd2(L) >>> L ??

More examples def zeroOdd1( L ): for i in range(len(L)): if L[i] % 2 == 1: L[i] = 0 def zeroOdd2( L ): for i in L: if i % 2 == 1: i = 0 >>> L = [1, 2, 3, 4, 5] >>> zeroOdd1(L) >>> L [0,2,0,4,0] >>> L = [1, 2, 3, 4, 5] >>> zeroOdd2(L) >>> L [1,2,3,4,5]

Lists’ flexibility Lists can hold ANY type of data A = [ 42., 75., 70. ] float list A they don’t have to be horizontal lists!

double list A they don’t have to be horizontal lists! Lists’ flexibility Lists can hold ANY type of data A = [ 42., 75., 70. ] float list A

Lists’ flexibility Lists can hold ANY type of data double list A int list A “go” “red” “sox!” String list A

2d lists or arrays Lists can hold ANY type of data -- including lists ! list A A = [ [1,2,3,4], [5,6], [7,8,9,10,11] ]

list A 2d arrays list A[0] A[1] A[2] Lists can hold ANY type of data -- including lists ! A = [ [1,2,3,4], [5,6], [7,8,9,10,11] ]

list A Jagged arrays list A[0] A[1] A[2] Lists can hold ANY type of data -- including lists ! A = [ [1,2,3,4], [5,6], [7,8,9,10,11] ] Rows within 2d arrays need not be the same length…

list A A[0] A[1] A[2] Lists can hold ANY type of data -- including lists ! A = [ [1,2,3,4], [5,6], [7,8,9,10,11] ] Rows within 2d arrays need not be the same length… We will not use jagged arrays at least in hw 5

Rectangular arrays Handling rectangular arrays … list A A[0] A[1] A[2] How many rows does A have, in general ? How many columns does A have, in general ? A[2][3] A[0][0]

Rectangular arrays Handling rectangular arrays … list A A[0] A[1] A[2] How many rows does A have, in general ? How many columns does A have, in general ? A[2][3] A[0][0] len(A)

Rectangular arrays Handling rectangular arrays … list A A[0] A[1] A[2] How many rows does A have, in general ? How many columns does A have, in general ? A[2][3] A[0][0] len(A) len(A[0])

Which one works? How could we create a rectangular array (of default data, 0 ), given its height and width ? or A = [ [0]*width ]*height A = [ [0]*height ]*width

Which one works? How could we create a rectangular array (of default data, 0 ), given its height and width ? A = [ [0]*width ]*height A = [ [0]*height ]*width

What's really going on? A = [ [0]*width ]*height inner = [0]*width A = [inner]*height

Creating a 2d array def create2dArray( width, height ): """ does just that """ A = [] # start with nothing for row in range( height ): for col in range( width ):

Creating a 2d array def create2dArray( width, height ): """ does just that """ A = [] # start with nothing for row in range( height ): A = A + [[]] for col in range( width ): A[row] = A[row] + [0] return A

"Quiz" What are the values of A, B, C and D at the indicated points? def mystery1(L1, L2): S = L1 for i in range(len(L2)): S[i] += L2[i] return L2 def mystery2(L1, L2): S = [0]*len(L1) for i in range(len(L2)): S[i] = L1[i] + L2[i] >>> A = [22, 10, 30] >>> B = [20, 32, 12] >>> C = [] >>> D = [] >>> C = mystery1(A, B) >>> D = mystery2(A, B) ) 2) 3) Name(s)__________________________________

"Quiz" def mystery1(L1, L2): S = L1 for i in range(len(L2)): S[i] += L2[i] return L2 def mystery2(L1, L2): S = [0]*len(L1) for i in range(len(L2)): S[i] = L1[i] + L2[i] >>> A = [22, 10, 30] >>> B = [20, 32, 12] >>> C = [] >>> D = [] >>> C = mystery1(A, B) >>> D = mystery2(A, B) ) 2) 3) Name(s)__________________________________ A: [22, 10, 30] B: [20, 32, 12] C: [] D: [] What are the values of A, B, C and D at the indicated points?

"Quiz" def mystery1(L1, L2): S = L1 for i in range(len(L2)): S[i] += L2[i] return L2 def mystery2(L1, L2): S = [0]*len(L1) for i in range(len(L2)): S[i] = L1[i] + L2[i] >>> A = [22, 10, 30] >>> B = [20, 32, 12] >>> C = [] >>> D = [] >>> C = mystery1(A, B) >>> D = mystery2(A, B) ) 2) 3) Name(s)__________________________________ A: [22, 10, 30] B: [20, 32, 12] C: [] D: [] A: [22, 10, 30] B: [20, 32, 12] C: [20, 32, 12] D: [] What are the values of A, B, C and D at the indicated points?

"Quiz" def mystery1(L1, L2): S = L1 for i in range(len(L2)): S[i] += L2[i] return L2 def mystery2(L1, L2): S = [0]*len(L1) for i in range(len(L2)): S[i] = L1[i] + L2[i] >>> A = [22, 10, 30] >>> B = [20, 32, 12] >>> C = [] >>> D = [] >>> C = mystery1(A, B) >>> D = mystery2(A, B) ) 2) 3) Name(s)__________________________________ A: [22, 10, 30] B: [20, 32, 12] C: [] D: [] A: [22, 10, 30] B: [20, 32, 12] C: [20, 32, 12] D: [] A: [22, 10, 30] B: [20, 32, 12] C: [20, 32, 12] D: None What are the values of A, B, C and D at the indicated points?

+= mutates Mutable Data (lists) WARNING: For mutable data types, the following are NOT the same A = [] B = A A += [42, 42] A = [] B = A A = A + [42, 42] NOT THE SAME! MUTATES A (B changes too) COPIES A (B does not change)

The Game of Life: History Created by John Horton Conway, a British Mathematician Inspired by a problem presented by John Von Neumann: –Build a hypothetical machine that can build copies of itself First presented in 1970, Scientific American

Problem 1 -- “Life” Evolutionary rules Grid World Everything depends on a cell’s eight neighbors red cells are alive white cells are empty Exactly 3 neighbors give birth to a new, live cell! Exactly 2 or 3 neighbors keep an existing cell alive Any other number of neighbors kill the central cell (or keep it dead)

Problem 1 -- Life Evolutionary rules Grid World Everything depends on a cell’s eight neighbors red cells are alive white cells are empty Exactly 3 neighbors give birth to a new, live cell! Exactly 2 or 3 neighbors keep an existing cell alive Any other number of neighbors kill the central cell (or keep it dead)

Problem 1 -- Life Evolutionary rules Grid World Everything depends on a cell’s eight neighbors red cells are alive white cells are empty Exactly 3 neighbors give birth to a new, live cell! Exactly 2 or 3 neighbors keep an existing cell alive Any other number of neighbors kill the central cell (or keep it dead)

Problem 1 -- Life Evolutionary rules Grid World Everything depends on a cell’s eight neighbors red cells are alive white cells are empty Exactly 3 neighbors give birth to a new, live cell! Exactly 2 or 3 neighbors keep an existing cell alive Any other number of neighbors kill the central cell (or keep it dead) life out there... Keep going!

Problem 1 -- Creating Life updateNextLife(oldB, newB) old generation or "board" new generation or "board"

Problem 1 -- Creating Life old generation or "board" new generation or "board" updateNextLife(oldB, newB)

Problem 1 -- Details For each generation… 0 represents an empty cell 1 represents a living cell outermost edge should always be left empty (even if there are 3 neighbors) compute all cells based on their previous neighbors old generation or "board" new generation or "board" life out there... updateNextLife(oldB, newB)

Problem 1 – Main Loop def life( width, height ): """ will become John Conway's Game of Life... """ B = createBoard(width, height) csplot.showAndClickInIdle(B) while True: # run forever csplot.show(B) # show current B time.sleep(0.25) # pause a bit oldB = B B = createBoard( width, height ) updateNextLife( oldB, B ) # gets a new board

Problem 1 – Main Loop def life( width, height ): """ will become John Conway's Game of Life... """ B = createBoard(width, height) csplot.showAndClickInIdle(B) while True: # run forever csplot.show(B) # show current B time.sleep(0.25) # pause a bit oldB = B B = createBoard( width, height ) updateNextLife( oldB, B ) # gets a new board Why not just have update RETURN a new list? (i.e., why bother with mutation at all?) Update MUTATES the list B

Problem 1 -- to  and beyond! Are there stable life configurations? Are there oscillating life configurations? Are there self-propagating life configurations? "rocks" "plants" "animals" period 3 period 2

Problem 1 -- to  and beyond! Are there life configurations that expand forever? What is the largest amount of the life universe that can be filled with cells? How sophisticated can the structures in the life universe be? Are all feasible configurations reachable?

See you in Lab!