# Chapter 5. Lists, tuples, and sets – The Quick Python Book

## Chapter 5. Lists, tuples, and sets

This chapter covers

• Manipulating lists and list indices
• Modifying lists
• Sorting
• Using common list operations
• Handling nested lists and deep copies
• Using tuples
• Creating and using sets

In this chapter, we’ll discuss the two major Python sequence types: lists and tuples. At first, lists may remind you of arrays in many other languages, but don’t be fooled—lists are a good deal more flexible and powerful than plain arrays. This chapter also discusses a newer Python collection type: sets. Sets are useful when an object’s membership in the collection, as opposed to its position, is important.

Tuples are like lists that can’t be modified—you can think of them as a restricted type of list or as a basic record type. We’ll discuss why we need such a restricted data type later in the chapter.

Most of the chapter is devoted to lists, because if you understand lists, you pretty much understand tuples. The last part of the chapter discusses the differences between lists and tuples, in both functional and design terms.

### 5.1. Lists are like arrays

A list in Python is much the same thing as an array in Java or C or any other language. It’s an ordered collection of objects. You create a listd by enclosing a comma-separated list of elements in square brackets, like so:

`# This assigns a three-element list to xx = [1, 2, 3]`

Note that you don’t have to worry about declaring the list or fixing its size ahead of time. This line creates the list as well as assigns it, and a list automatically grows or shrinks in size as needed.

Arrays in Python

A typed array module is available in Python that provides arrays based on C data types. Information on its use can be found in the Python Library Reference. I suggest you look into it only if you run into a situation where you really need the performance improvement. If a situation calls for numerical computations, you should consider using NumPy, mentioned in section 4.6.3, available at www.scipy.org.

Unlike lists in many other languages, Python lists can contain different types of elements; a list element can be any Python object. Here’s a list that contains a variety of elements:

`# First element is a number, second is a string, third is another list.x = [2, "two", [1, 2, 3]]`

Probably the most basic built-in list function is the len function, which returns the number of elements in a list:

`>>> x = [2, "two", [1, 2, 3]]>>> len(x)3`

Note that the len function doesn’t count the items in the inner, nested list.

### 5.2. List indices

Understanding how list indices work will make Python much more useful to you. Please read the whole section!

Elements can be extracted from a Python list using a notation like C’s array indexing. Like C and many other languages, Python starts counting from 0; asking for element 0 returns the first element of the list, asking for element 1 returns the second element, and so forth. Here are a few examples:

`>>> x = ["first", "second", "third", "fourth"]>>> x[0]'first'>>> x[2]'third'`

But Python indexing is more flexible than C indexing; if indices are negative numbers, they indicate positions counting from the end of the list, with –1 being the last position in the list, –2 being the second-to-last position, and so forth. Continuing with the same list x, we can do the following:

`>>> a = x[-1]>>> a'fourth'>>> x[-2]'third'`

For operations involving a single list index, it’s generally satisfactory to think of the index as pointing at a particular element in the list. For more advanced operations, it’s more correct to think of list indices as indicating positions between elements. In the list ["first", "second", "third", "fourth"], you can think of the indices as pointing like this:

x =[

"first",

"second",

"third",

"fourth"

]

Positive indices 0   1   2   3
Negative indices –4   –3   –2   –1

This is irrelevant when you’re extracting a single element, but Python can extract or assign to an entire sublist at once, an operation known as slicing. Instead of entering list[index] to extract the item just after index, enter list[index1:index2] to extract all items including index1 and up to (but not including) index2 into a new list. Here are some examples:

`>>> x = ["first", "second", "third", "fourth"]>>> x[1:-1]['second', 'third']>>> x[0:3]['first', 'second', 'third']>>> x[-2:-1]['third']`

It may seem reasonable that if the second index indicates a position in the list before the first index, this would return the elements between those indices in reverse order, but this isn’t what happens. Instead, this return: an empty list:

`>>> x[-1:2][]`

When slicing a list, it’s also possible to leave out index1 or index2. Leaving out index1 means “go from the beginning of the list,” and leaving out index2 means “go to the end of the list”:

`>>> x[:3]['first', 'second', 'third']>>> x[2:]['third', 'fourth']`

Omitting both indices makes a new list that goes from the beginning to the end of the original list; that is, it copies the list. This is useful when you wish to make a copy that you can modify, without affecting the original list:

`>>> y = x[:]>>> y[0] = '1 st'>>> y['1 st', 'second', 'third', 'fourth']>>> x['first', 'second', 'third', 'fourth']`

