The uses for prime numbers in computer science are nearly endless. They are useful for everything from hashing, cryptology, factorization and all sorts of applications in-between.

There exists a great number of algorithms that allow us to quickly generate primes, but today we are going to take a look at a popular method known as a **prime sieve**. There are a number of different implementations of prime sieves, but one of the simplest to implement is known as the *Sieve of Eratosthenes*. This algorithm is great for quickly generating smaller prime numbers (but it may not be the best choice for generating very large primes).

# How it Works

In general, the Sieve of Eratosthenes works by generating a list of number from **2 to n**. The algorithm will then work through the list, marking all the composite numbers. Here is a more detailed breakdown of the implementation:

- Create a list of integers from
**2 to n**. We start at 2 because it’s the smallest prime - Set
**p=2** - Iterate over the multiples of
**p**by counting to**n**from**2p**in increments of**p**. These are the numbers that get marked as composites in the list. - Find the first number greater than
**p**in the list that is not marked. If one does not exist, we are done. If one does exist, however, set**p**to this new value and repeat from step 3.

This method has a complexity of **O(NloglogN)**.

# Implementation in Python

Let’s take a look at how we can implement a Sieve of Eratosthenes in Python:

def get_primes(): D = {} p = 2 while 1: if p not in D: yield p D[p*p] = [q] else: for q in D[p]: D.setdefault[q+p, []).append(q) del D[p] p += 1

For this implementation I have modified things a bit to yield an infinite prime generator.

Let’s take a moment to consider an example of how this could be used in a practical scenario. Let’s take, for example, problem 10 from Project Euler, which asks that we find the sum of all the primes below 2 million. Using our *gen_primes()* method we can easily solve this with the following:

primes = gen_primes() print(sum(itertools.takewhile(lambda x: x < 2000000, primes)))

## Another Practical Example

Before I wrap up this post, let’s consider just one more practical use for our *gen_primes()*method. Assume that we needed to find out what the n^{th} prime is. For the purpose of example, let’s just say we want to find the 500^{th }prime number. It turns out this can be done easily with the following:

primes = gen_primes() print(next(itertools.islice(primes, 500, None), None))

Running this will reveal that the 500^{th} prime number is 3,581.

# Wrap Up

As I hope you can see, the Sieve of Eratosthenes is a simple way to generate prime numbers that can prove useful in a number of situations. I hope you’ve found this helpful!