Week 10

Lists

Demo: Lists

>>> abc = list('abc')
>>> abc
['a', 'b', 'c']
>>> a1 = ['a', 1]
>>> a1
['a', 1]
>>> abc[1]
'b'
>>> abc[1:3]
['a', 'b']
>>> len(abc)
3
>>> abc + a1
['a', 'b', 'c', 'a', 1]
>>> abc * 2
['a', 'b', 'c', 'a', 'b', 'c']
>>> 'b' in abc
True
>>> 'd' in abc
False
>>> 'd' not in abc
True
>>> abc.find('b')
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: 'list' object has no attribute 'find'
>>> abc.index('b')
1
>>> abc.index('d')
Traceback (most recent call last):
  File "", line 1, in 
ValueError: list.index(x): x not in list
>>>
>>> abc_copy = abc[:]
>>> abc_copy
['a', 'b', 'c']
>>> a[1] = 2
>>> abc
['a', 2, 'c']
>>> abc[1:3]
[2, 'c']
>>> del abc[1]
['a', 'c']
>>> abc_copy
['a', 'b', 'c']
>>> abc.append('b')
>>> abc
['a', 'c', 'b']
>>> abc.append([3])
>>> abc
['a', 'c', 'b', [3]]
>>> abc[3].append(4)
>>> abc
['a', 'c', 'b', [3, 4]]
>>> not []
True

The list data type and how lists are like strings

• Lists and strings are both called sequences in Python

  • both are an ordered collection of values that support indexing and slicing

  FYI Python has one other sequence type, tuples: they are similar to lists, but immutable

• The following operations work similarly on any sequence

  • indexing and slicing operators: _[_] and _[_:_]
  • concatenation and replication operators: + and *
  • membership operators: in and not in
  • len built-in function
  • index method

List indexing picture

How lists are unlike strings

• Values in lists may be anything, while strings contain only characters
• Lists are mutable (the element values and length of a list may change)
• Literal syntax: [ expression ,..., expression ]
• Printed form: [ literal ,..., literal ]
• Built-in type function: list
  • converts a string argument to a list of its characters
• Lists do not have a find method

List mutation

• List index operation may appear on the left-hand-side of an assignment statement
• The list append method adds an element to the end of a list (and returns None)
• The delete statement deletes from a list the element indicated by indexing
  • syntax: del list_expression [ index_expression ]
• The default values for slice indices are such that seq[:] returns a copy of seq
  • while there is no point in copying a string, list copies may be valuable, since mutation of a list does not change a previous copy of the list
• FYI Assignment and deletion of slices is also possible, but not used in this course

Example: my_sum

def my_sum(lon):
    """
    Returns the sum of the given list of numbers.
    >>> my_sum([3, 1, 5])
    9
    >>>
    """
    # The built-in function sum is similar, but a little more general
    # Hint: use a counted accumulating loop
    answer = 0
    index = 0
    while index < len(lon):
        answer = answer + lon[index]
        index = index + 1
    return answer

What is the value of [1,2][1]?

1. 2
2. [2]
3. [1,2,1]
4. [1]
5. syntax error
6. runtime error
7. none of the above

Answer: A

What is the value of [1,2] + [1]?

1. 3
2. [2]
3. [1,2,1]
4. [1]
5. syntax error
6. runtime error
7. none of the above

Answer: C

What is printed?

lst = [1]
lst = lst + 2
print lst

1. [1, 2]
2. [1, [2]]
3. 3
4. syntax error
5. runtime error

Answer: E

What is printed?

lst = [1]
lst + [2]
print lst

1. [1]
2. [1, [2]]
3. [1, 2]
4. syntax error
5. runtime error

Answer: A

What is printed?

lst = [1]
lst = lst + [2]
print lst

1. [1]
2. [1, [2]]
3. [1, 2]
4. syntax error
5. runtime error

Answer: C

What is printed?

lst = [1]
lst.append(2)
print lst

1. [1, 2]
2. [1, [2]]
3. 3
4. syntax error
5. runtime error

Answer: A

What is printed?

lst = [1]
lst.append([2])
print lst

1. [1, 2]
2. [1, [2]]
3. 3
4. syntax error
5. runtime error

Answer: B

What is the value of the expression?