### 5.3. Modifying lists

You can use list index notation to modify a list as well as to extract an element from it. Put the index on the left side of the assignment operator:

`>>> x = [1, 2, 3, 4]>>> x[1] = "two">>> x[1, 'two', 3, 4]`

Slice notation can be used here too. Saying something like lista[index1:index2] = listb causes all elements of lista between index1 and index2 to be replaced with the elements in listb. listb can have more or fewer elements than are removed from lista, in which case the length of lista will be altered. You can use slice assignment to do a number of different things, as shown here:

Appending a single element to a list is such a common operation that there’s a special append method to do it:

`>>> x = [1, 2, 3]>>> x.append("four")>>> x[1, 2, 3, 'four']`

One problem can occur if you try to append one list to another. The list gets appended as a single element of the main list:

`>>> x = [1, 2, 3, 4]>>> y = [5, 6, 7]>>> x.append(y)>>> x[1, 2, 3, 4, [5, 6, 7]]`

The extend method is like the append method, except that it allows you to add one list to another:

`>>> x = [1, 2, 3, 4]>>> y = [5, 6, 7]>>> x.extend(y)>>> x[1, 2, 3, 4, 5, 6, 7]`

There is also a special insert method to insert new list elements between two existing elements or at the front of the list. insert is used as a method of lists and takes two additional arguments; the first is the index position in the list where the new element should be inserted, and the second is the new element itself:

`>>> x = [1, 2, 3]>>> x.insert(2, "hello")>>> print(x)[1, 2, 'hello', 3]>>> x.insert(0, "start")>>> print(x)['start', 1, 2, 'hello', 3]`

insert understands list indices as discussed in the section on slice notation, but for most uses it’s easiest to think of list.insert(n, elem) as meaning insert elem just before the nth element of list. insert is just a convenience method. Anything that can be done with insert can also be done using slice assignment; that is, list.insert(n, elem) is the same thing as list[n:n] = [elem] when n is nonnegative. Using insert makes for somewhat more readable code, and insert even handles negative indices:

`>>> x = [1, 2, 3]>>> x.insert(-1, "hello")>>> print(x)[1, 2, 'hello', 3]`

The del statement is the preferred method of deleting list items or slices. It doesn’t do anything that can’t be done with slice assignment, but it’s usually easier to remember and easier to read:

`>>> x = ['a', 2, 'c', 7, 9, 11]>>> del x[1]>>> x['a', 'c', 7, 9, 11]>>> del x[:2]>>> x[7, 9, 11]`

In general, del list[n] does the same thing as list[n:n+1] = [], whereas del list[m:n] does the same thing as list[m:n] = [].

The remove method isn’t the converse of insert. Whereas insert inserts an element at a specified location, remove looks for the first instance of a given value in a list and removes that value from the list:

`>>> x = [1, 2, 3, 4, 3, 5]>>> x.remove(3)>>> x[1, 2, 4, 3, 5]>>> x.remove(3)>>> x[1, 2, 4, 5]>>> x.remove(3)Traceback (innermost last): File "<stdin>", line 1, in ?ValueError: list.remove(x): x not in list`

If remove can’t find anything to remove, it raises an error. You can catch this error using the exception-handling abilities of Python, or you can avoid the problem by using in to check for the presence of something in a list before attempting to remove it.

The reverse method is a more specialized list modification method. It efficiently reverses a list in place:

`>>> x = [1, 3, 5, 6, 7]>>> x.reverse()>>> x[7, 6, 5, 3, 1]`

### 5.4. Sorting lists

Lists can be sorted using the built-in Python sort method:

`>>> x = [3, 8, 4, 0, 2, 1]>>> x.sort()>>> x[0, 1, 2, 3, 4, 8]`

This does an in-place sort—that is, it changes the list being sorted. To sort a list without changing the original list, make a copy of it first.

`>>> x = [2, 4, 1, 3]>>> y = x[:]>>> y.sort()>>> y[1, 2, 3, 4]>>> x[2, 4, 1, 3]`

Sorting works with strings, too:

`>>> x = ["Life", "Is", "Enchanting"]>>> x.sort()>>> x['Enchanting', 'Is', 'Life']`

The sort method can sort just about anything, because Python can compare just about anything. But there is one caveat in sorting. The default key method used by sort requires that all items in the list be of comparable types. That means that using the sort method on a list containing both numbers and strings will raise an exception:

`>>> x = [1, 2, 'hello', 3]>>> x.sort()Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: unorderable types: str() < int()`

