Home > Articles

  • Print
  • + Share This
This chapter is from the book

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 [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:

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:

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-16-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
  • + Share This
  • 🔖 Save To Your Account