Olá, caro leitor! Seja muito bem-vindo a mais uma edição da "Dicas Pythonicas".
Aqui no pyPRO, continuamos a compartilhar dicas valiosas para te ajudar a otimizar seu código e aprimorar suas habilidades em Python.
Hoje, vamos explorar uma comparação entre dois métodos para realizar a mesma tarefa: usar loops tradicionais versus list comprehensions para filtrar dados em um grande dicionário de empregados e seus salários. A diferença entre os dois pode ter um impacto significativo no desempenho do seu código.
Aqui está o código que usamos para a comparação:
import string
import time
from random import randint, choice
empregados = {
'José': 10000,
'Pedro': 23000,
'Maria': 25000,
'Adriana': 15500,
'Frank': 21500
}
def gerador_aleatorio(tam=8, chars=string.ascii_uppercase + string.digits):
return ''.join(choice(chars) for _ in range(tam))
# Tornando o dicionário maior
for i in range(200000):
empregados[gerador_aleatorio()] = randint(1, 30000)
print(len(empregados)) # Verificando o tamanho do dicionário
tempo_inicial_loop = time.time()
bem_remunerados = []
for chave, valor in empregados.items():
if valor >= 20000:
bem_remunerados.append((chave, valor))
tempo_final_loop = time.time()
tempo_inicial_lc = time.time()
bem_remunerados = [(c, v) for c, v in empregados.items() if v >= 20000]
tempo_final_lc = time.time()
print("Resultado.................")
tempo_loop = tempo_final_loop - tempo_inicial_loop
print("Tempo Loop.: ", tempo_loop)
tempo_lc = tempo_final_lc - tempo_inicial_lc
print("Tempo ListC: ", tempo_lc)
Como Funciona?
O código começa criando um grande dicionário de empregados com salários aleatórios. Em seguida, usamos dois métodos para filtrar os empregados que ganham mais de 20.000:
No loop tradicional, iteramos sobre cada item do dicionário, verificando se o salário atende ao critério e adicionando-o a uma lista.
Com a list comprehension, realizamos a mesma operação em uma única linha, resultando em um código mais conciso e, frequentemente, mais rápido.
Os tempos de execução para cada método são então comparados, mostrando que a list comprehension tende a ser mais eficiente.
Esse tipo de análise é útil para entender o impacto das escolhas de design do seu código, especialmente ao lidar com grandes conjuntos de dados.
Espero que esta dica te inspire a experimentar list comprehensions em seus projetos e otimizar o desempenho do seu código. Fique atento para a próxima edição, onde traremos mais dicas práticas e poderosas!
Um forte abraço,
Prof. Dr. Dilermando Piva Jr.
Idealizador do pyPRO
Visite: https://pypro.com.br para mais informações sobre Python, Ciência de Dados e Git/GitHub.