5.2 Lists

Here, we discuss lists in more detail and explain how to refer to particular list elements. Many of the capabilities shown in this section apply to all sequence types.

Creating a List

Lists typically store homogeneous data, that is, values of the same data type. Consider the list c, which contains five integer elements:

In [1]: c = [-45, 6, 0, 72, 1543]

In [2]: c
Out[2]: [-45, 6, 0, 72, 1543]

They also may store heterogeneous data, that is, data of many different types. For example, the following list contains a student’s first name (a string), last name (a string), grade point average (a float) and graduation year (an int):

['Mary', 'Smith', 3.57, 2022]

Accessing Elements of a List

You reference a list element by writing the list’s name followed by the element’s index (that is, its position number) enclosed in square brackets ([], known as the subscription operator). The following diagram shows the list c labeled with its element names:

5.2-1 Full Alternative Text

The first element in a list has the index 0. So, in the five-element list c, the first element is named c[0] and the last is c[4]:

In [3]: c[0]
Out[3]: -45

In [4]: c[4]
Out[4]: 1543

Determining a List’s Length

To get a list’s length, use the built-in len function:

In [5]: len(c)
Out[5]: 5

Accessing Elements from the End of the List with Negative Indices

Lists also can be accessed from the end by using negative indices:

5.2-2 Full Alternative Text

So, list c’s last element (c[4]), can be accessed with c[-1] and its first element with c[-5]:

In [6]: c[-1]
Out[6]: 1543

In [7]: c[-5]
Out[7]: -45

Indices Must Be Integers or Integer Expressions

An index must be an integer or integer expression (or a slice, as we’ll soon see):

In [8]: a = 1

In [9]: b = 2

In [10]: c[a + b]
Out[10]: 72

Using a non-integer index value causes a TypeError.

Lists Are Mutable

Lists are mutable—their elements can be modified:

In [11]: c[4] = 17

In [12]: c
Out[12]: [-45, 6, 0, 72, 17]

You’ll soon see that you also can insert and delete elements, changing the list’s length.

Some Sequences Are Immutable

Python’s string and tuple sequences are immutable—they cannot be modified. You can get the individual characters in a string, but attempting to assign a new value to one of the characters causes a TypeError:

In [13]: s = 'hello'

In [14]: s[0]
Out[14]: 'h'

In [15]: s[0] = 'H'
-------------------------------------------------------------------------
TypeError                               Traceback (most recent call last)
<ipython-input-15-812ef2514689> in <module>()
----> 1 s[0] = 'H'

TypeError: 'str' object does not support item assignment

Attempting to Access a Nonexistent Element

Using an out-of-range list, tuple or string index causes an IndexError:

In [16]: c[100]
-------------------------------------------------------------------------
IndexError                              Traceback (most recent call last)
<ipython-input-19-9a31ea1e1a13> in <module>()
----> 1 c[100]

IndexError: list index out of range

Using List Elements in Expressions

List elements may be used as variables in expressions:

In [17]: c[0] + c[1] + c[2]
Out[17]: -39

Appending to a List with +=

Let’s start with an empty list [], then use a for statement and += to append the values 1 through 5 to the list—the list grows dynamically to accommodate each item:

In [18]: a_list = []

In [19]: for number in range(1, 6):
    ...:     a_list += [number]
    ...:

In [20]: a_list
Out[20]: [1, 2, 3, 4, 5]

When the left operand of += is a list, the right operand must be an iterable; otherwise, a TypeError occurs. In snippet [19]’s suite, the square brackets around number create a one-element list, which we append to a_list. If the right operand contains multiple elements, += appends them all. The following appends the characters of 'Python' to the list letters:

In [21]: letters = []

In [22]: letters += 'Python'

In [23]: letters
Out[23]: ['P', 'y', 't', 'h', 'o', 'n']

If the right operand of += is a tuple, its elements also are appended to the list. Later in the chapter, we’ll use the list method append to add items to a list.

Concatenating Lists with +

You can concatenate two lists, two tuples or two strings using the + operator. The result is a new sequence of the same type containing the left operand’s elements followed by the right operand’s elements. The original sequences are unchanged:

In [24]: list1 = [10, 20, 30]

In [25]: list2 = [40, 50]

In [26]: concatenated_list = list1 + list2

In [27]: concatenated_list
Out[27]: [10, 20, 30, 40, 50]

A TypeError occurs if the + operator’s operands are difference sequence types—for example, concatenating a list and a tuple is an error.

Using for and range to Access List Indices and Values

List elements also can be accessed via their indices and the subscription operator ([]):

In [28]: for i in range(len(concatenated_list)):
    ...:     print(f'{i}: {concatenated_list[i]}')
    ...:
0: 10
1: 20
2: 30
3: 40
4: 50

The function call range(len(concatenated_list)) produces a sequence of integers representing concatenated_list’s indices (in this case, 0 through 4). When looping in this manner, you must ensure that indices remain in range. Soon, we’ll show a safer way to access element indices and values using built-in function enumerate.

Comparison Operators

You can compare entire lists element-by-element using comparison operators:

In [29]: a = [1, 2, 3]

In [30]: b = [1, 2, 3]

In [31]: c = [1, 2, 3, 4]

In [32]: a == b # True: corresponding elements in both are equal
Out[32]: True

In [33]: a == c # False: a and c have different elements and lengths
Out[33]: False

In [34]: a < c # True: a has fewer elements than c
Out[34]: True

In [35]: c >= b # True: elements 0-2 are equal but c has more elements
Out[35]: True

Self Check

1. (Fill-In) Python’s string and tuple sequences are _____—they cannot be modified.
   Answer: immutable.

2. (True/False) The + operator’s sequence operands may be of any sequence type.
   Answer: False. The + operator’s operand sequences must have the same type; otherwise, a TypeError occurs.

3. (IPython Session) Create a function cube_list that cubes each element of a list. Call the function with the list numbers containing 1 through 10. Show numbers after the call.
   Answer:

   In [1]: def cube_list(values):
      ...:     for i in range(len(values)):
      ...:         values[i] **= 3
      ...:
   
   In [2]: numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   
   In [3]: cube_list(numbers)
   
   In [4]: numbers
   Out[4]: [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
   

4. (IPython Session) Use an empty list named characters and a += augmented assignment statement to convert the string 'Birthday' into a list of its characters.
   Answer:

   In [5]: characters = []
   
   In [6]: characters += 'Birthday'
   
   In [7]: characters
   Out[7]: ['B', 'i', 'r', 't', 'h', 'd', 'a', 'y']