In the Codes and Other Secrets chapter, we introduced the idea of a string as a sequential collection of characters. Each string is considered to be ordered from left to right, and each individual character can be accessed using the indexing operation. Provided that our data items can be thought of as characters, a string might make the perfect collection mechanism.

As an example, assume that we have just taken a multiple-choice exam where each question has five possible answers labeled A, B, C, D, and E. Our answer sheet might look like this:

1. A

2. B

3. E

4. A

5. D

6. B

7. B

8. A

9. C

10. E

To store our answers for later processing, we could use a simple string of 10 characters. The string will contain the 10 data items gathered from the student:

This technique allows us easy access to each individual answer. Furthermore, using iteration over strings, we can process the entire exam. However, some potential drawbacks arise with this approach. What if the exam was in math class, where we have to solve number problems and write down our final answer? Now the answers are numbers instead of characters. Can a string still be used?

For example, suppose this is our answer sheet for a math exam:

1. 34

2. 56

3. 2

4. 652

5. 26

6. 1

7. 99

8. 865

9. 22

10. 16

If we attempt to use the same string-based storage technique, we might get something like this:

It is easy to see that we have a real problem. How can we distinguish which numbers correspond to each answer?

In this case, we need a way to store collections of integers instead of being restricted to just using characters. As with the string, where there is one character per position, we would like an organization technique that can provide one integer per position. Fortunately, there is such a collection—the list.

A list is a collection that is very similar to a string in general structure, but has some specific differences that must be understood for the list to be used properly. FIGURE 4.1 shows that strings and lists are examples of sequential collections.

A list is an ordered, sequential collection of zero or more Python data objects. Lists are written as comma-delimited values enclosed in square brackets. We call a list with zero data objects the empty list, which is represented simply by []. Recall that strings are homogeneous collections because each item in the collection is the same type of object—a character. Lists, by contrast, are heterogeneous collections because lists can be composed of a mixture of any kind of object. In SESSION 4.1, the list myList consists of two integers, a floating-point value, and a string.

As with other values in Python, asking the interpreter to evaluate a list will simply return the list itself. To remember the list for later processing, we need to assign the list to a variable. Evaluating the variable then returns the list. FIGURE 4.2 shows the sequential organization of the items in the example list in Session 4.1.

Since lists are sequential, many operations that can be applied to any Python sequence, such as strings, can be applied to lists as well. TABLE 4.1 reviews these operations, and SESSION 4.2 gives examples of their use. Note that the last example in Session 4.2 introduces the del statement (see TABLE 4.2), which allows you to delete an item from a list. This operation is not permitted on strings. Strings are immutable collections of data in which individual items within the string cannot be changed. That is not true for lists: We can change an individual member of a list by using the assignment statement and placing the indexed location on the left-hand side. Thus, lists are mutable collections of data; that is, lists can be modified.

Note that the indexes for lists, as with strings, start with 0. The slice operation myList[1:3] returns a list of items starting with the item indexed by 1 up to, but not including, the item indexed by 3.

SESSION 4.3 shows an assignment statement modifying the item at index 2 in the list changeList. The reference diagram in FIGURE 4.3 shows that a list is a collection of references to Python objects. Changing an item in the list simply changes the reference stored at that position. Note that after item 2 has been changed, the previous reference is deleted, as indicated by a dotted line in the figure. As shown in Session 4.3, attempting to change an item in a string using the same operation will not work; the Python interpreter reports an error because strings do not support the ability to change a single character.

The use of the repetition operator (*) is also affected by this idea of a collection of references. The result of using the * operator is a repetition of references to the data objects in the sequence. This can best be seen by considering the statements in SESSION 4.4.

The notation [myList] means we have a list containing one item, whose value is a reference to the list myList. Hence, it is a list containing a list. The variable listOfMyList holds a collection of three references to the original list, myList. Note that a change to one element of myList shows up in all three occurrences in listOfMyList. This outcome occurs because the repetition operation is implemented as a list of three references to the same list, as shown in FIGURE 4.4.

A useful function for creating lists is the list built-in function, which converts other sequences to lists. We have already seen two such sequences: strings and ranges. Recall that the range function returns an object representing a sequence of integers. SESSION 4.5 demonstrates the use of list to create some simple lists from strings and ranges.

Lists support a number of other useful methods, as summarized in TABLE 4.3. Examples of their use can be seen in SESSION 4.6.

You can see that some of the methods, such as pop, return a value and also modify the list. Others, such as reverse and sort, simply modify the list with no return value. Although pop will default to the end of the list, it can also remove and return an item at a specific index location. Also notice the familiar “dot” notation, which is used when asking an object to invoke a method. You can read myList.append(False) as “ask the object myList to perform its append method using the value False as a parameter.” All data objects invoke methods in this way.

Before leaving this section, we will describe one additional string method—split, shown in TABLE 4.4. This method takes a string as a parameter that indicates the places to break the string into substrings; the substrings are returned in a list. By default, if no parameter is passed to split, it will break the string using one or more spaces or tabs as the delimiter. In Python, spaces and tabs are considered to be whitespace. The split method discards the delimiter. SESSION 4.7 demonstrates how the split method works.