In Python, list comprehensions are a sophisticated and concise approach to generating lists. They can be used in a single line of code to filter, map, and decrease the iterations. List comprehensions create new lists through the use of an expression to every item in the current iterable (such as an list item, tuple item, or range item) and sometimes filtering the items depending on a condition. It can potentially improve the Python code readability and reduce the number of necessary lines.

Developers can choose one of the following syntaxes to implement:

Basic List Comprehension

The following Python code shows two methods to produce an array of squares of integers that range from 1 to 5: a “for” loop and with a list comprehension approach.

Using a “For” Loop

This code generates an empty array called for_squares_lc. Then, it loops over the integers 1 through 5, squaring each one and adding it to the for_squares_lc. Finally, it outputs the for_squares_lc to the command prompt.

Using a List Comprehension

This code’s list comprehension loops through the numbers from 1 to 5, squaring each number, and stores it to the new list. Finally, the updated list is printed.

The two code pieces get the same result:

List comprehension, on the other hand, is briefer and more efficient. This is because the list comprehension doesn’t require the creation of an empty list and then appending to it. On the contrary, the list comprehension directly creates the new list.

List Comprehension with a Condition

The result of evaluating the expression for every item within the iterable will be added into the new list. The condition is optional; if it is present, only the items for which the condition evaluates to True are included in the new list. For loops are a more traditional way to iterate over a list.

Example 1: Create and Print a List of All the Even Digits/Numbers from 1 to 20

Both code snippets produce the same output:

Example 2: Create a List of All the Vowels in a String

For your reference, the outcome of the previously mentioned code is attached in the following:

Example 3: Create a List of All the Uppercase Letters in a String

We included the result of the code that we added in this example:

Example 4: Create a List of All the Cubes of the Numbers from 1 to 5

In the following instance, we incorporated the result of the code:

Example 5: Make a List of All the List Elements that Are Larger Than 5

Check out the output of this code here:

List Comprehension with an Else Clause

A list comprehension with an “else” clause allows the Python developer to specify a value to be included in the list if the condition is unmet. Here is the syntax for a list comprehension of the “if & else” statement:

If the condition evaluates to “True”, the expression following the “if” statement is assessed for each of the elements in the iterative, and the result of that evaluation is added to the new list. If the condition is not True or False, the expression after the “else” statement is evaluated, and the result is moved to the new list.

Example 1:

The function lists all files in the current or supplied directory with a “.py” extension or “no Python file” if the file name does not have a “.py” extension:

DisplayFileType.py:

Here’s the step-by-step explanation of the code:

1. directory = “E:WorkComprehension”: The directory parameter specifies the directory path to be examined, with backslashes escaped using double backslashes or a raw string, particularly when working with Windows file paths.
2. python_files = [file for file in os.listdir(directory) if pfileObj.endswith(“.py”)]:
   • In os.listdir(directory), a list of every single file and folder in the specified directory is retrieved.
   • The list comprehension [file for file in os.listdir(directory) if pfileObj.endswith(“.py”)] iterates over each item (file or directory) in the directory and filters out only those that end with “.py”. These are assumed to be Python files.
   • The filtered Python files are collected into the python_files list.
3. non_python_files = [“no Python file” if file not in python_files else file for file in os.listdir(directory)]:
   • This list comprehension iterates over each item (file or directory) in the directory using os.listdir(directory).
   • For each item, it checks if it’s in the python_files list using the file, not in the python_files condition.
   • If the item is not in the python_files list (i.e., it’s not a Python file), it assigns the “no Python file” string to non_python_files. Otherwise, it includes the filename in non_python_files.
4. print(python_files): This line prints the list of Python files in the specified directory.
5. print(non_python_files): This line prints the list of non-Python files and directories that is found in the specified directory. If an item in the directory is not a Python file, it will be represented as “no Python file” in this list.

Here is the output of the file:

Example 2: Create a List of All the Prime Numbers from 1 to 20 or “Composite” If the Number is Composite

PrintPrime.py

To see the output, open the command prompt using the Windows operating system and execute the code using the Python compiler. Here is the successful execution and printing of prime numbers on the screen:

This code works by creating an empty list called even_odd_loop. Then, it iterates over the numbers from 1 to 5, checking if each number is even or odd. If the number is even, the code appends the “Even” string to the even_odd_loop list. If the number is odd, the code appends the “Odd” string to the even_odd_loop list. Finally, the code prints the even_odd_loop list to the console. This code generates a list comprehension.

A list comprehension is a convenient way to build a new list from an iterable that already exists. The list comprehension in the following line of code iterates across the integers 1 to 5, evaluating the “Even’ if x% 2 == 0, else ‘Odd” expression. This expression’s result is then added to the new list. Finally, the code outputs the newly created list to the terminal.

OddEven.py:

Both of these code snippets produce the same output:

Conclusion

When used appropriately, the list comprehension can significantly simplify and increase the code readability. However, if you fail to make them too clever, the readability will suffer if they get too nested or intricate.