Let’s start with a simple list.
Quite often, we’ll need to build a new list from the elements of an existing list. For example, let’s say we want to make a list containing all elements of
my_list, each multiplied by 2. A common way to do this is by iterating through the existing list and building the new list:
Now let’s take a look at how to do this using Python’s list comprehension syntax.
The syntax for list comprehension is based on set builder notation. Given the form
[Y for X in LIST],
Y is commonly referred to as the output function ,
X is the variable, and
LIST is the input set. This statement says to do
Y on each
For an example of using a different output function , let’s say say we want a new list that contains each number in
my_list as a string type…
You may be asking yourself why we wouldn’t just use
In this example,
map looks like a good alternative. However, for slightly more complicated requirements, list comprehension can be a bit more concise. For example, when we’d like to specify a predicate .
Consider our previous example, where we want to create a list of string types for each element in
my_list, except this time we only want the elements which are even numbers. A typical way to do this would be:
In order to use
map() here we would need to first
filter the list to exclude the odd numbers.
Using the list comprehension syntax would look like this:
This version introduces the predicate, an expression after the list which acts as a filter on which elements get passed to the output function.
Neat, clear and concise.
Loops of loops.
Finally, it’s worth mentioning that you can use list comprehensions to iterate on more than one list. For example:
Just like you would expect in
for loops, the last loop moves the fastest. Also note that this method returns a list of
tuples. If you’d like nested lists, you can also nest one list comprehension within another.
List comprehension in Python can often provide a neat, clear, and concise syntax for creating lists from other lists. However, one should always be aware that, particularly for complex transformations or predicates, the concise and terse syntax can quickly become very difficult to read. In these cases, it’s often beneficial to revert to traditional looping constructs.