On the other hand, we can sort a list of lists:

`>>> x = [[3, 5], [2, 9], [2, 3], [4, 1], [3, 2]]>>> x.sort()>>> x[[2, 3], [2, 9], [3, 2], [3, 5], [4, 1]]`

According to the built-in Python rules for comparing complex objects, the sublists are sorted first by ascending first element and then by ascending second element.

sort is even more flexible than this—it’s possible to use your own key function to determine how elements of a list are sorted.

#### 5.4.1. Custom sorting

To use custom sorting, you need to be able to define functions, something we haven’t talked about. In this section we’ll also use the fact that len(string) returns the number of characters in a string. String operations are discussed more fully in chapter 6.

By default, sort uses built-in Python comparison functions to determine ordering, which is satisfactory for most purposes. There will be times, though, when you want to sort a list in a way that doesn’t correspond to this default ordering. For example, let’s say we wish to sort a list of words by the number of characters in each word, in contrast to the lexicographic sort that would normally be carried out by Python.

To do this, write a function that will return the value, or key, that we want to sort on, and use it with the sort method. That function in the context of sort is a function that takes one argument and returns the key or value the sort function is to use.

For our number-of-characters ordering, a suitable key function could be

`def compare_num_of_chars(string1):    return len(string1)`

This key function is trivial. It passes the length of each string back to the sort method, rather than the strings themselves.

After you define the key function, using it is a matter of passing it to the sort method using the key keyword. Because functions are Python objects, they can be passed around like any other Python object. Here’s a small program that illustrates the difference between a default sort and our custom sort:

`>>> def compare_num_of_chars(string1):...     return len(string1)>>> word_list = ['Python', 'is', 'better', 'than', 'C']>>> word_list.sort()>>> print(word_list)['C', 'Python', 'better', 'is', 'than']>>> word_list = ['Python', 'is', 'better', 'than', 'C']>>> word_list.sort(key=compare_num_of_chars)>>> print(word_list)['C', 'is', 'than', 'Python', 'better']`

The first list is in lexicographic order (with uppercase coming before lowercase), and the second list is ordered by ascending number of characters.

Custom sorting is very useful, but if performance is critical, it may be slower than the default. Usually this impact is minimal, but if the key function is particularly complex, the effect may be more than desired, especially for sorts involving hundreds of thousands or millions of elements.

One particular place to avoid custom sorts is where you want to sort a list in descending, rather than ascending, order. In this case, use the sort method’s reverse parameter set to True. If for some reason you don’t want to do that, it’s still better to sort the list normally and then use the reverse method to invert the order of the resulting list. These two operations together—the standard sort and the reverse—will still be much faster than a custom sort.

#### 5.4.2. The sorted() function

Lists have a built-in method to sort themselves, but other iterables in Python, like the keys of a dictionary, for example, don’t have a sort method. Python also has the built-in function sorted(), which returns a sorted list from any iterable. sorted() uses the same key and reverse parameters as the sort method:

`>>> x = (4, 3, 1, 2)>>> y = sorted(x)>>> y[1, 2, 3, 4]`

### 5.5. Other common list operations

A number of other list methods are frequently useful, but they don’t fall into any specific category.

#### 5.5.1. List membership with the in operator

It’s easy to test if a value is in a list using the in operator, which returns a Boolean value. You can also use the converse, the not in operator:

`>>> 3 in [1, 3, 4, 5]True>>> 3 not in [1, 3, 4, 5]False>>> 3 in ["one", "two", "three"]False>>> 3 not in ["one", "two", "three"]True`

#### 5.5.2. List concatenation with the + operator

To create a list by concatenating two existing lists, use the + (list concatenation) operator. This will leave the argument lists unchanged.

`>>> z = [1, 2, 3] + [4, 5]>>> z[1, 2, 3, 4, 5]`

#### 5.5.3. List initialization with the * operator

Use the * operator to produce a list of a given size, which is initialized to a given value. This is a common operation for working with large lists whose size is known ahead of time. Although you can use append to add elements and automatically expand the list as needed, you obtain greater efficiency by using * to correctly size the list at the start of the program. A list that doesn’t change in size doesn’t incur any memory reallocation overhead:

`>>> z = [None] * 4>>> z[None, None, None, None]`

When used with lists in this manner, * (which in this context is called the list multiplication operator) replicates the given list the indicated number of times and joins all the copies to form a new list. This is the standard Python method for defining a list of a given size ahead of time. A list containing a single instance of None is commonly used in list multiplication, but the list can be anything:

