Every list comprehension in Python includes three elements: expression is the member itself, a call to a method, or any other valid expression that returns a value. In the example above, the expression i. i is the square of the member value. Member is the object or value in the list or iterable. However, Python has an easier way to solve this issue using List Comprehension. List comprehension is an elegant way to define and create lists based on existing lists. Let’s see how the above program can be written using list comprehensions. Example 2: Iterating through a string Using List Comprehension. A list comprehension is a syntactic construct available in some programming languages for creating a list based on existing lists. It follows the form of the mathematical set-builder notation (set comprehension) as distinct from the use of map and filter functions.
A comprehension is a compact way of creating a Python data structure from iterators. With comprehensions, you can combine loops and conditional tests with a less verbose syntax.
Comprehension is considered more Pythonic and often useful in a variety of scenarios.
What is List Comprehension?
List comprehension sounds complex but it really isn’t.
List comprehension is a way to build a new list by applying an expression to each item in an iterable.
It saves you having to write several lines of code, and keeps the readability of your code neat.
Basic Example
Suppose you want to create a list of all integer square numbers from 0 to 4. You could build that list by appending one item at a time to an empty list:
Or, you could just use an iterator and the range() function:
Here both approaches produce the same result. However, a more Pythonic way to build a list is by using a list comprehension.
The general syntax for a list comprehension is:
Here’s how a list comprehension would build the above list:
In the example above, list comprehension has two parts.
The first part collects the results of an expression on each iteration and uses them to fill out a new list.
The second part is exactly the same as the for loop, where you tell Python which iterable to work on. Every time the loop goes over the iterable, Python will assign each individual element to a variable x.
More Examples
Below are few examples of list comprehension.
Example 1
List comprehensions can iterate over any type of iterable such as lists, strings, files, ranges, and anything else that supports the iteration protocol.
Here’s a simple list comprehension that uses string as an iterable.
Example 2
Following example applies abs() function to all the elements in a list.
Example 3
Following example calls a built-in method strip() on each element in a list.
Example 4
Following example creates a list of (number, square) tuples. Please note that, if a list comprehension is used to construct a list of tuples, the tuple values must be enclosed in parentheses.
Here’s why you should use list comprehension more often:
- List comprehensions are more concise to write and hence they turn out to be very useful in many contexts.
- Since a list comprehension is an expression, you can use it wherever you need an expression (e.g. as an argument to a function, in a return statement).
- List comprehensions run substantially faster than manual for loop statements (roughly twice as fast). It offers a major performance advantage especially for larger data sets.
List Comprehension with if Clause
A list comprehension may have an optional associated if clause to filter items out of the result.
Iterable’s items are skipped for which the if clause is not true.
This list comprehension is the same as a for loop that contains an if statement:
List Comprehension Python Print
Nested List Comprehensions
The initial expression in a list comprehension can be any expression, including another list comprehension.
For example, here’s a simple list comprehension that flattens a nested list into a single list of items.
Here’s another list comprehension that transposes rows and columns.
List Comprehension vs map() + lambda
When all you’re doing is calling an already-defined function on each element, map(f, L) is a little faster than the corresponding list comprehension [f(x) for x in L]. Following example collects the ASCII codes of all characters in an entire string.
However, when evaluating any other expression, [some_expr for x in L] is faster and clearer than map(lambda x: some_expr, L), because the map incurs an extra function call for each element. Following example creates a list of all integer square numbers.
List Comprehension vs filter() + lambda
List comprehension with if clause can be thought of as analogous to the filter() function as they both skip an iterable’s items for which the if clause is not true. Following example filters a list to exclude odd numbers.
As with map() function, filter() is slightly faster if you are using a built-in function.
List Comprehensions and Variable Scope
In Python 2, the iteration variables defined within a list comprehension remain defined even after the list comprehension is executed.
List Comprehension Python Mcq
For example, in [x for x in L], the iteration variable x overwrites any previously defined value of x and is set to the value of the last item, after the resulting list is created.
so, remember to use variable names that won’t conflict with names of other local variables you have.
List Comprehension Python Dictionary
Fortunately, this is not the case in Python 3 where the iteration variable remains private, so you need not worry.
Comments are closed.