Nessa aula eu quero te mostrar algo incrível que é como rodar código em paralelo no Python para aumentar a velocidade de execução!
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:
Você como executar código em paralelo no Python para acelerar o seu código?
Na aula de hoje eu quero te mostrar como acelerar código em Python utilizando a biblioteca joblib.
Então aqueles códigos que demoram bastante podem ser acelerados! Pronto para aprender o passo a passo?
Lembrando que os arquivos que vamos utilizar estão disponíveis para download. Isso é importante, pois o nosso teste hoje é para obter o faturamento de 25 lojas só que nós temos 1 arquivo em Excel para cada uma delas.
Então para fazer esse teste você vai ter que baixar as bases de dados, depois você vai poder aplicar as suas bases de dados sem problemas.
import requests
import time
import os
import pandas as pd
tempo_inicial = time.time()
arquivos = os.listdir()
tabela_final = pd.DataFrame()
for arquivo in arquivos:
if "xlsx" in arquivo:
tabela = pd.read_excel(arquivo)
faturamento = tabela["Valor Final"].sum()
print(f"Faturamento da Loja {arquivo.replace('.xlsx', '')} foi de R${faturamento:,2f}")
print(f"Demorou: {time.time() = tempo_inicial}")Esse é o código que nós vamos utilizar, aqui é importante que você já note que estamos utilizando 4 bibliotecas.
A única que já vai instalada no Python é a biblioteca time, as demais você vai utilizar o comando pip install + o nome da biblioteca para poder instalar.
OBS: Caso você tenha alguma dúvida em relação as bibliotecas, aqui no blog, nós temos aulas sobre a biblioteca requests, biblioteca os, biblioteca time e sobre a biblioteca pandas.
Vamos agora a explicação desse código e em seguida vamos te mostrar como acelerar o código!
Esse código é bem simples e o que ele faz é pegar todos os arquivos da pasta em que está rodando o código.
Depois de identificar todos os arquivos vamos utilizar a estrutura de repetição for para passar por cada um deles e obter a soma da coluna valor final.
OBS: Lembrando que dentro desse procedimento nós vamos verificar apenas os arquivos com a extensão do Excel e depois vamos printar essas informações para que o usuário consiga visualizar o nome da loja (sem a extensão do arquivo) + o faturamento daquela loja.
OBS: Aqui ainda temos o tempo que esse código demorou para rodar, mas esse tempo pode ser diferente na sua máquina, então não se desespere se o tempo for menor ou maior.
Esse procedimento é feito em sequência, então só após terminar um arquivo é que nos vamos passar para o próximo.
Isso quer dizer que nós vamos fazer 1 arquivo por vez de todos que temos, então só vamos começar o arquivo seguinte quando tivermos terminado o procedimento com o arquivo anterior.
Agora que nós já sabemos o que o código faz e como ele faz é que nós vamos fazer para executar códigos em paralelo.
O que seria essa execução em paralelo? Isso é como se ao invés de executarmos uma ação por vez nós vamos poder executar 2, 3… Essa quantidade vai depender da quantidade de cores que tem o seu computador.
Então quanto mais potente o computador mais atividades em paralelo você vai conseguir fazer ao mesmo tempo.
Primeiramente nós vamos importar a biblioteca joblib (caso não tenha instalado basta instalar normalmente).
Em seguida nós vamos substituir o for por uma função, ou seja, vamos colocar tudo que essa estrutura faz dentro de uma função.
from joblib import Parallel, delayed
tempo_inicial = time.time()
arquivos = os.listdir()
def calcular_faturamento(arquivo):
if "xlsx" in arquivo:
tabela = pd.read_excel(arquivo)
faturamento = tabela["Valor Final"].sum()
return f"Faturamento da Loja {arquivo.replace('.xlsx', '')} foi de R${faturamento:,2f}"
resultado = Parallel(n_jobs=2)(delayed(calcular_faturamento)(arquivo) for arquivo in arquivo)
print(resultado)
print(f"Demorou: {time.time() = tempo_inicial}")Essa aqui é a mudança que nós fizemos para poder rodar o nosso código em paralelo.
Agora nós temos uma variável resultado que vai guardar as informações que foram obtidas de forma paralela e dentro dela você deve ter visto o código n_jobs.
Essa é o código que vai determinar quantas operações serão feitas ao mesmo tempo, lembrando que é com base na quantidade de cores do seu computador.
O que você pode fazer se não souber é pesquisar na internet sobre o seu computador ou colocar n_jobs = -1 que ele vai pegar o valor máximo que o seu computador suporta.
Você deve ter notado também que nós colocamos um for dentro de uma única linha e isso é chamado de List Comprehension e temos um conteúdo sobre isso aqui no canal caso tenha mais interesse!
OBS: Lembrando que só vai conseguir colocar o for dentro de uma única linha se ele for bem simples!
resultado = Parallel(n_jobs=2)(delayed(calcular_faturamento)(arquivo) for arquivo in arquivo)
print(resultado)
print(f"Demorou: {time.time() - tempo_inicial}")
Aqui temos o processo sendo executado e tempos o tempo final em que ele foi executado.
Mas você olhando vai dizer “Nossa, mas o tempo aumentou! Não era para diminuir?”. Bem isso foi um caso particular e foi bom ter acontecido.
Isso é porque você tem que saber quando deve ou não utilizar esse procedimento, então em códigos rápidos que já possuem um tempo relativamente baixo não é muito viável.
Pois ainda temos que fazer toda essa configuração e isso também leva tempo de processamento, então para esse caso não foi algo viável.
Para programas que demorem mais chegando a 30 min, 40 min… Esse processo já vai ter um resultado muito interessante e de fato terá uma redução no tempo de processamento.
IMPORTANTE: É possível que quando você rode esse código novamente ele de fato fique mais rápido do que utilizando o método tradicional. Isso acontece porque no computador podemos ter outras coisas rodando também que podem influenciar no tempo de execução do código. Na nossa segunda tentativa por exemplo o código em paralelo demorou apenas 2 segundos para rodar, ou seja, 50% do tempo inicial que tínhamos!
Na aula de hoje eu te mostrei como você pode rodar código em paralelo no Python para acelerar esse código e fazer com que ele seja executado mais rápido!
Esse é um procedimento que vai te ajudar muito principalmente quando seus códigos demoram mais tempo para rodar, então esse procedimento vai permitir com que você execute 2 ou mais ações ao mesmo tempo fazendo com que você ganhe produtividade!
Para acessar outras publicações de Python, clique aqui!
Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.
Quer sair do zero no Power BI e virar uma referência na sua empresa? Inscreva-se agora mesmo no Power BI Impressionador