Question

def primes(n): 
    if n==2: return [2]
    elif n<2: return []
    s=range(3,n+1,2)
    mroot = n ** 0.5
    half=(n+1)/2-1
    i=0
    m=3
    while m <= mroot:
        if s[i]:
            j=(m*m-3)/2
            s[j]=0
            while j<half:
                s[j]=0
                j+=m
        i=i+1
        m=2*i+3
    return [2]+[x for x in s if x]

Hello, I found this function here http://code.activestate.com/recipes/366178-a-fast-prime-number-list-generator/ and I’m stuck. I don’t understand this. I think it’s using some properties of prime numbers but all those single letter variables are so mysterious. Could you please shed some light?

This I understand:
mroot is the limit of the numbers you want to check for primality
and I know that the function changes the list s to 0’s marking the multiples. I also understand the list comprehesion at the end, and I understand s.

But why half? What is j? What is m?

Could you please give some comment?

Answer 1

A line-by-line breakdown:

def primes(n): 
    if n==2: return [2]

This function returns a list of primes <= n. So if n == 2, that list contains only 2. Easy enough.

    elif n<2: return []

Here again, there are no prime numbers below 2, so return an empty list.

    s=range(3,n+1,2)

So s is a list of odd numbers starting with 3 and going to n + 1. s stands for sieve — this is a sieve algorithm, which means that composite (non-prime) numbers will be sifted out of the list. In effect, they will be “crossed out.” See below for a detailed description of sieve algorithms.

    mroot = n ** 0.5

Since it’s a sieve, we can stop the algorithm once we’ve hit the square root of n.

    half=(n+1)/2-1

This is an explicit formula for the length of s; it could be replaced with len(s), but that might take longer to calculate for large values of n. This will also be useful for terminating certain parts of the algorithm.

    i=0
    m=3

I is our index; i simply steps through the sieve, checking each value. If the value is 0, then the number has been “crossed off” because it isn’t prime. m is simply the value of s[i] at any given moment; a later line keeps it updated.

    while m <= mroot:
        if s[i]:

Since s[i] evaluates to True, it hasn’t been crossed off the list yet. That means it’s prime! So now we have to figure out which numbers on the list are multiples of s[i] — they are all non-primes, and should be crossed off the list.

            j=(m*m-3)/2
            s[j]=0

Now the fun starts. Because the sieve isn’t a list of consecutive numbers, but a list of odd numbers, we have to figure out where the multiples of our prime live in s. In this case, our prime is 3, so we need to find the index of 9, 15, 21, 27… (we don’t have to find 6, 12, 18… because they’re even, and so not in the list). This particular technique for finding the indices is really clever, because the author has figured out that once all the multiples of a particular prime have been crossed out, they can be skipped. That means the first un-crossed-out multiple of our prime is actually the square of that prime. (So for example, if the prime were 7, 7 * 3 = 21 and 7 * 5 = 35 would already have been crossed out, so the first multiple of 7 that we have to deal with is 7 * 7.) Once that makes sense, it’s pretty easy to see that the location of 9 in s is (9 – 3) // 2 (where // is floor division).

            while j<half:
                s[j]=0
                j+=m

Now it goes back to being easy. We’ve found 9; now we have to find 15 = 9 + 3 + 3. Since s contains only odd numbers, it’s half as long as a list with every number; to skip ahead 6 then, we need only add 3 to j. We do this as long as j is less than half — in other words, as long as j is less than the length of s.

        i=i+1
        m=2*i+3

Again, easy — i is just the index of the list, while m is the value of the number that was originally there. (You can test it out to see why: [2 * i + 3 for i in range(10)].)

    return [2]+[x for x in s if x]

And voila — filter the zeros out of the sieve, prepend [2] and you have a list of primes.

The most confusing thing about this algorithm has to do with the shortcuts the author has taken, which make this run faster, but fog up the fundamental concept. (In fact, there are even more shortcuts one could take, but that’s another post.) Here’s a much simpler sieve that shows the basic idea:

>>> numbers = range(40)
>>> numbers[1] = 0    # 1 isn't prime
>>> for i in numbers:
...     if i:
...         for j in range(i + i, len(numbers), i):
...             numbers[j] = 0
... 
>>> [n for n in numbers if n]
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]

To spell it all out, first numbers looks like this:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10...]

Then…

[0, 0, 2, 3, 4, 5, 6, 7, 8, 9, 10...]
[0, 0, 2, 3, 0, 5, 0, 7, 0, 9, 0...]
[0, 0, 2, 3, 0, 5, 0, 7, 0, 0, 0...]

And so on.