`>>> z = [3, 1] * 2>>> z[3, 1, 3, 1]`

#### 5.5.4. List minimum or maximum with min and max

You can use min and max to find the smallest and largest elements in a list. You’ll probably use these mostly with numerical lists, but they can be used with lists containing any type of element. Trying to find the maximum or minimum object in a set of objects of different types causes an error if it doesn’t make sense to compare those types:

`>>> min([3, 7, 0, -2, 11])-2>>> max([4, "Hello", [1, 2]])Traceback (most recent call last):  File "<pyshell#58>", line 1, in <module>    max([4, "Hello",[1, 2]])TypeError: unorderable types: str() > int()`

#### 5.5.5. List search with index

If you wish to find where in a list a value can be found (rather than wanting to know only if the value is in the list), use the index method. It searches through a list looking for a list element equivalent to a given value and returns the position of that list element:

`>>> x = [1, 3, "five", 7, -2]>>> x.index(7)3>>> x.index(5)Traceback (innermost last): File "<stdin>", line 1, in ?ValueError: list.index(x): x not in list`

Attempting to find the position of an element that doesn’t exist in the list at all raises an error, as shown here. This can be handled in the same manner as the analogous error that can occur with the remove method (that is, by testing the list with in before using index).

#### 5.5.6. List matches with count

count also searches through a list, looking for a given value, but it returns the number of times that value is found in the list rather than positional information:

`>>> x = [1, 2, 2, 3, 5, 2, 5]>>> x.count(2)3>>> x.count(5)2>>> x.count(4)0`

#### 5.5.7. Summary of list operations

You can see that lists are very powerful data structures, with possibilities that go far beyond plain old arrays. List operations are so important in Python programming that it’s worth laying them out for easy reference, as shown in table 5.1.

##### Table 5.1. List operations

List operation

Explanation

Example

[] Creates an empty list x = []
len Returns the length of a list len(x)
append Adds a single element to the end of a list x.append('y')
insert Inserts a new element at a given position in the list x.insert(0, 'y')
del Removes a list element or slice del(x[0])
remove Searches for and removes a given value from a list x.remove('y')
reverse Reverses a list in place x.reverse()
sort Sorts a list in place x.sort()
+ Adds two lists together x1 + x2
* Replicates a list x = ['y'] * 3
min Returns the smallest element in a list min(x)
max Returns the largest element in a list max(x)
index Returns the position of a value in a list x.index['y']
count Counts the number of times a value occurs in a list x.count('y')
in Returns whether an item is in a list 'y' in x

Being familiar with these list operations will make your life as a Python coder much easier.

### 5.6. Nested lists and deep copies

This is another advanced topic that you may want to skip if you’re just learning the language.

Lists can be nested. One application of this is to represent two-dimensional matrices. The members of these can be referred to using two-dimensional indices. Indices for these work as follows:

`>>> m = [[0, 1, 2], [10, 11, 12], [20, 21, 22]]>>> m[0][0, 1, 2]>>> m[0][1]1>>> m[2][20, 21, 22]>>> m[2][2]22`

This mechanism scales to higher dimensions in the manner you would expect.

Most of the time, this is all you need to concern yourself with. But there is an issue with nested lists that you may run into. This is the result of the combination of the way variables refer to objects and the fact that some objects (such as lists) can be modified (they’re mutable). An example is the best way to illustrate:

`>>> nested = [0]>>> original = [nested, 1]>>> original[[0], 1]`

Figure 5.1 shows what this looks like.

##### Figure 5.1. A list with its first item referring to a nested list

The value in the nested list can now be changed using either the nested or the original variables:

`>>> nested[0] = 'zero'>>> original[['zero'], 1]>>> original[0][0] = 0>>> nested[0]>>> original[[0], 1]`

But if nested is set to another list, the connection between them is broken:

`>>> nested = [2]>>> original[[0], 1]`

Figure 5.2 illustrates this.

##### Figure 5.2. The first item of the original list is still a nested list, but the nested variable refers to a different list.

You’ve seen that you can obtain a copy of a list by taking a full slice (that is, x[:]). You can also obtain a copy of a list using the + or * operator (for example, x + [] or x * 1). These are slightly less efficient than the slice method. All three create what is called a shallow copy of the list. This is probably what you want most of the time. But if your list has other lists nested in it, you may want to make a deep copy. You can do this with the deepcopy function of the copy module:

`>>> original = [[0], 1]>>> shallow = original[:]>>> import copy>>> deep = copy.deepcopy(original)`

