Por que python é tão lento em Raring?

Question

Para executar alguns benchmarks em meu 13.04 recém-instalado, escrevi o script fibonacci abaixo em python. Basicamente aceita um número e começa a processar números de fibonacci que muitas vezes:

#!/usr/bin/python
import time
from time import time

def fibo(n):
    a,b,i=0,1,0
    while i<n:
        #print b
        a,b = b,b+a
        i+=1


if __name__ == "__main__":
    s=time()
    fibo(1000000)
    print round((time()-s)*1000,0),"ms"

No entanto, quando a função fibo () é chamada com 1 milhão como parâmetro, o python parece travar. Enquanto esse código semelhante em java é executado instantaneamente:

class fibonacci
{
    private static void fibo(int n)
    {
        int a=0,b=1,i=0;
        while( i<n)
        {
            //print b
            int t=a;
            a=b;
            b=b+t;
            i++;
        }
    }   

    public static void main(String[] args)
    {
        float s=System.currentTimeMillis();
        fibo(1000000);
        System.out.println( (System.currentTimeMillis()-s) + "ms");
    }
}

Qual é o motivo disso? O python é inerentemente lento ou há algo errado com minha instalação de raring?

    

Answer 1

Olhando para o seu código Java, noto que você está usando int para os números de Fibonacci. Por outro lado, o Python está usando precisão arbitrária .

Observe também que os números de Fibonacci não cabem em uma variável int para n > 46 ! Portanto, o código Java nem calcula os números de Fibonacci para n > 46 .

Você deve alterar o int para algum tipo de dados maior (um de precisão arbitrária, talvez) antes de fazer a comparação.

Conclusão, Java roda muito mais rápido porque está calculando com ints (um tipo de dados de tamanho fixo), enquanto o Python está usando mais e mais RAM para acumular para os números cada vez maiores (que eventualmente param de se encaixar em 32 bits). inteiro).

Tente isto:

#!/usr/bin/python
from time import time

def int32(x):
    x &= 0xffffffff
    if x > 0x7fffffff:
        return - ( ~(x - 1) & 0xffffffff )
    else:
        return x

def fibo(n):
    a,b,i=0,1,0
    while i<n:
        t = a
        a = b
        b = int32(b + t)
        i+=1


if __name__ == "__main__":
    s=time()
    fibo(1000000)
    print round((time()-s)*1000,0),"ms"

para ver aproximadamente quanto tempo levaria se o Python usasse ints.

    

Answer 2

Um pequeno trecho do link deve responder à sua pergunta.
A resposta curta está na primeira frase;)

"Python programs are generally expected to run slower than Java programs, but they also take much less time to develop. Python programs are typically 3-5 times shorter than equivalent Java programs. This difference can be attributed to Python's built-in high-level data types and its dynamic typing. For example, a Python programmer wastes no time declaring the types of arguments or variables, and Python's powerful polymorphic list and dictionary types, for which rich syntactic support is built straight into the language, find a use in almost every Python program. Because of the run-time typing, Python's run time must work harder than Java's. For example, when evaluating the expression a+b, it must first inspect the objects a and b to find out their type, which is not known at compile time. It then invokes the appropriate addition operation, which may be an overloaded user-defined method. Java, on the other hand, can perform an efficient integer or floating point addition, but requires variable declarations for a and b, and does not allow overloading of the + operator for instances of user-defined classes.

For these reasons, Python is much better suited as a "glue" language, while Java is better characterized as a low-level implementation language. In fact, the two together make an excellent combination. Components can be developed in Java and combined to form applications in Python; Python can also be used to prototype components until their design can be "hardened" in a Java implementation. To support this type of development, a Python implementation written in Java is under development, which allows calling Python code from Java and vice versa. In this implementation, Python source code is translated to Java bytecode (with help from a run-time library to support Python's dynamic semantics)."