List comprehensions are a Python feature that let us quickly write simple loops that and return the results to a list. This is a common pattern in programming, so it can save us a lot of keystrokes, but they are also often simpler to read for basic problems.

For example, let's say we have a list of numbers and we need to do some math (let's square each value) on each of those numbers and store the results in a list. Using a for loop the answer would look something like this.

In [1]:

```
numbers = [2.2, 7.3, 1, 0, 9.5, 6.2, 42]
results = []
for value in numbers:
results.append(value ** 2)
results
```

Out[1]:

Using a list comprehension we can right the middle 3 lines as a single line:

In [2]:

```
numbers = [2.2, 7.3, 1, 0, 9.5, 6.2, 42]
results = [value ** 2 for value in numbers]
results
```

Out[2]:

List comprehensions can also handle nested for loops. So if we wanted to get the products of all of the possible combinations of numbers from 1 to 4 we could write a list comprehension like this:

In [3]:

```
multiplication_table = [a * b for a in range(1, 5) for b in range(1, 5)]
multiplication_table
```

Out[3]:

The loops can interact just like in a normal nested for loop, so if we
only wanted to calculate each unique combination once (i.e., only calculate
1 * 3, not also 3 * 1) we can modify the second for loop.

In [4]:

```
multiplication_table = [a * b for a in range(1, 5) for b in range(a, 5)]
multiplication_table
```

Out[4]:

They can also handle conditions. So, if in the first example we only wanted, to square the number if it was positive we could check that inside the list comprehension.

In [5]:

```
numbers = [2.2, 7.3, -5, -2.2, 1, 0, 9.5, -7, 6.2, 42]
results = [value ** 2 for value in numbers if value > 0]
results
```

Out[5]:

Simple list comprehensions are easier to read than their equivalent for loops, but this is only true up to a point. A general rule of thumb is to use a regular for loop if you have more than total for loops and conditions, or the if the conditions are complex.

Check out the Python documentation on list comprehensions.