See figure 5.3 for an illustration.

##### Figure 5.3. A shallow copy doesn’t copy nested lists.

The lists pointed at by the original or shallow variables are connected. Changing the value in the nested list through either one of them affects the other:

`>>> shallow[1] = 2>>> shallow[[0], 2]>>> original[[0], 1]>>> shallow[0][0] = 'zero'>>> original[['zero'], 1]`

The deep copy is independent of the original, and no change to it has any effect on the original list:

`>>> deep[0][0] = 5>>> deep[[5], 1]>>> original[['zero'], 1]`

This behavior is the same for any other nested objects in a list that are modifiable (such as dictionaries).

Now that you’ve seen what lists can do, it’s time to look at tuples.

### 5.7. Tuples

Tuples are data structures that are very similar to lists, but they can’t be modified. They can only be created. Tuples are so much like lists that you may wonder why Python bothers to include them. The reason is that tuples have important roles that can’t be efficiently filled by lists, as keys for dictionaries.

#### 5.7.1. Tuple basics

Creating a tuple is similar to creating a list: assign a sequence of values to a variable. A list is a sequence that is enclosed by [ and ]; a tuple is a sequence that is enclosed by ( and ):

`>>> x = ('a', 'b', 'c')`

This line creates a three-element tuple.

After a tuple is created, using it is so much like using a list that it’s easy to forget they’re different data types:

`>>> x[2]'c'>>> x[1:]('b', 'c')>>> len(x)3>>> max(x)'c'>>> min(x)'a'>>> 5 in xFalse>>> 5 not in xTrue`

The main difference between tuples and lists is that tuples are immutable. An attempt to modify a tuple results in a confusing error message, which is Python’s way of saying it doesn’t know how to set an item in a tuple.

`>>> x[2] = 'd'Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: 'tuple' object does not support item assignment`

You can create tuples from existing ones by using the + and * operators.

`>>> x + x('a', 'b', 'c', 'a', 'b', 'c')>>> 2 * x('a', 'b', 'c', 'a', 'b', 'c')`

A copy of a tuple can be made in any of the same ways as for lists:

`>>> x[:]('a', 'b', 'c')>>> x * 1('a', 'b', 'c')>>> x + ()('a', 'b', 'c')`

If you didn’t read section 5.6, “Nested lists and deep copies,” you can skip the rest of this paragraph. Tuples themselves can’t be modified. But if they contain any mutable objects (for example, lists or dictionaries), these may be changed if they’re still assigned to their own variables. Tuples that contain mutable objects aren’t allowed as keys for dictionaries.

#### 5.7.2. One-element tuples need a comma

A small syntactical point is associated with using tuples. Because the square brackets used to enclose a list aren’t used elsewhere in Python, it’s clear that [] means an empty list and [1] means a list with one element. The same thing isn’t true with the parentheses used to enclose tuples. Parentheses can also be used to group items in expressions in order to force a certain evaluation order. If we say (x + y) in a Python program, do we mean that x and y should be added and then put into a one-element tuple, or do we mean that the parentheses should be used to force x and y to be added, before any expressions to either side come into play?

This is only a problem for tuples with one element, because tuples with more than one element always include commas to separate the elements, and the commas tell Python the parentheses indicate a tuple, not a grouping. In the case of one-element tuples, Python requires that the element in the tuple be followed by a comma, to disambiguate the situation. In the case of zero-element (empty) tuples, there’s no problem. An empty set of parentheses must be a tuple, because it’s meaningless otherwise.

`>>> x = 3>>> y = 4>>> (x + y)   # This adds x and y.7>>> (x + y,)  # Including a comma indicates the parentheses denote a tuple.(7,)>>> ()        # To create an empty tuple, use an empty pair of parentheses.()`

#### 5.7.3. Packing and unpacking tuples

As a convenience, Python permits tuples to appear on the left-hand side of an assignment operator, in which case variables in the tuple receive the corresponding values from the tuple on the right-hand side of the assignment operator. Here’s a simple example:

`>>> (one, two, three, four) =  (1, 2, 3, 4)>>> one1>>> two2`

This can be written even more simply, because Python recognizes tuples in an assignment context even without the enclosing parentheses. The values on the right-hand side are packed into a tuple and then unpacked into the variables on the left-hand side:

`one, two, three, four = 1, 2, 3, 4`

One line of code has replaced the following four lines of code:

`one = 1two = 2three = 3four = 4`

This is a convenient way to swap values between variables. Instead of saying

