Numba Python – Aprenda a Acelerar seu Código com 1 Linha

Conheça o Numba Python e aprenda como acelerar absurdamente seu código com apenas uma linha, graças a essa ferramenta incrível!

Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:

Numba Python – Aprenda a Acelerar seu Código com 1 Linha

Na aula de hoje eu quero apresentar para você o Numba Python, uma ferramenta capaz de acelerar significativamente o seu código Python com apenas uma linha. Esta ferramenta é surpreendentemente fácil de usar, e os resultados são impressionantes!

Vou te explicar o que é o Numba Python, como ele funciona e demonstrar com exemplos em quais casos ele pode ser uma ótima escolha.

Então, faça o download do material disponível para esta aula e vamos explorar mais sobre o Numba Python, que promete acelerar seu código absurdamente!

O que é o Numba Python?

O Numba é uma biblioteca do Python projetada para acelerar a execução dos códigos Python. Em vez de ser uma biblioteca tradicional, o Numba funciona na verdade como um compilador.

Ele compila seus códigos Python em código de máquina otimizado, o que pode te garantir um melhor desempenho e velocidade do que o código em Python tradicional.

Por ser uma linguagem interpretada, o Python acaba sendo naturalmente um pouco mais lento do que linguagens compiladas. Isso ocorre porque o Python precisa passar por uma etapa de traduzir o código que escrevemos em linguagem de máquina que o computador possa executar.

No entanto, em geral, o Python não costuma ter problemas significativos de tempo de execução, graças ao grande número de bibliotecas que otimizam o trabalho com Python, tornando-o mais eficiente.

Tempo de Execução no Python – Exemplo com For

Para avaliar o impacto do Numba em um código Python, iremos executar o exemplo a seguir, no qual um loop for é executado 1 bilhão de vezes, e mediremos o tempo que o Python levará para concluir esse processo.

import time

def valor_com_imposto(qtde):
    for i in range(qtde):
        novo_valor = qtde * 1.1

inicio = time.time()
valor_com_imposto(1000000000)
fim = time.time()
print(fim - inicio)

Ao executar esse código, meu computador levou 25 segundos para concluir todo o processo. É importante observar que esse tempo pode variar de um computador para outro, mas geralmente deve estar dentro dessa faixa.

Em resumo, o Python levou aproximadamente 25 segundos para executar um loop for 1 bilhão de vezes.

O que o Numba Python faz?

O Numba, como mencionado anteriormente, é uma biblioteca Python que age como um compilador JIT (Compilação Just-In-Time). Ele utiliza a compilação JIT para traduzir o código Python em código de máquina otimizado durante a execução do programa.

Em vez de compilar o programa inteiro de uma só vez, o Numba identifica partes críticas do código que são executadas com frequência, como funções ou loops, e as compila em tempo real para código de máquina.

Ou seja, ele pega a função anterior:

def valor_com_imposto(qtde):
    for i in range(qtde):
        novo_valor = qtde * 1.1

E a compila em linguagem de máquina otimizada.

É importante observar que o Numba é particularmente recomendado e eficaz ao lidar com operações matemáticas complexas e loops extensos.

No entanto, seu impacto pode não ser tão significativo em funções ou códigos que não envolvem grandes loops ou cálculos matemáticos intensivos.

Por isso, é mais comum vê-lo associado a códigos que trabalham com NumPy ou que contenham loops extensos e operações matemáticas mais complexas.

Instalação, Importação e Execução do Numba

Para entendermos como o Numba funciona, primeiro precisamos instalá-lo e importá-lo em nosso código. Vamos fazer isso executando o seguinte comando no terminal do editor de códigos:

pip install numba

Feito isso, podemos importá-lo:

from numba import jit, njit

Com o Numba importado em nosso código, podemos adicionar o decorator @jit antes da função valor_com_imposto.

Para esse decorator, passaremos o parâmetro nopython=True, que informa que o código a seguir não deve ser interpretado como código Python padrão, mas sim deve ser compilado just-in-time e, em seguida, executado.

import time
from numba import jit, njit

@jit(nopython=True)
def valor_com_imposto(qtde):
    for i in range(qtde):
        novo_valor = qtde * 1.1

