# What's the Difference Between Generator Expressions and List Comprehensions in Python?

Generator expressions (Python 2.4+) and list comprehensions (Python 2.0+) differ in the following ways:

## Syntax

Syntactically, the difference between the two is that generator expressions are wrapped in parentheses and list comprehensions are wrapped in squared brackets:

```# generator expression
(item for item in iterable)
```
```# list comprehension
[item for item in iterable]
```

Consider, for example, the following where numbers are squared using generator expression:

```squares = list(n ** 2 for n in range(5))
print(squares) # [0, 1, 4, 9, 16]
```

This is equivalent to the following:

```def GenSquare(num):
for n in range(num):
yield(n ** 2)

squares = list(GenSquare(5))

print(squares) # [0, 1, 4, 9, 16]
```

The same example (of squaring numbers) can be written as list comprehension, for example, like so:

```squares = [n ** 2 for n in range(5)]
print(squares) # [0, 1, 4, 9, 16]
```

This is equivalent to the following:

```squares = list(map(lambda n: n ** 2, range(5)))
print(squares) # [0, 1, 4, 9, 16]
```

It can also be written in a loop, like so:

```squares = []

for n in range(5):
squares.append(n ** 2)

print(squares) # [0, 1, 4, 9, 16]
```

## Return Type

Generator expressions return a generator object, while list comprehensions return a new list:

```# generator syntax
squares = (n ** 2 for n in range(5))
print(squares) # <generator object <genexpr> at ...>
```
```# list comprehension
squares = [n ** 2 for n in range(5)]
print(squares) # [0, 1, 4, 9, 16]
```

To return a list with generator syntax, you have to explicitly wrap the resulting generator object in a list, for example, like so:

```# generator syntax
squares = list(n ** 2 for n in range(5))
print(squares) # [0, 1, 4, 9, 16]
```

Since generator expression return a generator object, it won't support list functions/operations (such as indexing, slicing, etc.) unless you explicitly convert it to a list.

## Operation

Generator expressions are more memory efficient than list comprehensions. This is because list comprehension loads the entire list in memory, whereas a generator expression only loads one value in memory at a time. For example, you can check how much memory each of these use by using the `sys.getsizeof()` method:

```from sys import getsizeof

ge = (n for n in range(5000))

ge_size = getsizeof(ge)
print(ge_size) # 112

lc = [n for n in range(5000)]

lc_size = getsizeof(lc)
print(lc_size) # 43032
```

This means that you can use generator expressions for very large, even infinite, sequences.

Hope you found this post useful. It was published . Please show your love and support by sharing this post.