# Infinite list of prime numbers using Python generators

### Alejandro Bezdjian ・1 min read

Sometimes we want to create collections of elements that are very expensive to calculate. The first option is to create a list and wait until all the elements are calculated before we use it. Although this works, it is not very efficient. To make it a bit more efficient, modern languages provide a way to create custom iterators so each element is calculated only when needed (this is also called lazy initialization). Also, iterators allows us to create infinite collections!

Python has, in my opinion, one of the most succint and elegant ways to declare iterators: generators.

Without further ado, let's try to create an infinite list of prime numbers.

The first thing we need is a way to detect if a number is prime:

```
def is_prime(n) :
if (n <= 1) :
return False
if (n == 2) :
return True
i = 2
while(i * i <= n) :
if n % i == 0:
return False
i = i + 2
return True
```

Now, using our `is_prime`

function we can do:

```
def prime_generator():
n = 1
while True:
n += 1
if is_prime(n):
yield n
```

And that's it! Just call the function and get elements from it:

```
generator = prime_generator()
for i in range(10):
print(next(generator))
```

Or create a list of the first N prime numbers:

```
from itertools import islice
array = [x for x in islice(prime_generator(), 10)]
```

As you could see, the iterator definition is one of the shortest and simplest among all languages.

Since the time complexity of

`is_prime`

is`O(sqrt(n))`

:Worth a mention that for prime numbers up to

`N`

,overall, using this method is not as time efficient as sieve methods that eagerly pre-calculate all the primes up to`N`

(this is because sieves use previously found primes to eliminate other composite numbers, instead of performing an exhaustive search for each number).