Python's list Data Type: A Deep Dive With Examples

Creating Lists Through Literals

List literals are probably the most popular way to create a list object in Python. These literals are fairly straightforward. They consist of a pair of square brackets enclosing a comma-separated series of objects.

Here’s the general syntax of a list literal:

[item_0, item_1, ..., item_n]

This syntax creates a list of n items by listing the items in an enclosing pair of square brackets. Note that you don’t have to declare the items’ type or the list’s size beforehand. Remember that lists have a variable size and can store heterogeneous objects.

Here are a few examples of how to use the literal syntax to create new lists:

>>> digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> fruits = ["apple", "banana", "orange", "kiwi", "grape"]
>>> cities = [
...     "New York",
...     "Los Angeles",
...     "Chicago",
...     "Houston",
...     "Philadelphia"
... ]

>>> matrix = [
...     [1, 2, 3],
...     [4, 5, 6],
...     [7, 8, 9]
... ]

>>> inventory = [
...     {"product": "phone", "price": 1000, "quantity": 10},
...     {"product": "laptop", "price": 1500, "quantity": 5},
...     {"product": "tablet", "price": 500, "quantity": 20}
... ]

>>> functions = [print, len, range, type, enumerate]

>>> empty = []

In these examples, you use the list literal syntax to create lists containing numbers, strings, other lists, dictionaries, and even function objects. As you already know, lists can store any type of object. They can also be empty, like the final list in the above code snippet.

Empty lists are useful in many situations. For example, maybe you want to create a list of objects resulting from computations that run in a loop. The loop will allow you to populate the empty list one element at a time.

Using a list literal is arguably the most common way to create lists. You’ll find these literals in many Python examples and codebases. They come in handy when you have a series of elements with closely related meanings, and you want to pack them into a single data structure.

Note that naming lists as plural nouns is a common practice that improves readability. However, there are situations where you can use collective nouns as well.

For example, you can have a list called people. In this case, every item will be a person. Another example would be a list that represents a table in a database. You can call the list table, and each item will be a row. You’ll find more examples like these in your walk-through of using lists.

Using the list() Constructor

Another tool that allows you to create list objects is the class constructor, list(). You can call this constructor with any iterable object, including other lists, tuples, sets, dictionaries and their components, strings, and many others. You can also call it without any arguments, in which case you’ll get an empty list back.

Here’s the general syntax:

list([iterable])

To create a list, you need to call list() as you’d call any class constructor or function. Note that the square brackets around iterable mean that the argument is optional, so the brackets aren’t part of the syntax. Here are a few examples of how to use the constructor:

>>> list((0, 1, 2, 3, 4, 5, 6, 7, 8, 9))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list({"circle", "square", "triangle", "rectangle", "pentagon"})
['square', 'rectangle', 'triangle', 'pentagon', 'circle']

>>> list({"name": "John", "age": 30, "city": "New York"}.items())
[('name', 'John'), ('age', 30), ('city', 'New York')]

>>> list("Pythonista")
['P', 'y', 't', 'h', 'o', 'n', 'i', 's', 't', 'a']

>>> list()
[]

In these examples, you create different lists using the list() constructor, which accepts any type of iterable object, including tuples, dictionaries, strings, and many more. It even accepts sets, in which case you need to remember that sets are unordered data structures, so you won’t be able to predict the final order of items in the resulting list.

Calling list() without an argument creates and returns a new empty list. This way of creating empty lists is less common than using an empty pair of square brackets. However, in some situations, it can make your code more explicit by clearly communicating your intent: creating an empty list.

The list() constructor is especially useful when you need to create a list out of an iterator object. For example, say that you have a generator function that yields numbers from the Fibonacci sequence on demand, and you need to store the first ten numbers in a list.

In this case, you can use list() as in the code below:

>>> def fibonacci_generator(stop):
...     current_fib, next_fib = 0, 1
...     for _ in range(0, stop):
...         fib_number = current_fib
...         current_fib, next_fib = next_fib, current_fib + next_fib
...         yield fib_number
...

>>> fibonacci_generator(10)
<generator object fibonacci_generator at 0x10692f3d0>

>>> list(fibonacci_generator(10))
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Calling fibonacci_generator() directly returns a generator iterator object that allows you to iterate over the numbers in the Fibonacci sequence up to the index of your choice. However, you don’t need an iterator in your code. You need a list. A quick way to get that list is to wrap the iterator in a call to list(), as you did in the final example.

This technique comes in handy when you’re working with functions that return iterators, and you want to construct a list object out of the items that the iterator yields. The list() constructor will consume the iterator, build your list, and return it back to you.

>>> [*fibonacci_generator(10)]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

As a side note, you’ll often find that built-in and third-party functions return iterators. Functions like reversed(), enumerate(), map(), and filter() are good examples of this practice. It’s less common to find functions that directly return list objects, but the built-in sorted() function is one example. It takes an iterable as an argument and returns a list of sorted items.

Building Lists With List Comprehensions

List comprehensions are one of the most distinctive features of Python. They’re quite popular in the Python community, so you’ll likely find them all around. List comprehensions allow you to quickly create and transform lists using a syntax that mimics a for loop but in a single line of code.

The core syntax of list comprehensions looks something like this:

[expression(item) for item in iterable]

Every list comprehension needs at least three components:

1. expression() is a Python expression that returns a concrete value, and most of the time, that value depends on item. Note that it doesn’t have to be a function.
2. item is the current object from iterable.
3. iterable can be any Python iterable object, such as a list, tuple, set, string, or generator.

The for construct iterates over the items in iterable, while expression(item) provides the corresponding list item that results from running the comprehension.

To illustrate how list comprehensions allow you to create new lists out of existing iterables, say that you want to construct a list with the square values of the first ten integer numbers. In this case, you can write the following comprehension:

>>> [number ** 2 for number in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

In this example, you use range() to get the first ten integer numbers. The comprehension iterates over them while computing the square and building the new list. This example is just a quick sample of what you can do with a list comprehension.

In general, you’ll use a list comprehension when you need to create a list of transformed values out of an existing iterable. Comprehensions are a great tool that you need to master as a Python developer. They’re optimized for performance and are quick to write.

Aliases of a List

In Python, you can create aliases of variables using the assignment operator (=). Assignments don’t create copies of objects in Python. Instead, they create bindings between the variable and the object involved in the assignment. Therefore, when you have several aliases of a given list, changes in an alias will affect the rest of the aliases.

To illustrate how you can create aliases and how they work, consider the following example:

>>> countries = ["United States", "Canada", "Poland", "Germany", "Austria"]

>>> nations = countries
>>> id(countries) == id(nations)
True

>>> countries[0] = "United States of America"

>>> nations
['United States of America', 'Canada', 'Poland', 'Germany', 'Austria']

In this code snippet, the first highlighted line creates nations as an alias of countries. Note how both variables point to the same object, which you know because the object’s identity is the same. In the second highlighted line, you update the object at index 0 in countries. This change reflects in the nations alias.

Assignment statements like the one in the first highlighted line above don’t create copies of the right-hand object. They just create aliases or variables that point to the same underlying object.

In general, aliases can come in handy in situations where you need to avoid name collisions in your code or when you need to adapt the names to specific naming patterns.

To illustrate, say that you have an app that uses your list of countries as countries in one part of the code. The app requires the same list in another part of the code, but there’s already a variable called countries with other content.

If you want both pieces of code to work on the same list, then you can use nations as an alias for countries. A handy way to do this would be to use the as keyword for creating the alias through an implicit assignment, for example, when you import the list from another module.

Shallow Copies of a List

A shallow copy of an existing list is a new list containing references to the objects stored in the original list. In other words, when you create a shallow copy of a list, Python constructs a new list with a new identity. Then, it inserts references to the objects in the original list into the new list.

There are at least three different ways to create shallow copies of an existing list. You can use:

1. The slicing operator, [:]
2. The .copy() method
3. The copy() function from the copy module

These three tools demonstrate equivalent behavior. So, to kick things off, you’ll start exploring the slicing operator:

>>> countries = ["United States", "Canada", "Poland", "Germany", "Austria"]

>>> nations = countries[:]
>>> nations
['United States', 'Canada', 'Poland', 'Germany', 'Austria']

>>> id(countries) == id(nations)
False

The highlighted line creates nations as a shallow copy of countries by using the slicing operator with one colon only. This operation takes a slice from the beginning to the end of countries. In this case, nations and countries have different identities. They’re completely independent list objects.

However, the elements in nations are aliases of the elements in countries:

>>> id(nations[0]) == id(countries[0])
True
>>> id(nations[1]) == id(countries[1])
True

As you can see, items under the same index in both nations and countries share the same object identity. This means that you don’t have copies of the items. You’re really sharing them. This behavior allows you to save some memory when working with lists and their copies.

Now, how would this impact the behavior of both lists? If you changed an item in nations, would the change reflect in countries? The code below will help you answer these questions:

>>> countries[0] = "United States of America"
>>> countries
['United States of America', 'Canada', 'Poland', 'Germany', 'Austria']

>>> nations
['United States', 'Canada', 'Poland', 'Germany', 'Austria']

>>> id(countries[0]) == id(nations[0])
False
>>> id(countries[1]) == id(nations[1])
True

On the first line of this piece of code, you update the item at index 0 in countries. This change doesn’t affect the item at index 0 in nations. Now the first items in the lists are completely different objects with their own identities. The rest of the items, however, continue to share the same identity. So, they’re the same object in each case.

Because making copies of a list is such a common operation, the list class has a dedicated method for it. The method is called .copy(), and it returns a shallow copy of the target list:

>>> countries = ["United States", "Canada", "Poland", "Germany", "Austria"]

>>> nations = countries.copy()
>>> nations
['United States', 'Canada', 'Poland', 'Germany', 'Austria']

>>> id(countries) == id(nations)
False
>>> id(countries[0]) == id(nations[0])
True
>>> id(countries[1]) == id(nations[1])
True

>>> countries[0] = "United States of America"
>>> countries
['United States of America', 'Canada', 'Poland', 'Germany', 'Austria']
>>> nations
['United States', 'Canada', 'Poland', 'Germany', 'Austria']

Calling .copy() on countries gets you a shallow copy of this list. Now you have two different lists. However, their elements are common to both. Again, if you change an element in one of the lists, then the change won’t reflect in the copy.

You’ll find yet another tool for creating shallow copies of a list. The copy() function from the copy module allows you to do just that:

>>> from copy import copy

>>> countries = ["United States", "Canada", "Poland", "Germany", "Austria"]

>>> nations = copy(countries)
>>> nations
['United States', 'Canada', 'Poland', 'Germany', 'Austria']

>>> id(countries) == id(nations)
False
>>> id(countries[0]) == id(nations[0])
True
>>> id(countries[1]) == id(nations[1])
True

>>> countries[0] = "United States of America"
>>> countries
['United States of America', 'Canada', 'Poland', 'Germany', 'Austria']
>>> nations
['United States', 'Canada', 'Poland', 'Germany', 'Austria']

When you feed copy() with a mutable container data type, such as a list, the function returns a shallow copy of the input object. This copy behaves the same as the previous shallow copies that you’ve built in this section.

Deep Copies of a List

Sometimes you may need to build a complete copy of an existing list. In other words, you want a copy that creates a new list object and also creates new copies of the contained elements. In these situations, you’ll have to construct what’s known as a deep copy.

When you create a deep copy of a list, Python constructs a new list object and then inserts copies of the objects from the original list recursively.

To create a deep copy of an existing list, you can use the deepcopy() function from the copy module. Here’s an example of how this function works:

>>> from copy import deepcopy

>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> matrix_copy = deepcopy(matrix)

>>> id(matrix) == id(matrix_copy)
False
>>> id(matrix[0]) == id(matrix_copy[0])
False
>>> id(matrix[1]) == id(matrix_copy[1])
False

In this example, you create a deep copy of your matrix list. Note how both the lists and their sibling items have different identities.

Why would you need to create a deep copy of matrix, anyway? For example, if you only create a shallow copy of matrix, then you can face some issues when trying to mutate the nested lists:

>>> from copy import copy

>>> matrix_copy = copy(matrix)
>>> matrix_copy[0][0] = 100
>>> matrix_copy[0][1] = 200
>>> matrix_copy[0][2] = 300
>>> matrix_copy
[[100, 200, 300], [4, 5, 6], [7, 8, 9]]

>>> matrix
[[100, 200, 300], [4, 5, 6], [7, 8, 9]]

In this example, you create a shallow copy of matrix. If you change items in a nested list within matrix_copy, then those changes affect the original data in matrix. The way to avoid this behavior is to use a deep copy:

>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

>>> matrix_copy = deepcopy(matrix)
>>> matrix_copy[0][0] = 100
>>> matrix_copy[0][1] = 200
>>> matrix_copy[0][2] = 300
>>> matrix_copy
[[100, 200, 300], [4, 5, 6], [7, 8, 9]]

>>> matrix
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Now the changes in matrix_copy or any other deep copy don’t affect the content of matrix, as you can see on the highlighted lines.

Finally, it’s important to note that when you have a list containing immutable objects, such as numbers, strings, or tuples, the behavior of deepcopy() mimics what copy() does:

>>> countries = ["United States", "Canada", "Poland", "Germany", "Austria"]
>>> nations = deepcopy(countries)

>>> id(countries) == id(nations)
False
>>> id(countries[0]) == id(nations[0])
True
>>> id(countries[1]) == id(nations[1])
True

In this example, even though you use deepcopy(), the items in nations are aliases of the items in countries. That behavior makes sense because you can’t change immutable objects in place. Again, this behavior optimizes the memory consumption of your code when you’re working with multiple copies of a list.

Appending a Single Item at Once: .append()

The .append() method is probably the most common tool that you’ll use to add items to an existing list. As its name suggests, this method allows you to append items to a list. The method takes one item at a time and adds it to the right end of the target list.

Here’s an example of how .append() works:

>>> pets = ["cat", "dog"]

>>> pets.append("parrot")
>>> pets
['cat', 'dog', 'parrot']

>>> pets.append("gold fish")
>>> pets
['cat', 'dog', 'parrot', 'gold fish']

>>> pets.append("python")
>>> pets
['cat', 'dog', 'parrot', 'gold fish', 'python']

In these examples, every call to .append() adds a new pet at the end of your list. This behavior allows you to gradually populate an empty list or to add items to an existing list, as you did in the example.

Using .append() is equivalent to doing the following slice assignment:

>>> pets[len(pets):] = ["hawk"]
>>> pets
['cat', 'dog', 'parrot', 'gold fish', 'python', 'hawk']

The slice assignment in this example grows your lists by appending a new item, "hawk", after the current last item in pets. This technique works the same as .append(). However, using .append() leads to a more readable and explicit solution.

An important fact to keep in mind when using .append() is that this method adds only a single item at a time. That item could be of any data type, including another list:

>>> pets.append(["hamster", "turtle"])
>>> pets
[
    'cat',
    'dog',
    'parrot',
    'gold fish',
    'python',
    'hawk',
    ['hamster', 'turtle']
]

Note how the last item in pets is a list of two pets rather than two new independent pets. This behavior may be a source of subtle errors. To avoid problems, you must remember that .append() takes and adds a single item each time.

If you need to add several items from an iterable at the end of an existing list, then you can use the .extend() method, which you’ll expore in the following section.

Extending a List With Multiple Items at Once: .extend()

When you’re working with lists, you may face the need to add multiple items to the right end of a list at once. Because this is such a common requirement, Python’s list has a dedicated method for that task.

The method is called .extend(). It takes an iterable of objects and appends them as individual items to the end of the target list:

>>> fruits = ["apple", "pear", "peach"]

>>> fruits.extend(["orange", "mango", "banana"])
>>> fruits
['apple', 'pear', 'peach', 'orange', 'mango', 'banana']

The .extend() method unpacks the items in the input iterable and adds them one by one to the right end of your target list. Now fruits has three more items on its end.

You should note that .extend() can take any iterable as an argument. So, you can use tuples, strings, dictionaries and their components, iterators, and even sets. However, remember that if you use a set as an argument to extend(), then you won’t know the final order of items beforehand.

Again, you must note that .extend() is equivalent to the following slice assignment:

>>> fruits = ["apple", "pear", "peach"]

>>> fruits[len(fruits):] = ["orange", "mango", "banana"]
>>> fruits
['apple', 'pear', 'peach', 'orange', 'mango', 'banana']

In this example, you use a slice assignment to add three items after the end of your original fruits list. Note that the result is the same as when you use .extend(). However, the .extend() variation is more readable and explicit.

Inserting an Item at a Given Position: .insert()

The .insert() method is another tool that you can use to add items to an existing list. This method is a bit different from .append() and .extend(). Instead of adding items at the right end of the list, .insert() allows you to decide where you want to put your item. That said, .insert() takes two arguments:

1. index: the index at which you want to insert the item
2. item: the item that you need to insert into the list

When you insert an item at a given index, Python moves all the following items one position to the right in order to make space for the new item, which will take the place of the old item at the target index:

>>> letters = ["A", "B", "F", "G"]

>>> letters.insert(2, "C")
>>> letters
['A', 'B', 'C', 'F', 'G']

>>> letters.insert(3, "D")
>>> letters
['A', 'B', 'C', 'D', 'F', 'G']

>>> letters.insert(4, "E")
>>> letters
['A', 'B', 'C', 'D', 'E', 'F', 'G']

In this example, you insert letters into specific positions in letters. You must insert one letter at a time because .insert() adds a single item in every call. To insert an item, the method shifts all the items starting from the target index to the right end of the list. This shifting makes space for the new item.

As an exercise, could you come up with a slice assignment that produces the same result as .insert()? Click the collapsible section below for the solution:

list_object[index:index] = [item]

Now that you’ve learned how to add items to an existing list using different tools and techniques, it’s time to learn how to remove unneeded items from a list, which is another common task.

Deleting Items From a List

Python also allows you to remove one or more items from an existing list. Again, deleting items from lists is such a common operation that the list class already has methods to help you with that. You’ll have the following methods:

The .remove() method comes in handy when you want to remove an item from a list, but you don’t know the item’s index. If you have several items with the same value, then you can remove all of them by calling .remove() as many times as the item occurs:

>>> sample = [12, 11, 10, 42, 14, 12, 42]

>>> sample.remove(42)
>>> sample
[12, 11, 10, 14, 12, 42]

>>> sample.remove(42)
>>> sample
[12, 11, 10, 14, 12]

>>> sample.remove(42)
Traceback (most recent call last):
    ...
ValueError: list.remove(x): x not in list

The first call to .remove() deletes the first instance of the number 42. The second call removes the remaining instance of 42. If you call .remove() with an item that’s not in the target list, then you get a ValueError.

The .pop() method allows you to remove and return a specific item using its index. If you call the method with no index, then it removes and returns the last item in the underlying list:

>>> to_visit = [
...     "https://realpython.com",
...     "https://python.org",
...     "https://stackoverflow.com",
... ]

>>> visited = to_visit.pop()
>>> visited
'https://stackoverflow.com'
>>> to_visit
['https://realpython.com', 'https://python.org']

>>> visited = to_visit.pop(0)
>>> visited
'https://realpython.com'
>>> to_visit
['https://python.org']

>>> visited = to_visit.pop(-1)
>>> visited
'https://python.org'
>>> to_visit
[]

In these examples, the first call to .pop() removes and returns the last site in your list of sites to visit. The second call removes and returns the first site, which is the site at index 0.

Finally, you use .pop() with -1 as an argument to emphasize that you can also use negative indices. This call removes and returns the last item. At the end of the process, your list of sites to visit is empty, pointing out that you’ve done all your planned visits.

Removing all the items from a list in one go can be another frequent task. In this case, Python also has you covered because list has a method called .clear(), which does exactly that. Consider the following example:

>>> cache = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> cache.clear()
>>> cache
[]

If you call .clear() on a non-empty list object, then you get the list content completely removed. This method can be useful when your lists work as a cache that you want to quickly clean for a restart.

The following slice assignment produces the same result as the .clear() method:

>>> cache = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> cache[:] = []
>>> cache
[]

In this slice assignment, you assign an empty list to a slice that grabs the whole target list. Again, this syntax is less explicit and readable than using .clear().

There’s still one more Python tool that you can use to remove one or more items from an existing list. Yes, that’s the del statement. You can combine del with an indexing or slicing operation to remove an item or multiple items, respectively:

>>> colors = [
...     "red",
...     "orange",
...     "yellow",
...     "green",
...     "blue",
...     "indigo",
...     "violet"
... ]

>>> del colors[1]
>>> colors
['red', 'yellow', 'green', 'blue', 'indigo', 'violet']

>>> del colors[-1]
>>> colors
['red', 'yellow', 'green', 'blue', 'indigo']

>>> del colors[2:4]
>>> colors
['red', 'yellow', 'indigo']

>>> del colors[:]
>>> colors
[]

With the first del statement, you remove the color at index 1, which is "orange". In the second del, you use a negative index of -1 to remove the last color, "violet". Next, you use a slice to remove "green" and "blue".

In the final example, you use del and a slice to remove all the items from an existing list. That construct produces a result that’s equivalent to calling .clear() on your target list.

Considering Performance While Growing Lists

When you create a list, Python allocates enough space to store the provided items. It also allocates extra space to host future items. When you use the extra space by adding new items to that list with .append(), .extend(), or .insert(), Python automatically creates room for additional new items.

This process is known as resizing, and while it ensures that the list can accept new items, it requires extra CPU time and additional memory. Why? Well, to grow an existing list, Python creates a new one with room for your current data and the extra items. Then it moves the current items to the new list and adds the new item or items.

Consider the following code to explore how Python grows a list dynamically:

>>> from sys import getsizeof

>>> numbers = []
>>> for value in range(100):
...     print(getsizeof(numbers))
...     numbers.append(value)
...
56
88
88
88
88
120
120
120
120
184
184
...

In this code snippet, you first import getsizeof() from the sys module. This function allows you to get the size of an object in bytes. Then you define numbers as an empty list.

Inside the for loop, you get and print your list object’s size in bytes. The first iteration shows that the size of your empty list is 56 bytes, which is the baseline size of every list in Python.

Next, the .append() method adds a new value to your list. Note how the size of numbers grows to 88 bytes. That’s the baseline size plus 32 additional bytes (56 + 4 × 8 = 88), which represent four 8-byte pointers or slots for future items. It means that Python went ahead and allocated space for four items when you added the first element.

As the loop goes, the size of numbers grows to 120 bytes, which is 88 + 4 × 8 = 120. This step allocates space for four more items. That’s why you get 120 four times on your screen.

If you follow the loop’s output, then you’ll notice that the next steps add room for eight extra items, then for twelve, then for sixteen, and so on. Every time Python resizes the list, it has to move all the items to the new space, which takes considerable time.

In practice, if you’re working with small lists, then the overall impact of this internal behavior is negligible. However, in performance-critical situations or when your lists are large, you may want to use more efficient data types, such as collections.deque, for example.

Check out the time complexity Wiki page for a detailed summary of how time-efficient list operations are. For example, the .append() method has a time complexity of O(1), which means that appending an item to a list takes constant time. However, when Python has to grow the list to make room for the new item, this performance will be a bit poorer.

Being aware of the time complexity of common list operations will significantly improve your ability to choose the right tool for the job, depending on your specific needs.

Concatenating Lists

Concatenation consists of joining two things together. In this case, you’d like to concatenate two lists, which you can do using the plus operator (+). In this context, this operator is known as the concatenation operator.

Here’s how it works:

>>> [0, 1, 2, 3] + [4, 5, 6] + [7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In this example, you combine three list objects using the concatenation operator. Note how the operator creates a new list containing all the individual items from the three original lists.

Whenever you use the concatenation operator, you get a new list object as a result. Consider the following example. Keep an eye on the identity of digits:

>>> digits = [0, 1, 2, 3, 4, 5]
>>> id(digits)
4558758720

>>> digits = digits + [6, 7, 8, 9]
>>> id(digits)
4470412224

In this example, you first create a list containing a few numbers. The id() function allows you to know the identity of this first list. Then you use a concatenation operation to complete your list of digits. Note how id() now returns a different value. This result confirms that the concatenation operator always creates a new list that joins its operands.

>>> [0, 1, 2, 3, 4, 5] + (6, 7, 8, 9)
Traceback (most recent call last):
    ...
TypeError: can only concatenate list (not "tuple") to list

The concatenation operator has an augmented variation, which uses the += operator. Here’s how this operator works:

>>> digits = [0, 1, 2, 3, 4, 5]
>>> digits += [6, 7, 8, 9]
>>> digits
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

The augmented concatenation operator works on an existing list. It takes a second list and adds its items, one by one, to the end of the initial list. The operation is a shortcut to something like digits = digits + [6, 7, 8, 9]. However, it works a bit differently.

Unlike the regular concatenation operator, the augmented variation mutates the target list in place rather than creating a new list:

>>> digits = [0, 1, 2, 3, 4, 5]
>>> id(digits)
4699578112

>>> digits += [6, 7, 8, 9]
>>> id(digits)
4699578112

In this example, the id() function returns the same value in both calls, meaning that you have a single list object instead of two. The augmented concatenation mutates digits in place, so the whole process is more efficient in terms of memory and execution time than a plain concatenation would be.

Repeating the Content of a List

Repetition consists of cloning the content of a given list a specific number of times. You can achieve this with the repetition operator (*), which takes two operands:

1. The list whose content you want to repeat
2. The number of times that you need to repeat the content

To understand how this operator works, consider the following example:

>>> ["A", "B", "C"] * 3
['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C']

>>> 3 * ["A", "B", "C"]
['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C']

Here, you repeat the content of a list three times and get a new list as a result. In the first example, the left-hand operand is the target list, and the right-hand operand is an integer representing the number of times that you want to repeat the list’s content. In this second example, the operands are swapped, but the result is the same, as you’d expect in a multiplication operation.

The repetition operator also has an augmented variation that you’ll call the augmented repetition operator. This variation uses the *= operator. Here’s how it works:

>>> letters = ["A", "B", "C"]
>>> letters *= 3
>>> letters
['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C']

In the highlighted expression, the left-hand operand is the target list, while the right-hand operand is the integer value. You can’t swap them.

Again, the regular repetition operator returns a new list object containing the repeated data. However, its augmented variation mutates the target list in place, which makes it more efficient. As an exercise, go ahead and use the id() function to confirm this statement.

Reversing a List: reversed() and .reverse()

The built-in reversed() function takes a sequence as an argument and returns an iterator that yields the values of that sequence in reverse order:

>>> digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> reversed(digits)
<list_reverseiterator object at 0x10b261a50>

>>> list(reversed(digits))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

>>> digits
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

When you call reversed() with a list as an argument, you get a reverse iterator object. This iterator yields values from the input list in reverse order. In this example, you use the list() constructor to consume the iterator and get the reversed data as a list.

The reversed() function doesn’t modify the input object. You’ll typically use reversed() in loops as a way to iterate over your data in reverse order. If you need to keep a reference to your data, then you can use list() and assign its return value to a new variable, which will be completely independent of your original sequence.

It’s important to note that reversed() retrieves items from the input sequence lazily. This means that if something changes in the input sequence during the reversing process, then those changes will reflect in the final result:

>>> numbers = [1, 2, 3]

>>> reversed_numbers = reversed(numbers)
>>> next(reversed_numbers)
3

>>> numbers[1] = 222
>>> next(reversed_numbers)
222

>>> next(reversed_numbers)
1

In this example, you use the built-in next() function to consume the iterator value by value. The first call to next() returns the last item from numbers. Then you update the value of the second item from 2 to 222. When you call next() again, you get 222 instead of 2. This is because reversed() doesn’t create a copy of the input iterable. Instead, it works with a reference to it.

The reversed() function is great when you want to iterate over a list in reverse order without altering the original list. What if you have a list, and for some reason, you need to reverse its content persistently? In that case, you can use the .reverse() method:

>>> digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> digits.reverse()
>>> digits
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

The .reverse() method reverses a list in place. This means that if you call .reverse() on an existing list, then the changes will reflect in the underlying list.

Keep in mind that while reversed() returns an iterator, the .reverse() method returns None. This behavior may be the source of subtle errors when you’re starting to use lists. Consider the following code:

>>> digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> reversed_digits = digits.reverse()
>>> reversed_digits is None
True

In this example, reversed_digits doesn’t get a list of reversed digits. Instead, it gets None because .reverse() mutates the underlying list in place and has no fruitful return value.

Finally, slicing is another technique that you can use to get a reversed copy of an existing list. To do this, you can use the following slicing operation:

>>> digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> digits[::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

The [::-1] variation of the slicing operator does the magic in this code. With this operator, you create a reversed copy of the original list. But how does it work? The third index, step, is typically a positive number, which is why a normal slicing operation extracts the items from left to right.

By setting step to a negative number, such as -1, you tell the slicing operator to extract the items from right to left. That’s why you get a reversed copy of digits in the example above.

Sorting a List: sorted() and .sort()

When you need to sort a list of values without altering the original list, you can use the built-in sorted() function. This function takes an iterable of values and returns a list of sorted values:

>>> numbers = [2, 9, 5, 1, 6]

>>> sorted(numbers)
[1, 2, 5, 6, 9]

>>> numbers
[2, 9, 5, 1, 6]

When you pass a list to sorted(), you get a list of sorted values as a result. The function doesn’t alter the original data in your list.

As you can see in the above example, Python sorts numbers according to their specific values. When it comes to sorting strings, things can be a bit confusing. Consider the following example:

>>> words = ["Hello,", "World!", "I", "am", "a", "Pythonista!"]

>>> sorted(words)
['Hello,', 'I', 'Pythonista!', 'World!', 'a', 'am']

What? The sorted list isn’t in alphabetical order. Why? Python sorts strings character by character using each character’s Unicode code point. Because uppercase letters come before lowercase letters in Python’s default character set, UTF-8, you end up with "Hello" in the first position and "am" in the last.

You can use the built-in ord() function to get the Unicode code point of a character in Python:

>>> ord("H")
72
>>> ord("a")
97

As you can confirm in this code snippet, the uppercase "H" comes before the lowercase "a" in the Unicode table. That’s why you get "Hello" before "am" in the above example.

By default, the sorted() function sorts the items of a list in ascending order. If you need to sort the items in descending order, then you can use the reverse keyword-only argument. This argument defaults to False. If you set it to True, then you get the data in descending order:

>>> numbers = [2, 9, 5, 1, 6]

>>> sorted(numbers, reverse=True)
[9, 6, 5, 2, 1]

By setting the reverse argument to True, you tell sorted() to sort the input iterable in reverse order. Isn’t that neat?

>>> numbers = [2, "9", 5, "1", 6]

>>> sorted(numbers)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'

To illustrate how sorted() can help you in the real world, say that you want to calculate the median of a numeric dataset or sample. The median is the value that lies in the middle when you sort the data. In most cases, your data won’t be sorted, so sorting will be the first step. Then you just need to locate the value in the middle.

If the number of values in your dataset is even, then the median is the average of the two values in the middle. Here’s a Python function that allows you to compute the median of a sample of values:

>>> def median(samples):
...     n = len(samples)
...     middle_index = n // 2
...     sorted_samples = sorted(samples)
...     # Odd number of values
...     if n % 2:
...         return sorted_samples[middle_index]
...     # Even number of values
...     lower, upper = middle_index - 1, middle_index + 1
...     return sum(sorted_samples[lower:upper]) / 2
...

>>> median([3, 5, 1, 4, 2])
3

>>> median([3, 5, 1, 4, 2, 6])
3.5

Inside median(), you use sorted() to sort the samples in ascending order. Then you check if your list has an odd number of data points, in which case, you return the item in the middle directly. If the list has an even number of samples, then you compute the index of the two items in the middle, calculate their average, and return the resulting value.

The sorted() function also accepts another keyword-only argument called key. This argument allows you to specify a one-argument function that will extract a comparison key from each list item.

As an example of how to use key, say that you have a list of tuples where each tuple holds an employee’s data, including the employee’s name, age, position, and salary. Now imagine that you want to sort the employees by their age.

In that situation, you can do something like the following:

>>> employees = [
...     ("John", 30, "Designer", 75000),
...     ("Jane", 28, "Engineer", 60000),
...     ("Bob", 35, "Analyst", 50000),
...     ("Mary", 25, "Service", 40000),
...     ("Tom", 40, "Director", 90000)
... ]

>>> sorted(employees, key=lambda employee: employee[1])
[
    ('Mary', 25, 'Service', 40000),
    ('Jane', 28, 'Engineer', 60000),
    ('John', 30, 'Designer', 75000),
    ('Bob', 35, 'Analyst', 50000),
    ('Tom', 40, 'Director', 90000)
]

In this example, you pass a lambda function to the key argument. This lambda takes an employee tuple as an argument and returns the age value, which lives at index 1. Then sorted() uses this value to sort the tuples.

The key argument is quite useful in practice because it allows you to fine-tune the sorting process by changing the sorting criteria according to your specific needs.

If you need to sort a list in place instead of getting a new list of sorted data, then you can use the .sort() method. This method is similar to the sorted() function:

>>> numbers = [2, 9, 5, 1, 6]

>>> numbers.sort()
>>> numbers
[1, 2, 5, 6, 9]

The main difference between sorted() and .sort() is that the former returns a new list of sorted data, while the latter sorts the target list in place. Also, because .sort() is a method, you need to call it on a list object.

Like most list methods that run mutations, .sort() returns None. For example, in the code below, you run into a common mistake that can occur when working with lists:

>>> numbers = [2, 9, 5, 1, 6]

>>> sorted_numbers = numbers.sort()
>>> sorted_numbers is None
True

The .sort() method sorts the list in place and returns None to remind users that it operates by side effect. You must keep this behavior in mind because it can lead to subtle bugs.

You can also use the reverse and key keyword-only arguments with .sort(). They have the same meaning and functionality as the equivalent arguments in the sorted() function. Go ahead and give them a try!

Using a for Loop to Iterate Over a List

The recommended way to iterate over a list is to use a for loop. This kind of loop is quite readable and straightforward in Python. Here’s how it goes:

>>> colors = [
...     "red",
...     "orange",
...     "yellow",
...     "green",
...     "blue",
...     "indigo",
...     "violet"
... ]

>>> for color in colors:
...     print(color)
...
red
orange
yellow
green
blue
indigo
violet

To use a for loop with a list, you place the list after the in keyword and provide a suitable loop variable. Don’t you think this loop is beautiful? Its meaning is clear, and it reads like plain English. That’s great!

Python’s for loops are intrinsically ready to operate on any iterable input directly. In this example, you’re using a list, but it’d work the same with a tuple, string, set, or any other iterable.

In the above example, the target iterable is your colors list. The loop variable, color, holds the current color in each iteration, and you can process each color in the loop’s body as needed. Note that if your list has a plural noun as its name, then the loop variable can use the same name in singular. This tiny detail will improve your loop’s readability.

A coding pattern that you’ll usually notice in code by people who come from other programming languages is that they tend to iterate over lists using a for loop that looks something like this:

>>> for i in range(len(colors)):
...     print(colors[i])
...
red
orange
yellow
green
blue
indigo
violet

This loop iterates over a range of integer numbers from 0 up to the length of the target list. In each iteration, you use the current index to access the associated item in the underlying list. Even though this loop works, it’s not Pythonic and is considered bad practice.

You don’t have to use a range of indices to iterate over a list in a for loop. Just go ahead and use your list directly in the loop definition. Python will take care of the rest.

Some people will argue that, in many situations, you’ll need to know the index of the current item to be able to perform some computations. That’s right! It’s especially true when you’re dealing with complex algorithms that operate on indices. In those cases, Python has you covered as well. It offers you the built-in enumerate() function, which you can use as in the following example:

>>> for i, color in enumerate(colors):
...     print(f"{i} is the index of '{color}'")
...
0 is the index of 'red'
1 is the index of 'orange'
2 is the index of 'yellow'
3 is the index of 'green'
4 is the index of 'blue'
5 is the index of 'indigo'
6 is the index of 'violet'

The enumerate() function takes an iterable and returns an iterator. This iterator yields two-item tuples on demand. Each tuple will contain an index and the associated item.

Python provides many other tools that you can use when you’re iterating through a list of values. For example, you can use reversed() to iterate over the list in reverse order:

>>> for color in reversed(colors):
...     print(color)
...
violet
indigo
blue
green
yellow
orange
red

In this loop, you take advantage of the reversed() function to traverse your list of colors in reverse order, which might be a common requirement in your code.

Another common need is to traverse the list in sorted order. In this situation, you can use your old friend sorted() as in the code below:

>>> numbers = [2, 9, 5, 1, 6]

>>> for number in sorted(numbers):
...     print(number)
...
1
2
5
6
9

The sorted() function allows you to get a new list of sorted data from your original list. Then you iterate over the new sorted list as usual.

If you continue digging into the Python tool kit, then you’ll find many other tools that will allow you to traverse your lists in different ways. For example, you’ll have the zip() function, which allows you to iterate over multiple lists in parallel:

>>> integers = [1, 2, 3]
>>> letters = ["a", "b", "c"]
>>> floats = [4.0, 5.0, 6.0]

>>> for i, l, f in zip(integers, letters, floats):
...     print(i, l, f)
...
1 a 4.0
2 b 5.0
3 c 6.0

In this example, you use zip() to iterate over three lists in parallel. The zip() function returns an iterator of tuples. The elements of each tuple come from the input iterables. In this example, the tuples combine items from integers, letters, and floats.

Up to this point, all your list-traversing examples iterate over a list without performing any modification on the list itself. Modifying a list during iteration can lead to unexpected behavior and bugs, so avoid this practice. As a rule of thumb, if you need to modify the content of a list in a loop, then take a copy of that list first.

Say that you have a list of numbers, and you want to remove only odd values. In this situation, you can try something like this as your first attempt:

>>> numbers = [2, 9, 5, 1, 6]

>>> for number in numbers:
...     if number % 2:
...         numbers.remove(number)
...
>>> numbers
[2, 5, 6]

Unfortunately, only 9 and 1 were removed, while 5 remained in your list. This unexpected and incorrect behavior happened because removing items from a list shifts their indices, which interferes with the indices inside a running for loop. You can avoid this problem in a few ways.

For example, you can iterate over a copy of the original list:

>>> numbers = [2, 9, 5, 1, 6]

>>> for number in numbers[:]:
...     if number % 2:
...         numbers.remove(number)
...
>>> numbers
[2, 6]

This time, the result is correct. You use the [:] operator to create a shallow copy of your list. This copy allows you to iterate over the original data in a safe way. Once you have the copy, then you feed it into the for loop, as before.

Alternatively, you can iterate over the list in reverse order:

>>> numbers = [2, 9, 5, 1, 6]

>>> for number in reversed(numbers):
...     if number % 2:
...         numbers.remove(number)
...
>>> numbers
[2, 6]

When you remove only the last item from the right end of a list on each iteration, you change the list length, but the indexing remains unaffected. This lets you correctly map indices to the corresponding list elements.

Note that this was just an illustrative example that relied on cherry-picked data. Remember that calling .remove() deletes the first occurrence of the given value, starting from the left side of the list, instead of the last one. If you had duplicate values on the list, then list elements would be removed in a different order.

While modifying list elements during iteration is less of a problem than deleting them, it also isn’t considered a good practice. It’s usually more desirable to create a completely new list and populate it with the transformed values:

>>> numbers_as_strings = ["2", "9", "5", "1", "6"]

>>> numbers_as_integers = []
>>> for number in numbers_as_strings:
...     numbers_as_integers.append(int(number))
...

>>> numbers_as_integers
[2, 9, 5, 1, 6]

This example shows a pretty common pattern in Python. The pattern consists of creating an empty list and then populating it in a loop. You’ll find this pattern in several Python codebases all around. It provides an intuitive and readable way to populate a list from scratch. However, you’ll often find that you can replace this pattern with something even better, a list comprehension.

Building New Lists With Comprehensions

List comprehensions are another great, popular way to traverse your lists. Comprehensions are fundamentally a list transformation tool. They allow you to create lists with transformed data out of another list or iterable.

To understand how comprehensions can help you transform your lists, refer to the example where you have a list of numbers as strings and want to turn them into integers. You can solve this problem with the following comprehension:

>>> numbers = ["2", "9", "5", "1", "6"]

>>> numbers = [int(number) for number in numbers]
>>> numbers
[2, 9, 5, 1, 6]

This comprehension iterates over the values in your original list. The expression in the comprehension runs the conversion from string to integer. The final result is a new list object, which you assign back to the numbers variable.

Note that this comprehension is equivalent to a loop with the enumerate() function:

>>> numbers = ["2", "9", "5", "1", "6"]

>>> for i, number in enumerate(numbers):
...     numbers[i] = int(number)
...

>>> numbers
[2, 9, 5, 1, 6]

The loop is more verbose and complicated because you need to call enumerate() and declare an extra indexing variable, i. On the other hand, the loop modifies the original list in place, while the list comprehension creates a new list.

You can also use comprehensions to filter existing lists. For example, say that you have a list of integer values and want to create a new list containing only the even values out of your original list:

>>> integers = [20, 31, 52, 6, 17, 8, 42, 55]

>>> even_numbers = [number for number in integers if number % 2 == 0]
>>> even_numbers
[20, 52, 6, 8, 42]

The if clause in this list comprehension works as a filter that selects only the even numbers from your original data. How would you write a similar comprehension to retrieve the odd numbers?

Processing Lists With Functional Tools

You can also take advantage of some Python functional programming tools, such as map() and filter(), to traverse a list of values. These functions have an internal loop that iterates over the items of an input iterable and returns a given result.

For example, the map() function takes a transformation function and an iterable as arguments. Then it returns an iterator that yields items that result from applying the function to every item in the iterable.

Using map(), you can convert your list of numbers to integers with the following code:

>>> numbers = ["2", "9", "5", "1", "6"]

>>> numbers = list(map(int, numbers))
>>> numbers
[2, 9, 5, 1, 6]

In this example, map() applies int() to every item in numbers in a loop. Because map() returns an iterator, you’ve used the list() constructor to consume the iterator and show the result as a list.

If you need to filter values from an existing list, then you can use the built-in filter() function. This function takes two arguments: a predicate function and an iterable of data. Then it returns an iterator that yields items that meet a given condition, which the predicate function tests for.

Here’s how filter() works in practice:

>>> integers = [20, 31, 52, 6, 17, 8, 42, 55]

>>> even_numbers = list(filter(lambda number: number % 2 == 0, integers))
>>> even_numbers
[20, 52, 6, 8, 42]

In this example, you use filter() to traverse your integers list and extract those values that satisfy the condition of being even numbers.

In Python, you’ll find a few other built-in and standard-library functions that allow you to traverse a list of values and obtain a final result either as another list, an iterator, or even a single value. Some examples include reduce(), min() and max(), sum(), all(), and any(). Note that some of these functions aren’t really functional programming tools, but they internally iterate over the input list.

Finding Items in a List

Python has a few tools that allow you to search for values in an existing list. For example, if you only need to quickly determine whether a value is present in a list, but you don’t need to grab the value, then you can use the in or not in operator, which will run a membership test on your list.

As its name suggests, a membership test is a Boolean test that allows you to find out whether an object is a member of a collection of values. The general syntax for membership tests on list objects looks something like this:

item in list_object

item not in list_object

The first expression allows you to determine if item is in list_object. It returns True if it finds item in list_object or False otherwise. The second expression works in the opposite way, allowing you to check if item is not in list_object. In this case, you get True if item doesn’t appear in list_object.

Here’s how membership tests work in practice:

>>> usernames = ["john", "jane", "bob", "david", "eve"]

>>> "linda" in usernames
False
>>> "linda" not in usernames
True

>>> "bob" in usernames
True
>>> "bob" not in usernames
False

In this example, you have a list of users and want to determine whether some specific users are registered in your system.

The first test uses in to check whether the user linda is registered. You get False because that user isn’t registered. The second test uses the not in operator, which returns True as a confirmation that linda isn’t one of your users.

The .index() method is another tool that you can use to find a given value in an existing list. This method traverses a list looking for a specified value. If the value is in the list, then the method returns its index. Otherwise, it raises a ValueError exception:

>>> usernames = ["john", "jane", "bob", "david", "eve"]

>>> usernames.index("eve")
4

>>> usernames.index("linda")
Traceback (most recent call last):
    ...
ValueError: 'linda' is not in list

In the first call to .index(), you get the index where you can find the user named "eve". You can use this index later in your code to access the actual object as needed. In the second call, because the user "linda" isn’t in the list, you get a ValueError with an explanatory message.

Note that if your search’s target value appears several times in the list, then .index() will return the index of the first occurrence:

>>> sample = [12, 11, 10, 50, 14, 12, 50]

>>> sample.index(12)
0
>>> sample.index(50)
3

The .index() method returns as soon as it finds the input value in the underlying list. So, if the value occurs many times, then .index() always returns the index of the first occurrence.

Lists provide yet another method that you can use for searching purposes. The method is called .count(), and it allows you to check how many times a given value is present in a list:

>>> sample = [12, 11, 10, 50, 14, 12, 50]

>>> sample.count(12)
2
>>> sample.count(11)
1
>>> sample.count(100)
0

The .count() method takes an item as an argument and returns the number of times the input item appears in the underlying list. If the item isn’t in the list, then you get 0.

Searching for a specific value in a Python list isn’t a cheap operation. The time complexity of .index(), .count(), and membership tests on lists is O(n). Such linear complexity may be okay if you don’t need to perform many lookups. However, it can negatively impact performance if you need to run many of these operations.

Getting the Length, Maximum, and Minimum of a List

While working with Python lists, you’ll face the need to obtain descriptive information about a given list. For example, you may want to know the number of items in the list, which is known as the list’s length. You may also want to determine the greatest and lowest values in the list. In all these cases, Python has you covered.

To determine the length of a list, you’ll use the built-in len() function. In the following example, you use this function as an intermediate step to calculate the average grade of a student:

>>> grades = [80, 97, 86, 100, 98, 82]
>>> n = len(grades)
>>> sum(grades) / n
90.5

Here, you calculate the average grade of a student. To do this, you use the sum() function to get the total sum and len() to get the number of evaluated subjects, which is the length of your grades list.

It’s important to note that because lists keep track of their length, calling len() is pretty fast, with a time complexity of O(1). So, in most cases, you don’t need to store the return value of len() in an intermediate variable as you did in the example above.

Another frequent task that you’ll perform on lists, especially on lists of numeric values, is to find the minimum and maximum values. To do this, you can take advantage of the built-in min() and max() functions:

>>> min([3, 5, 9, 1, -5])
-5

>>> max([3, 5, 9, 1, -5])
9

In these examples, you call min() and max() with a list of integer numbers. The call to min() returns the smallest number in the input list, -5. In contrast, the call to max() returns the largest number in the list, or 9.

Overall, Python lists support the len(), min(), and max() functions. With len(), you get the length of a list. With min() and max(), you get the smallest and largest values in a list. All these values can be fairly useful when you’re working with lists in your code.

Comparing Lists

You can also face the need to compare lists. Fortunately, list objects support the standard comparison operators. All these operators work by making item-by-item comparisons within the two involved lists:

>>> [2, 3] == [2, 3]
True
>>> [5, 6] != [5, 6]
False

>>> [5, 6, 7] < [7, 5, 6]
True
>>> [5, 6, 7] > [7, 5, 6]
False

>>> [4, 3, 2] <= [4, 3, 2]
True
>>> [4, 3, 2] >= [4, 3, 2]
True

When you compare two lists, Python uses lexicographical ordering. It compares the first two items from each list. If they’re different, this difference determines the comparison result. If they’re equal, then Python compares the next two items, and so on, until either list is exhausted.

In these examples, you compare lists of numbers using the standard comparison operators. In the first expression above, Python compares 2 and 2, which are equal. Then it compares 3 and 3 to conclude that both lists are equal.

In the second expression, Python compares 5 and 5. They’re equal, so Python has to compare 6 and 6. They’re equal too, so the final result is False.

In the rest of the expressions, Python follows the same pattern to figure out the comparison. In short, Python compares lists in an item-by-item manner using lexicographical comparison. The first difference determines the result.

You can also compare lists of different lengths:

>>> [5, 6, 7] < [8]
True

>>> [5, 6, 7] == [5]
False

In the first expression, you get True as a result because 5 is less than 8. That fact is sufficient for Python to solve the evaluation. In the second example, you get False. This result makes sense because the lists don’t have the same length, so they can’t be equal.

As you can see, comparing lists can be tricky. It’s also an expensive operation that, in the worst case, requires traversing two entire lists. Things get more complex and expensive when you compare lists of strings. In this situation, Python will also have to compare the strings character by character, which adds cost to the operation.

Removing Repeated Items From a List

Removing repeated items from an existing list is often a requirement in Python. You’ll probably manage to figure out several approaches to this problem. Using a set object could be one of them because sets don’t allow repeated items. So, you can do something like this:

>>> list(set([2, 4, 5, 2, 3, 5]))
[2, 3, 4, 5]

This solution works because you get a new list of unique values. However, Python sets don’t necessarily keep the contained items in order. So, you may want to use another technique that preserves the original insertion order.

Arguably, the safest way to tackle the problem of removing repeated items from a list is to create a new list with unique values out of the original list. You can do this in a function like the following:

>>> def get_unique_items(list_object):
...     result = []
...     for item in list_object:
...         if item not in result:
...             result.append(item)
...     return result
...

>>> get_unique_items([2, 4, 5, 2, 3, 5])
[2, 4, 5, 3]