Detailed explanation of list comprehensions in Python

List comprehension in Python is a convenient and fast syntax that can quickly generate lists. Its grammatical form is similar to set derivation in mathematics, and its semantics are also similar, making it easy to understand and use. List comprehensions in Python will be introduced in detail below.

1. Basic grammatical structure

The basic grammatical structure of list comprehension is:

[expression for item in iterable if condition]

where, expression Represents expressions involved in list generation, which can include operations such as variables and function calls; item represents elements in the generated list; iterable represents iterable objects, such as lists, tuples, sets, etc.; if condition represents the filtering of conditions, which can Omit.

2. Common usage scenarios

1. Generate a list of integers

For example, to generate a list of integers between 1 and 10, you can use the following code:

num_list = [i for i in range(1,11)]
print(num_list)

The output result is:

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

The range() function is used here to generate an integer iterator between 1 and 10, and then the elements are extracted one by one through list comprehension and formed into a list.

2. Generate a square list

For example, to generate a square list of integers between 1 and 10, you can use the following code:

square_list = [i**2 for i in range(1,11)]
print(square_list)

The output result is:

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

3. Filter list elements

For example, to filter out strings longer than 3 from a string list, you can use the following code:

str_list = ['hello', 'world', 'python', 'list', 'comprehension', 'study']
new_list = [s for s in str_list if len(s) > 3]
print(new_list)

The output result is:

['hello', 'world', 'python', 'comprehension', 'study']

The if statement is used here to conditionally filter elements. Only strings with a length greater than 3 can be entered into the new list.

4. Multiple loops

For example, to generate all products between 1 and 9, you can use the following code:

mul_list = [i*j for i in range(1,4) for j in range(1,4)]
print(mul_list)

The output result is:

[1, 2, 3, 2, 4, 6, 3, 6, 9]

The multiplication operation is implemented here through two levels of loops, that is, when i and j are 1, 2, and 3 respectively, their product constitutes the elements in the list.

3. Nested list comprehensions

Sometimes you need to perform more complex operations on the elements when generating a list. In this case, you can use nested list comprehensions. A nested list comprehension is a list comprehension nested again on the basis of a list comprehension. Its syntax structure is:

[ expression for item in iterable if condition for sub_item in sub_iterable if sub_condition ]

Among them, the meanings of expression, item, iterable and condition are consistent with the above basic syntax structure; sub_item represents the element traversed again based on item traversal; sub_iterable represents the iteration object of sub_item; sub_condition represents the filtering condition for sub_item.

The following are several common examples of nested list comprehensions.

1. Generate a square matrix

For example, to generate a 3×3 square matrix you can use the following code:

matrix = [[i*j for j in range(1,4)] for i in range(1,4)]
for row in matrix:
    print(row)

The output result is:

[1, 2, 3]
[2, 4, 6]
[3, 6, 9]

This Two levels of nested derivation are used here. The outer derivation generates three lists, and the inner derivation generates three elements in each list, thus forming a 3×3 square matrix.

2. Filter odd and even numbers

For example, to filter out odd numbers and even numbers from a list of integers to form two lists respectively, you can use the following code:

num_list = [1,2,3,4,5,6,7,8,9,10]
odd_list = [i for i in num_list if i%2 == 1]
even_list = [i for i in num_list if i%2 == 0]
print(odd_list)
print(even_list)

The output results are respectively :

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

Two nested list comprehensions are used here to filter out the odd and even elements in the original list respectively.

4. Summary

List comprehension is one of the excellent grammatical features of the Python language. It can easily generate various types of lists and also supports advanced features such as nesting. . In actual programming, learning and using list comprehensions can greatly improve the efficiency and readability of code writing.

The above is the detailed content of Detailed explanation of list comprehensions in Python. For more information, please follow other related articles on the PHP Chinese website!