Velocidade de Processamento: R vs Julia vs Python

Benchmark

Para quem lida com grandes volumes de dados ou cálculos complexos, conhecer a velocidade de execução das linguagens é fundamental. Neste post, comparamos R, Julia e Python por meio de uma função de Fibonacci, mostrando como a escolha da linguagem pode fazer diferença no tempo de processamento e na produtividade.

Autores

Afiliação

Gabriel Campovilla da Silva

Universidade Estadual de Campinas

Nicole Fredericci

Universidade Estadual de Campinas

Data de Publicação

19 de setembro de 2025

Introdução

Em uma linguagem interpretada, o código é processado linha a linha por um interpretador, o que facilita a execução de testes rápidos, execução de trechos isolados e depuração (mas reduz a velocidade em operações intensivas). Já em linguagens com compilação Just-In-Time (JIT), o interpretador compila trechos do código em linguagem de máquina durante a execução, em vez de interpretar linha a linha o tempo todo, permitindo um desempenho próximo a linguagens compiladas (especialmente em loops e cálculos intensivos). E quando se procura uma linguagem de programação para análise de dados ou computação científica, a velocidade de processamento pode influenciar bastante a escolha. Neste post, comparamos três linguagens populares — R, Julia e Python — analisando seu desempenho em uma tarefa computacionalmente intensiva.

Por que a velocidade difere?

Python: Linguagem interpretada e dinâmica, o que geralmente a torna mais lenta. No entanto, bibliotecas como NumPy e Pandas usam implementações em C e Fortran, permitindo um bom desempenho em operações numéricas.
R: Também é interpretada e foi criada para atender ao público da estatística. Loops puros são lentos, mas funções vetorizadas e pacotes como data.table e dplyr oferecem bom desempenho.
Julia: Projetada para alta performance, atinge velocidades próximas às de C e Fortran sem depender de bibliotecas externas, graças à sua compilação JIT. Vale notar que Python e R também podem alcançar desempenho semelhante usando ferramentas que compilam partes do código em C, como Cython (uma extensão para Python) e Rcpp (um pacote para R).

Exemplo Prático: Cálculo de Fibonacci

Para evidenciar a diferença de desempenho bruto entre as três linguagens, implementamos uma função recursiva de Fibonacci (propositalmente ineficiente), com o objetivo de testar a velocidade de processamento. Os resultados apresentados foram obtidos em um MacBook equipado com Apple M3 Pro e 18 GB de RAM.

fib <- function(n) {
    if (n <= 1) {
        return(n)
    } else {
        return(fib(n-1) + fib(n-2))
    }
}

start <- Sys.time()
result <- fib(30)
end <- Sys.time()

print(paste("Resultado:", result))

[1] "Resultado: 832040"

print(paste("Tempo R:", end - start))

[1] "Tempo R: 0.522500038146973"

start <- Sys.time()
result <- fib(40)
end <- Sys.time()

print(paste("Resultado:", result))

[1] "Resultado: 102334155"

print(paste("Tempo R:", end - start))

[1] "Tempo R: 1.0203111688296"

Julia

function fib(n)
    if n <= 1
        return n
    else
        return fib(n-1) + fib(n-2)
    end
end

fib (generic function with 1 method)

start_time = time();
result = fib(30);
end_time = time();

println("Resultado: $result")

Resultado: 832040

println("Tempo Julia: $(end_time - start_time) segundos")

Tempo Julia: 0.06513118743896484 segundos

start_time = time();
result = fib(40);
end_time = time();

println("Resultado: $result")

Resultado: 102334155

println("Tempo Julia: $(end_time - start_time) segundos")

Tempo Julia: 0.5383601188659668 segundos

Python

import time

def fib(n):
    if n <= 1:
        return n
    else:
        return fib(n-1) + fib(n-2)

start = time.time()
result = fib(30)
end = time.time()

print(f"Resultado: {result}")

Resultado: 832040

print(f"Tempo Python: {end - start:.4f} segundos")

Tempo Python: 0.0827 segundos

start = time.time()
result = fib(40)
end = time.time()

print(f"Resultado: {result}")

Resultado: 102334155

print(f"Tempo Python: {end - start:.4f} segundos")

Tempo Python: 9.9229 segundos

Resultados Esperados

Os tempos de execução podem variar de execução para execução e dependendo do computador sendo utilizado. Para padronizar um pouco os resultados, utilizando a consiguração padrão do Colab e realizamos os testes para fib(40) os valores encontrados foram:

Julia: 1,45 segundos.
Python: 23,13 segundos.
R: 159,51 segundos.

Conclusão

Os testes com a função recursiva de Fibonacci ilustram claramente as diferenças de desempenho entre as linguagens. Embora Julia se destaque em cálculos computacionalmente intensivos devido à sua compilação JIT, a escolha da linguagem deve levar em conta também o ecossistema, a familiaridade do usuário e o tipo de análise a ser realizada.

Python oferece equilíbrio entre desempenho e facilidade de uso, enquanto R continua sendo a opção ideal para análises estatísticas específicas, com sintaxe concisa e pacotes robustos, apesar de mais lento em cálculos brutos.

Nota

Ferramentas de IA foram utilizadas para correção ortográfica e aprimoramento do texto.