- 5.1 Introduction
- 5.2 Lists
- 5.3 Tuples
- 5.4 Unpacking Sequences
- 5.5 Sequence Slicing
- 5.6 del Statement
- 5.7 Passing Lists to Functions
- 5.8 Sorting Lists
- 5.9 Searching Sequences
- 5.10 Other List Methods
- 5.11 Simulating Stacks with Lists
- 5.12 List Comprehensions
- 5.13 Generator Expressions
- 5.14 Filter, Map and Reduce
- 5.15 Other Sequence Processing Functions
- 5.16 Two-Dimensional Lists
- 5.17 Intro to Data Science: Simulation and Static Visualizations
- 5.18 Wrap-Up
This chapter is from the book
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