A common use of a for loop is to inspect each item in an iterable and build a new list by appending the results of an expression computed on some or all of the items. The expression form known as a list comprehension lets you code this common idiom concisely and directly. Since a list comprehension is an expression (rather than a block of statements), you can use it wherever you need an expression (e.g., as an argument in a function call, in a return statement, or as a subexpression for some other expression).
A list comprehension has the following syntax:
[ expression for target in iterable lc-clauses ]
target and iterable are the same as in a regular for statement. You must enclose the expression in parentheses if it indicates a tuple.
lc-clauses is a series of zero or more clauses, each with one of the following forms:
for target in iterable if expression
target and iterable in each for clause of a list comprehension have the same syntax and meaning as those in a regular for statement, and the expression in each if clause of a list comprehension has the same syntax and meaning as the expression in a regular if statement.
A list comprehension is equivalent to a for loop that builds the same list by repeated calls to the resulting list's append method. For example (assigning the list comprehension result to a variable for clarity):
result1 = [x+1 for x in some_sequence]
is the same as the for loop:
result2 =  for x in some_sequence: result2.append(x+1)
Here's a list comprehension that uses an if clause:
result3 = [x+1 for x in some_sequence if x>23]
This list comprehension is the same as a for loop that contains an if statement:
result4 =  for x in some_sequence: if x>23: result4.append(x+1)
And here's a list comprehension that uses a for clause:
result5 = [x+y for x in alist for y in another]
This is the same as a for loop with another for loop nested inside:
result6 =  for x in alist: for y in another: result6.append(x+y)
As these examples show, the order of for and if in a list comprehension is the same as in the equivalent loop, but in the list comprehension, the nesting remains implicit.