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]

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[0] and the last is c[4]:

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

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

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

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

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

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

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—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.

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

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

List elements may be used as variables in expressions:

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

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.

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.

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.

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