Mutants

• The most important difference between strings and lists is one of mutability
  • Strings we have already identified as being immutable: you can not change the individual elements
  • Lists, in contrast, are mutable, which means that we can change or assign new values to the elements of a list
• Immutable objects have many advantages in programming:
  • You don’t have to worry about if the values will change
  • Immutable values can be more easily shared
  • Immutable objects are easier to use with concurrent programs
• In some situations though, mutable objects are the perfect tool for the job

Locations in Memory

>>> A = 5
>>> id(A)
129257497672776
>>> B = 5
>>> id(B)
129257497672776
>>> C = [5]
>>> id(C)
129257425943936
>>> D = [5]
>>> id(D)
129257426156544

For Reference

• When working with mutable objects, it is better to think of the variable as holding a reference to the object, rather than the actual contents of the object
• I find it useful to think of a reference as the “address” in memory where that object’s contents can be found
  • The treasure map showing where you can find the object!
• This undeniably complicates things, as referencing a mutable object lets you change it, which will immediately be reflected in anything else that referenced that object!
• Mutable objects can be terrific to work with, as their mutability makes them very flexible, but be wary of unexpected behavior

Following along Mutable Lists

cool = ['blue', 'violet']
warm = ['red', 'orange']

colors = [cool, warm]
other_colors = [['blue', 'violet'],
                ['red', 'orange']]

print(colors == other_colors)
print(colors is other_colors)

cool[0] = 'indigo'
warm = ['orange', 'yellow']

print(colors)
print(other_colors)

Lists as Arguments

• When you pass a list as an argument to a function or return a list as a result, only the reference to the list is actually passed back and forth
• This means that the elements of the list are effectively shared between the function and the caller
  • Changes that the function makes to the elements will persist after the function returns
• Example of reversing a list in PythonTutor: here

Sneaky Mutability

• List’s mutability can frequently be very nice to work with, but as with lists as arguments to functions, you need to be careful in some instances to ensure you understand how Python is treating the list
• I’ve encountered a few other problems where it can be easy to mess up:
  • Initializing a list to look like another list, wanting to make changes and then compare it to the original
    • Example
  • Looping over a mutating list
    • Example

Cloning

• What can we do in these sorts of instances to not let mutability trip us up?
• Clone the list instead of just assigning a reference
  • Creates a new object in memory
• Several ways you can make a shallow clone (in code)
  • Using the .copy() list method
  • Any slice always returns a new object
  • Using the list() function will return a new object

Common Useful List Methods

Functions on Iterators

• The .sort and .reverse methods reorder the list in place and do not return anything
• Commonly, you might want to loop through a list in a particular order, but not change the original list
• Python gives you two matching functions to do this, which return a new ordered version of the list, without changing the original
  • The reversed() function creates a new iterable object that returns its elements in the opposite order
  • The sorted() function creates a new iterable object that returns its elements in ascending order

Understanding Check

A = [
     'Fox',
     'Giraffe', 
     'Hippo'
    ]
A.append('Iguana')
A[:].reverse()
B = A
for anim in B:
    if anim[1] == 'i':
        B.remove(anim)
print(A)

List building with loops

• Commonly will make lists with a simple:

  even_digits = [ 2, 4, 6, 8 ]

• But in many cases, it is easier to specify the elements of a list using a sequence of values generated by a for loop. For instance

  even_digits = [ ]
  for i in range(0, 10, 2):
      even_digits.append(i)

• Python gives us a shorthand notation to achieve this:

  even_digits = [ i for i in range(0, 10, 2) ]

  • Called list comprehension

Comprehending Lists

• The simplest list comprehension syntax is:

  [ |||expression||| |||iterator||| ]

  where |||expression||| is any Python expression and |||iterator||| is a for loop header

• The iterator component can be followed by any number of additional modifiers

  • More for loop headers for nested loops
  • or if statements to select specific values

• Example: all even numbers to 20 not also visible by 3

  [i for i in range(0,2,20) if i % 3 != 0]

Where Strings and Lists Meet

• There are a handful of methods that transition between strings and lists

Tabulation

• Arrays can also be useful when you have a set of values and you need to count how many values fall into a different ranges
  • Process is called tabulation
• The idea is that for each piece of data we encounter, we figure out a corresponding index in our tabular array and then increment the value of that element
• Your book shows this for seeing how many times each letter of the alphabet appears in a text sequence
• Let’s instead look at an example of determining how many students got different letters grades on a made-up final