Blog

Postado em em 15 de novembro de 2021

Rodar Código em Paralelo no Python – Acelerando o seu Código!

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:

Como Rodar Código em Paralelo no Python

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?

Como Executar Código em Paralelo no Python

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.

Resultado do método tradicional (os valores podem variar para cada computador)
Resultado do método tradicional (os valores podem variar para cada computador)

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 após o código em paralelo
Resultado após o código em paralelo

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!

Conclusão

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!

Hashtag Treinamentos

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


Quer aprender mais sobre Python com um minicurso gratuito?


Quer participar do maior evento de Power BI da América Latina de forma 100% Online e Gratuita? Inscreva-se abaixo!