 • Print
This chapter is from the book

## 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 : c = [-45, 6, 0, 72, 1543]

In : c
Out: [-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:

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

```In : c
Out: -45

In : c
Out: 1543```

#### Determining a List’s Length

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

```In : len(c)
Out: 5```

#### Accessing Elements from the End of the List with Negative Indices

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

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

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

In : c[-5]
Out: -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 : a = 1

In : b = 2

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

Using a non-integer index value causes a TypeError.

#### Lists Are Mutable

Lists are mutable—their elements can be modified:

```In : c = 17

In : c
Out: [-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 : s = 'hello'

In : s
Out: 'h'

In : s = 'H'
-------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-15-812ef2514689> in <module>()
----> 1 s = '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 : c
-------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-16-9a31ea1e1a13> in <module>()
----> 1 c

IndexError: list index out   of range```

#### Using List Elements in Expressions

List elements may be used as variables in expressions:

```In : c + c + c
Out: -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 : a_list = []

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

In : a_list
Out: [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 ’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 : letters = []

In : letters += 'Python'

In : letters
Out: ['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 : list1 = [10, 20, 30]

In : list2 = [40, 50]

In : concatenated_list = list1 + list2

In : concatenated_list
Out: [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 : 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 : a = [1, 2, 3]

In : b = [1, 2, 3]

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

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

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

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

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