Lists vs Tuples in Python – Real Python

Creating Lists in Python

In many situations, you’ll define a list object using a literal. A list literal is a comma-separated sequence of objects enclosed in square brackets:

In this example, you create a list of countries represented by string objects. Because lists are ordered sequences, the values retain the insertion order.

Alternatively, you can create new lists using the list() constructor:

In this example, you use the list() constructor to define a list of digits using a range object. In general, list() can convert any iterable to a list.

You can also create new list objects using list comprehensions. For example, the following comprehension builds a list of even digits:

List comprehensions are powerful tools for creating lists in Python. You’ll often find them in Python code that runs transformations over sequences of data.

Finally, to create an empty list, you can use either an empty pair of square brackets or the list() constructor without arguments:

The first approach is arguably the most efficient and most commonly used. However, the second approach can be more explicit and readable in some situations.

Creating Tuples in Python

Similar to lists, you’ll often create new tuples using literals. Here’s a short example showing a tuple definition:

In this example, you create a tuple containing the parameters for a database connection. The data includes the server name, port, timeout, and database name.

Strictly speaking, to define a tuple, you don’t need the parentheses. The comma-separated sequence will be enough:

In practice, you can define tuples without using a pair of parentheses. However, using the parentheses is a common practice because it improves the readability of your code.

Because the parentheses are optional, to define a single-item tuple, you need to use a comma:

In the first example, you create a tuple containing a single value by appending a comma after the value. In the second example, you use the parentheses without the comma. In this case, you create an integer value instead of a tuple.

You can also create new tuples using the tuple() constructor:

In this example, you create a list of digits using tuple(). This way of creating tuples can be helpful when you’re working with iterators and need to convert them into tuples.

Finally, to create empty tuples, you can use a pair of parentheses or call tuple() without arguments:

The first approach is a common way to create empty tuples. However, using tuple() can be more explicit and readable.

Lists and Tuples Are Ordered Sequences

List and tuples are ordered sequences of objects. The order in which you insert the objects when you create a list or tuple is an innate characteristic. This order remains the same for that list or tuple’s lifetime:

In these examples, you can confirm that the order of items in lists and tuples is the same order you define when creating the list or tuple.

Lists and Tuples Can Contain Arbitrary Objects

Lists and tuples can contain any Python objects. The elements of a list or tuple can all be the same type:

In these examples, you create a list of integer numbers and then a tuple of similar objects. In both cases, the contained objects have the same data type. So, they’re homogeneous.

The elements of a list or tuple can also be of heterogeneous data types:

Here, your list and tuple contain objects of different types, including strings, integers, Booleans, and floats. So, your list and tuple are heterogeneous.

Lists and tuples can even contain objects like functions, classes, and modules:

In these examples, the list and the tuple contain a class, built-in function, custom function, and module objects.

Lists and tuples can contain any number of objects, from zero to as many as your computer’s memory allows. In the following code, you have a list and tuple built out of a range with a million numbers:

These two lines of code will take some time to run and populate your screen with many, many numbers.

Finally, objects in a list or tuple don’t need to be unique. A given object can appear multiple times:

Lists and tuples can contain duplicated values like "bark" in the above examples.

Lists and Tuples Can Be Indexed and Sliced

You can access individual elements in a list or tuple using the item’s index in square brackets. This is exactly analogous to accessing individual characters in a string. List indexing is zero-based, as it is with strings.

Consider the following list:

The indices for the elements in words are shown below:

Here’s the Python code to access individual elements of words:

The first element in the list has an index of 0. The second element has an index of 1, and so on. Virtually everything about indexing works the same for tuples.

You can also use a negative index, in which case the count starts from the end of the list:

Index -1 corresponds to the last element in the list, while the first element is -len(words), as shown below:

Slicing also works with lists and tuples. For example, the expression words[m:n] returns the portion of words from index m to, but not including, index n:

Other features of slicing work for lists as well. For example, you can use both positive and negative indices:

Omitting the first index starts the slice at the beginning of the list or tuple. Omitting the second index extends the slice to the end of the list or tuple:

You can specify a stride—either positive or negative:

The slicing operator ([:]) works for both lists and tuples. You can check it out by turning words into a tuple and running the same slicing operations on it.

Lists and Tuples Can Be Nested

You’ve seen that an element in a list or tuple can be of any type. This means that they can contain other lists or tuples. For example, a list can contain sublists, which can contain other sublists, and so on, to arbitrary depth.

Consider the following example:

The internal structure of this list is represented in the diagram below:

In this diagram, x[0], x[2], and x[4] are strings, each one character long:

However, x[1] and x[3] are sublists or nested lists:

To access the items in a sublist, append an additional index:

Here, x[1][1] is yet another sublist, so adding one more index accesses its elements:

There’s no limit to the depth you can nest lists this way. However, deeply nested lists or tuples can be hard to decipher in an indexing or slicing context.

Lists Are Mutable, Tuples Are Immutable

The built-in list class provides a mutable data type. Being mutable means that once you create a list object, you can add, delete, shift, and move elements around at will. Python provides many ways to modify lists, as you’ll learn in a moment. Unlike lists, tuples are immutable, meaning that you can’t change a tuple once it has been created.

You can replace or update a value in a list by indexing it on the left side of an assignment statement:

In this example, you create a list of letters where some letters are in uppercase while others are in lowercase. You use an assignment to turn the lowercase letters into uppercase letters.

Now, because tuples are immutable, you can’t do with a tuple what you did in the above example with a list:

If you try to update the value of a tuple element, you get a TypeError exception because tuples are immutable, and this type of operation isn’t allowed for them.

You can also use the del statement to delete individual items from a list. However, that operation won’t work on tuples:

You can remove individual elements from lists using the del statement because lists are mutable, but this won’t work with tuples because they’re immutable.

What if you want to change several elements in a list at once? Python allows this operation with a slice assignment, which has the following syntax:

Think of an iterable as a container of multiple values like a list or tuple. This assignment replaces the specified slice of a_list with the content of <iterable>:

In this example, you replace the 0 values with the corresponding consecutive numbers using a slice assignment.

It’s important to note that the number of elements to insert doesn’t need to be equal to the number of elements in the slice. Python grows or shrinks the list as needed. For example, you can insert multiple elements in place of a single element:

In this example, you replace the 7 with a list of values from 4 to 7. Note how Python automatically grows the list for you.

You can also insert elements into a list without removing anything. To do this, you can specify a slice of the form [n:n] at the desired index:

In this example, you insert the desired values at index 3. Because you’re using an empty slice, Python doesn’t replace any of the existing values. Instead, it makes space for the new values as needed.

You can’t do slice assignment on tuple objects:

Because tuples are immutable, they don’t support slice assignment. If you try to do it, then you get a TypeError exception.

Lists Have Mutator Methods, Tuples Don’t

Python lists have several methods that you can use to modify the underlying list. These methods aren’t available for tuples because tuples are immutable, so you can’t change them in place.

In this section, you’ll explore the mutator methods available in Python list objects. These methods are handy in many situations, so they’re great tools for you as a Python developer.