1. 5 Examples of List Comprehension in Python

List comprehension is an essential feature in Python that enables developers to create lists in a concise and readable way. With list comprehension, you can write advanced programs that handle complex operations with fewer lines of code. Python list comprehension involves creating a list from an iterable object, such as a list, tuple, or set. In this article, we’ll explore five examples of list comprehension in Python.

1. Filtering data
List comprehension is an excellent way to filter elements in a list based on specific criteria. For instance, you can create a new list that contains only positive integers from an existing list. Here is an example:

“`python
original_list = [1, 2, -3, 4, -5, 6, -7, 8, -9]
new_list = [x for x in original_list if x > 0]
print(new_list)
“`
Output:
“`python
[1, 2, 4, 6, 8]
“`
In this example, we create a new list (new_list) that contains only positive numbers from the original list. The condition “if x > 0” specifies that we only want elements greater than zero.

2. Mapping data
List comprehension can also help you create a new list with elements that have undergone a specific transformation. For example, you can create a list of squares for a given list of numbers. Here is an example:

“`python
original_list = [1, 2, 3, 4, 5]
squares = [x * x for x in original_list]
print(squares)
“`
Output:
“`python
[1, 4, 9, 16, 25]
“`
In this example, we create a new list “squares” that contains the squares of the original list elements. We use the expression “x * x” to square each element in the original list.

3. Nested list comprehension
List comprehension allows you to embed one list comprehension inside another. This technique is known as nested list comprehension. Consider the following example where we want to create a list of tuples containing two elements, where each element is a combination of two lists:

“`python
list1 = [“A”, “B”, “C”]
list2 = [1, 2]
result = [(x, y) for x in list1 for y in list2]
print(result)
“`

Output:
“`python
[(‘A’, 1), (‘A’, 2), (‘B’, 1), (‘B’, 2), (‘C’, 1), (‘C’, 2)]
“`
In this example, we create a list of tuples(list1, list2) where the elements of the first list are paired with the elements of the second list.

4. Conditional nested list comprehension
In nested list comprehension, you can use conditions to filter elements in the inner and outer loops independently. Here is an example where we create a new list that contains only tuples where the sum of the elements is greater than six:

“`python
list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = [(x, y) for x in list1 for y in list2 if x + y > 6]
print(result)
“`

Output:
“`python
[(2, 5), (3, 4), (3, 5)]
“`
In this example, we use a condition “if x + y > 6” to select only the tuples whose sum is greater than six.

5. Creating a dictionary
List comprehension can also be used to create a dictionary instead of a list. Consider the following example where we create a dictionary that contains the squares of the keys:

“`python
dict1 = {x: x*x for x in range(1, 6)}
print(dict1)
“`

Output:
“`python
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
“`
In this example, we create a dictionary where the key is a number from 1 to 5, and the value is the square of the key.

Conclusion
Python list comprehension is a powerful tool for creating lists in a concise and readable way. The above examples demonstrate how you can use list comprehension for filtering data, mapping data, creating nested lists, and dictionaries. By mastering list comprehension, you can simplify your code, improve readability, and enhance your programming skills.