# How to Sort a List of Tuples in Python

• 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 [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```