inicio = time.time()
valor_com_imposto(1000000000)
fim = time.time()
print(fim - inicio)

Uma alternativa, ao invés de escrever o decorator jit e passar o parâmetro para ele, é utilizar diretamente o decorator njit, que fará a mesma coisa.

import time
from numba import jit, njit

@njit
def valor_com_imposto(qtde):
    for i in range(qtde):
        novo_valor = qtde * 1.1

inicio = time.time()
valor_com_imposto(1000000000)
fim = time.time()
print(fim - inicio)

Agora, vamos executar esse código para ver sua velocidade com o uso do Numba.

Observe que o tempo de execução caiu de quase 26 segundos para 0,17 segundos. Ele tornou o código muito mais rápido!

Além disso, caso você utilize a mesma função várias vezes em seu código, ela se tornará ainda mais rápida, pois já terá sido compilada em linguagem de máquina otimizada.

Segundo Exemplo com Numba Python

Vamos explorar um segundo exemplo de uso do Numba no código Python a seguir:

import time
import numpy as np

array = np.random.randint(1000, 10000, 10000000)

def preco_com_imposto(lista):
    aumento_total = 0
    for item in lista:
        if item > 5000:
            valor = item * 1.1
        else:
            valor = item
        aumento_total += valor - item
    return aumento_total

inicio = time.time()
print("Aumento:", preco_com_imposto(array))
fim = time.time()
print(fim - inicio)

Repare que no início do código, criamos um array do NumPy para trabalhar com “listas” dentro do Python. Fizemos isso para demonstrar a eficiência do Numba ao trabalhar com o NumPy.

Além disso, vale notar que a função preco_com_imposto, apesar de conter mais verificações e uma lógica mais elaborada do que o exemplo anterior, ainda é essencialmente uma operação matemática.

Nessa função, pegamos uma lista (o array criado) e, caso o valor do produto seja superior a 5000, aumentamos o valor desse produto em 10%. No final, calculamos o aumento total que os produtos sofreram.

Executando esse código sem o Numba:

Sem utilizar o Numba, nosso código levou 6.9 segundos, quase 7 segundos, para realizar o cálculo.

Executando o código com o Numba:

import time
import numpy as np
from numba import njit

array = np.random.randint(1000, 10000, 10000000)

@njit
def preco_com_imposto(lista):
    aumento_total = 0
    for item in lista:
        if item > 5000:
            valor = item * 1.1
        else:
            valor = item
        aumento_total += valor - item
    return aumento_total

inicio = time.time()
print("Aumento:", preco_com_imposto(array))
fim = time.time()
print(fim - inicio)

Observe que o Numba Python executou o mesmo código em apenas 0.23 segundos. Tudo o que precisamos fazer foi importar a biblioteca e adicionar um decorator para alcançar essa velocidade impressionante.

Como Saber se o Numba Python Funcionará para os Meus Códigos?

Vimos aqui nessa aula, dois exemplos de aplicação do Numba em códigos Python. No entanto, você pode estar se perguntando se ele será eficaz para o seu código específico.

Para determinar se o Numba pode acelerar o seu código, a regra geral é a seguinte: se a função em seu código envolver cálculos matemáticos e/ou execuções extensas de loops, o Numba provavelmente otimizará e acelerará a execução do seu código.

Se a aplicação for mais complexa ou se você ainda tiver dúvidas sobre como o Numba se encaixa no seu código, é aconselhável consultar a documentação para obter informações mais detalhadas.

Conclusão – Numba Python

Na aula de hoje eu te apresentei e demonstrei como o Numba Python funciona. Uma biblioteca incrível que atua como um compilador JIT, capaz de acelerar absurdamente seus códigos Python.

De forma simples e prática, com apenas 1 linha, você aprendeu a acelerar códigos que envolvem loops extensos ou operações matemáticas intensas.

Através de dois exemplos práticos, você pôde medir e visualizar o impacto que o Numba pode ter em um código Python, fornecendo uma base para decidir se deve ou não aplicar o Numba em seus projetos. Isso pode ser extremamente útil para acelerar o desempenho dos seus códigos!

Hashtag Treinamentos

Para acessar outras publicações de Python, clique aqui!

Diego Monutti

Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.