([].append((3))[0]

1. [3]
2. 3
3. 0
4. syntax error
5. runtime error

Answer: D

What is the value of the expression?

[].append(3)[0] + [1]

1. [3]
2. 3
3. 0
4. syntax error
5. runtime error

Answer: E

Exercise: concatenate_strings

def concatenate_strings(los):
    """
    Return the result of concatenating all the strings in the given list of
    strings.
    >>> concatenate_strings(['spam', 'eggs'])
    'spameggs'
    >>>
    """
    # The same result may be obtained using the empty string join method,
    # as in ''.join(los)
    #.
    #.
    #.
    #.
    #.
    #.

Solution: concatenate_strings

def concatenate_strings(los):
    """
    Return the result of concatenating all the strings in the given list of
    strings.
    >>> concatenate_strings(['spam', 'eggs'])
    'spameggs'
    >>>
    """
    # The same result may be obtained using the empty string join method,
    # as in ''.join(los)
    answer = ''
    index = 0
    while index < len(los):
        answer = answer + los[index]
        index = index + 1
    return answer

Exercise: rfind

def rfind(lst, value):
    """
    Return the index of the right-most occurrence of the value
    in the list, or -1 if there is no occurrence of the value.
    >>> rfind(['a', 3, 'b'], 3)
    1
    >>> rfind(['a', 3, 'b'], 'c')
    -1
    >>>
    """
    # Hint: loop backwards (use an indexed loop that decrements the index)
    #.
    #.
    #.
    #.
    #.
    #.

Solution: rfind

def rfind(lst, value):
    """
    Return the index of the right-most occurrence of the value
    in the list, or -1 if there is no occurrence of the value.
    >>> rfind(['a', 3, 'b'], 3)
    1
    >>> rfind(['a', 3, 'b'], 'c')
    -1
    >>>
    """
    # Hint: loop backwards (use an indexed loop that decrements the index)
    index = len(lst) - 1
    while index >= 0:
        if lst[index] == value:
            return index
        index = index - 1
    return -1

Appending to a list

• The list method append(value) modifies the list by adding the value at the end of the list (and returns None):

  >>> a = [1, 2]
  >>> a.append('b')
  >>> a
  [1, 2, 'b']
  

• This is more efficient than creating a new list formed by concatenating the original list with a list of one element, as in:

  >>> a = [1, 2, 'b']
  >>> a = a + ['c']
  >>> a
  [1, 2, 'b', 'c']
  

Exercise: my_range

def my_range(n):
    """
    Return a list of the numbers 0, 1, ..., n-1.
    >>> my_range(4)
    [0, 1, 2, 3]
    >>>
    """
    # This is the same as the built-in function range with one argument
    #.
    #.
    #.
    #.
    #.
    #.

Solution: my_range

def my_range(n):
    """
    Return a list of the numbers 0, 1, ..., n-1.
    >>> my_range(4)
    [0, 1, 2, 3]
    >>>
    """
    # This is the same as the built-in function range with one argument
    answer = []
    count = 0
    while count < n:
        answer.append(count)
        count = count + 1
    return answer

Elementwise operations

• Operations that is performed on elements that have the same index in more than one sequence are called elementwise operations
  • they are very common
  • they require an indexed loop

Exercise: add_lists

def add_lists(lst1, lst2):
    """
    Return the result of adding the given lists elementwise.
    >>> add_lists([1, 2], [3, 4])
    [4, 6]
    >>>
    """
    # Hint: use an indexed accumulating loop and the list method append
    #.
    #.
    #.
    #.
    #.
    #.

Solution: add_lists

def add_lists(lst1, lst2):
    """
    Return the result of adding the given lists elementwise.
    >>> add_lists([1, 2], [3, 4])
    [4, 6]
    >>>
    """
    # Hint: use an indexed accumulating loop and the list method append
    index = 0
    answer = []
    while index < len(lst1):
        answer.append(lst1[index] + lst2[index])
        index = index + 1
    return answer

Mutation example: extend_list

• Compare the following function with concatenate_lists on the following slide, which does not use mutation

def extend_list(extended_list, appended_list):
    """
    Extend extended_list by appending the elements in appended_list.
    Return None.
    >>> a = range(3)
    >>> b = list('abc')
    >>> extend_list(a, b)
    >>> a
    [0, 1, 2, 'a', 'b', 'c']
    >>>
    """
    index = 0
    while index < len(appended_list):
        extended_list.append(appended_list[index])
        index = index + 1

Example: concatenate_lists

def concatenate_lists(lst1, lst2):
    """
    Return a new list obtained by concatenating the elements of lst1 and
    lst2.
    >>> a = range(3)
    >>> b = list('abc')
    >>> concatenate_lists(a, b)
    [0, 1, 2, 'a', 'b', 'c']
    >>> a
    [0, 1, 2]
    >>>
    """
    return lst1 + lst2

Do not mutate a given list unless told to do so!

• If the specification of a function or other program element says that a given list (usually a parameter value) is to be modified, then do so, but otherwise, do not modify lists you are given
  • of course you can modify lists you create, but be sure that is consistent with your program design
• Always be aware of the difference between a function that is to have the side effect of modifying one or more given lists (and probably return None), and one that is to return a new list
  • this is related to the difference between printing (an operation with a side-effect) and returning a value

Exercise: elementwise_add_to_list

def elementwise_add_to_list(lst1, lst2):
    """
    Replace each value in lst1 with the result of adding to it
    the corresponding value in lst2.
    >>> lst = [1, 2]
    >>> elementwise_add_to_list(lst, [3, 4])
    >>> lst
    [4, 6]
    >>>
    """
    #.
    #.
    #.
    #.

Solution: elementwise_add_to_list

def elementwise_add_to_list(lst1, lst2):
    """
    Replace each value in lst1 with the result of adding to it
    the corresponding value in lst2.
    >>> lst = [1, 2]
    >>> elementwise_add_to_list(lst, [3, 4])
    >>> lst
    [4, 6]
    >>>
    """
    index = 0
    while index < len(lst1):
        lst1[index] = lst1[index] + lst2[index]
        index = index + 1