Optimizing python for loops

Here are two programs that naively calculate the number of prime numbers <= n.

One is in Python and the o开发者_JAVA百科ther is in Java.

public class prime{
    public static void main(String args[]){
        int n = Integer.parseInt(args[0]);
        int nps = 0;
 boolean isp;

        for(int i = 1; i <= n; i++){
            isp = true;

            for(int k = 2; k < i; k++){
               if( (i*1.0 / k) == (i/k) ) isp = false;
            }
            if(isp){nps++;}
 }
        System.out.println(nps);
    }
}


`#!/usr/bin/python`                                                                                                                                        
import sys
n = int(sys.argv[1])
nps = 0

for i in range(1,n+1):
    isp = True
    for k in range(2,i):
        if( (i*1.0 / k) == (i/k) ): isp = False
    if isp == True: nps = nps + 1
print nps

Running them on n=10000 I get the following timings.

shell:~$ time python prime.py 10000 && time java prime 10000

1230

real 0m49.833s

user 0m49.815s

sys 0m0.012s

1230

real 0m1.491s

user 0m1.468s

sys 0m0.016s

Am I using for loops in python in an incorrect manner here or is python actually just this much slower?

I'm not looking for an answer that is specifically crafted for calculating primes but rather I am wondering if python code is typically utilized in a smarter fashion.

The Java code was compiled with javac 1.6.0_20

Run with java version "1.6.0_18"

OpenJDK Runtime Environment (IcedTea6 1.8.1) (6b18-1.8.1-0ubuntu1~9.10.1) OpenJDK Client VM (build 16.0-b13, mixed mode, sharing)

Python is:

Python 2.6.4 (r264:75706, Dec 7 2009, 18:45:15)

As has been pointed out, straight Python really isn't made for this sort of thing. That the prime checking algorithm is naive is also not the point. However, with two simple things I was able to greatly reduce the time in Python while using the original algorithm.

First, put everything inside of a function, call it main() or something. This decreased the time on my machine in Python from 20.6 seconds to 14.54 seconds. Doing things globally is slower than doing them in a function.

Second, use Psyco, a JIT compiler. This requires adding two lines to the top of the file (and of course having psyco installed):

import psyco
psyco.full()

This brought the final time to 2.77 seconds.

One last note. I decided for kicks to use Cython on this and got the time down to 0.8533. However, knowing how to make the few changes to make it fast Cython code isn't something that I recommend for the casual user.

Yes, Python is slow, about a hundred times slower than C. You can use xrange instead of range for a small speedup, but other than that it's fine.

Ultimately what you're doing wrong is that you do this in plain Python, instead of using optimized libraries such as Numpy or Psyco.

Java comes with a jit compiler that makes a big difference where you're just crunching numbers.

You can make your Python about twice as fast by replacing that complicated test with

if i % k == 0: isp = False

You can also make it about eight times faster (for n=10000) than that by adding a break after that isp = False.

Also, do yourself a favor and skip the even numbers (adding one to nps to start to include 2).

Finally, you only need k to go up to sqrt(i).

Of course, if you make the same changes in the Java, it's still about 10x faster than the optimized Python.

Boy, when you said it was a naive implementation, you sure weren't joking!

But yes, a one to two order of magnitude difference in performance is not unexpected when comparing JIT-compiled, optimized machine code with an interpreted language. An alternative Python implementation such as Jython, which runs on the Java VM, may well be faster for this task; you could give it a whirl. Cython, which allows you to add static typing to Python and get C-like performance in some cases, may be worth investigating as well.

Even when considering the standard Python interpreter, CPython, though, the question is: is Python fast enough for the task at hand? Will the time you save writing the code in a dynamic language like Python make up for the extra time spent running it? If you had to write a given program in Java, would it seem like too much work to be worth the trouble?

Consider, for example, that a Python program running on a modern computer will be about as fast as a Java program running on a 10-year-old computer. The computer you had ten years ago was fast enough for many things, wasn't it?

Python does have a number of features that make it great for numerical work. These include an integer type that supports an unlimited number of digits, a decimal type with unlimited precision, and an optional library called NumPy specifically for calculations. Speed of execution, however, is not generally one of its major claims to fame. Where it excels is in getting the computer to do what you want with minimal cognitive friction.

If you're looking to do it fast, Python probably isn't the way forward, but you could speed it up a bit. First, you're using quite a slow way to test for divisibility. Modulo is quicker. You can also stop the inner loop (with k) as soon as it detects a match. I'd do something like this:

nps = 0
for i in range(1, n+1):
    if all(i % k for k in range(2, i)): # i.e. if divisible by none of them
       nps += 1

That brings it down from 25 s to 1.5 s for me. Using xrange brings it down to 0.9 s.

You could speed it up further by keeping a list of primes you've already found, and only testing those, rather than every number up to i (if i isn't divisible by 2, it won't be divisible by 4, 6, 8...).

Why don't you post something about the memory usage - and not just the speed? Trying to get a simple servlet on tomcat is wasting 3GB on my server.

What you did with the examples up there is not very good. You need to use numpy. Replace for/range with while loops, thus avoiding the list creation.

At last, python is quite suitable for number crunching, at least by people that do it the right way, and know what Sieve of Eratosthenes is, or mod operation is.

There are lots of things you can do to this algorithm to speed it up, but most of them would also speed up the Java version as well. Some of those will speed up the Python more than the Java, so they're worth testing.

Here's just a couple of changes that speed it up from 11.4 to 2.8 seconds on my system:

nps = 0 
for i in range(1,n+1): 
    isp = True 
    for k in range(2,i):
        isp = isp and (i % k != 0)
    if isp: nps = nps + 1 
print nps 

Python is a language which, ironically, is well-suited for developing algorithms. Even a modified algorithm like this:

# See Thomas K for use of all(), many posters for sqrt optimization
nps = 0
for i in xrange(1, n+1):
    if all(i % k for k in xrange(2, 1 + int(i ** 0.5))):
       nps += 1

runs in significantly under one second. Code like this:

def eras(n):
    last = n + 1
    sieve = [0,0] + range(2, last)
    sqn = int(round(n ** 0.5))
    it = (i for i in xrange(2, sqn + 1) if sieve[i])
    for i in it:
        sieve[i*i:last:i] = [0] * (n//i - i + 1)
    return filter(None, sieve)

is faster still. Or try out these.

The thing is, python is usually fast enough for designing your solution. If it is not fast enough for production, use numpy or Jython to goose more performance out of it. Or move it to a compiled language, taking your algorithm observations learned in python with you.

Yes, Python is one of the slowest practical languages you'll encounter. While loops are marginally faster than for i in xrange(), but ultimately Python will always be much, much slower than anything else.

Python has its place: Prototyping theory and ideas, or in any situation where the ability to produce code fast is more important than the code's performance.

Python is a scripting language. Not a programming language.