`temp = var1var1 = var2var2 = temp`

just say

`var1, var2 = var2, var1`

To make things even more convenient, Python 3 has an extended unpacking feature, allowing an element marked with a * to absorb any number elements not matching the other elements. Again, some examples will make this clearer:

`>>> x = (1, 2, 3, 4)>>> a, b, *c = x>>> a, b, c(1, 2, [3, 4])>>> a, *b, c = x>>> a, b, c(1, [2, 3], 4)>>> *a, b, c = x>>> a, b, c([1, 2], 3, 4)>>> a, b, c, d, *e = x>>> a, b, c, d, e(1, 2, 3, 4, [])`

Note that the starred element receives all the surplus items as a list, and that if there are no surplus elements, it receives an empty list.

Packing and unpacking can be performed using list delimiters as well:

`>>> [a, b] = [1, 2]>>> [c, d] = 3, 4>>> [e, f] = (5, 6)>>> (g, h) = 7, 8>>> i, j = [9, 10]>>> k, l = (11, 12)>>> a1>>> [b, c, d][2, 3, 4]>>> (e, f, g)(5, 6, 7)>>> h, i, j, k, l(8, 9, 10, 11, 12)`

#### 5.7.4. Converting between lists and tuples

Tuples can be easily converted to lists with the list function (which takes any sequence as an argument and produces a new list with the same elements as the original sequence). Similarly, lists can be converted to tuples with the tuple function (which does the same thing but produces a new tuple instead of a new list):

`>>> list((1, 2, 3, 4))[1, 2, 3, 4]>>> tuple([1, 2, 3, 4])(1, 2, 3, 4)`

As an interesting side note, list is a convenient way to break a string into characters:

`>>> list("Hello")['H', 'e', 'l', 'l', 'o']`

This works because list (and tuple) apply to any Python sequence, and a string is just a sequence of characters. (Strings are discussed fully in the next chapter.)

### 5.8. Sets

A set in Python is an unordered collection of objects used in situations where membership and uniqueness in the set are main things you need to know about that object. Just as with dictionary keys (as you’ll see in chapter 7), the items in a set must be immutable and hashable. This means that ints, floats, strings, and tuples can be members of a set, but lists, dictionaries, and sets themselves can’t.

#### 5.8.1. Set operations

In addition to the operations that apply to collections in general, like in, len, and being able to use a for loop to iterate over all of their elements, sets also have several set-specific operations:

You can create a set by using set on a sequence, like a list . When a sequence is made into a set, duplicates are removed . After creating a set using the set function, you can use add and remove to change the elements in the set. The in keyword is used to check for membership of an object in a set . You can also use | to get the union, or combination, of two sets, & to get their intersection , and ^ to find their symmetric difference—that is, elements that are in one set or the other but not both.

These examples aren’t a complete listing of set operations but are enough to give you a good idea of how sets work. For more information, refer to the official Python documentation.

#### 5.8.2. Frozensets

Because sets aren’t immutable and hashable, they can’t belong to other sets. To remedy that situation there is another set type, frozenset, which is just like a set but can’t be changed after creation. Because frozensets are immutable and hashable, they can be members of other sets:

`>>> x = set([1, 2, 3, 1, 3, 5])>>> z = frozenset(x)>>> zfrozenset({1, 2, 3, 5})>>> z.add(6)Traceback (most recent call last):  File "<pyshell#79>", line 1, in <module>    z.add(6)AttributeError: 'frozenset' object has no attribute 'add'>>> x.add(z)>>> x{1, 2, 3, 5, frozenset({1, 2, 3, 5})}`

### 5.9. Summary

Lists are a basic and highly useful data structure built into the Python language. In addition to demonstrating fairly standard array-like behavior, lists possess additional functionality, such as automatic resizing, the ability to use slice notation, and a good set of convenience functions, methods, and operators. Note that there are a few more list methods than were covered in this chapter. You’ll find details on these in the appendix.

Tuples are similar to lists but can’t be modified. They take up slightly less memory and are faster to access. They aren’t as flexible but are more efficient than lists. Their normal use (from the point of view of a Python coder) is to serve as dictionary keys, which is discussed in chapter 7.

Sets are also sequence structures but with two differences from lists and tuples. Although sets do have an order, that order is arbitrary and not under the programmer’s control. The second difference is that the elements in a set must be unique.

Lists, tuples, and sets are structures that embody the idea of a sequence of elements. As you’ll see in the next chapter, strings are also sequences with some additional methods.