Programming Tricks: Dicas Essenciais para Escrever Código Eficiente

Se você já passou horas tentando fazer um programa rodar mais rápido, só para descobrir que o problema era um loop desnecessário ou uma escolha de estrutura de dados errada, você já sabe o que é um programming trick. Não se trata de truques sujos ou gambiarras - são pequenas decisões de código que, quando aplicadas com consciência, transformam um programa lento e confuso em algo rápido, limpo e fácil de manter.

Escolha a estrutura de dados certa desde o início

Muitos programadores começam com uma lista (array) porque é a primeira coisa que aprendem. Mas listas não são boas para buscas rápidas. Se você precisa procurar itens frequentemente, use um dicionário (hash map) ou um conjunto (set). Em Python, buscar em uma lista de 10.000 itens pode levar mais de 500 mil operações no pior caso. Já em um conjunto, a busca é quase instantânea - cerca de 1 operação, independente do tamanho.

Exemplo real: um sistema de controle de acesso que verifica se um usuário está autorizado. Se você armazena os IDs autorizados em uma lista e faz uma busca linear, cada verificação pode levar segundos em milhares de usuários. Troque por um conjunto: a verificação cai para menos de 1 milissegundo. É isso que faz um sistema escalar ou quebrar.

Evite loops aninhados quando possível

Loops aninhados são a causa número um de lentidão em programas pequenos que viram gargalos. Se você tem dois loops de 1.000 iterações cada, está fazendo 1 milhão de operações. Isso pode parecer aceitável em um protótipo, mas quando o sistema cresce, isso vira um pesadelo.

Em vez de comparar cada item de uma lista com cada item de outra, use estruturas de dados que ajudem a eliminar comparações. Por exemplo: se você quer encontrar todos os produtos que um cliente já comprou e que estão em promoção, não faça um loop dentro de outro. Transforme os produtos em promoção em um conjunto e faça uma única varredura nos pedidos do cliente. Redução de 1.000.000 para 2.000 operações. Simples. E eficaz.

Use compreensão de listas e geradores em vez de loops tradicionais

Em Python, escrever algo como:

result = []
for x in data:
    if x > 10:
        result.append(x * 2)

Funciona, mas é mais lento e menos legível do que:

result = [x * 2 for x in data if x > 10]

A compreensão de lista não só é mais concisa - ela é otimizada internamente pela linguagem. E se os dados forem grandes? Use um gerador:

result = (x * 2 for x in data if x > 10)

Aqui, os valores são gerados sob demanda. Nada é armazenado na memória até que você precise. Isso pode reduzir o uso de memória de 500 MB para 2 MB em processamentos de arquivos grandes. É uma diferença que faz o servidor não cair durante picos de carga.

Cacheie resultados caros - mas só quando fizer sentido

Se você tem uma função que calcula algo pesado - como uma consulta ao banco de dados, uma chamada de API ou uma operação matemática complexa - e ela é chamada repetidamente com os mesmos parâmetros, cacheie o resultado. Em Python, o @lru_cache do módulo functools faz isso automaticamente.

Exemplo: uma função que converte moedas usando taxas de câmbio. Se a função é chamada 100 vezes por segundo com o mesmo par de moedas (ex: USD para EUR), você está fazendo 100 chamadas de API por segundo. Com cache, você faz uma. As outras 99 são respondidas em menos de 1 microssegundo.

Mas atenção: cache não é mágica. Se os dados mudam com frequência, ou se os parâmetros são quase sempre diferentes, o cache só ocupa memória inútil. Use apenas quando a mesma entrada for repetida.

Evite repetição de cálculos dentro de loops

Quantas vezes você já viu algo assim?

for i in range(len(items)):
    if items[i].length > math.sqrt(144):
        process(items[i])

O math.sqrt(144) é calculado 100, 1.000 ou 10.000 vezes - e o resultado é sempre 12. Isso é desperdício. Faça o cálculo uma vez fora do loop:

threshold = math.sqrt(144)
for item in items:
    if item.length > threshold:
        process(item)

Isso pode parecer óbvio, mas é um erro comum em código escrito com pressa. Em sistemas de alta frequência, esses pequenos erros somam-se e viram latência visível para o usuário.

Use bibliotecas otimizadas em vez de reinventar a roda

Se você precisa ordenar uma lista, use sorted(). Se precisa de operações matemáticas rápidas, use NumPy. Se precisa manipular texto complexo, use expressões regulares otimizadas - não faça loops com if e substring.

NumPy, por exemplo, é escrito em C e usa vetores de memória contíguos. Uma operação como somar dois arrays de 1 milhão de números leva 0,02 segundos com NumPy. Com um loop em Python puro, leva cerca de 1,5 segundo. Mais de 70 vezes mais lento. E isso sem contar o código mais confuso.

As bibliotecas certas não são só mais rápidas - são mais testadas, mais seguras e mais bem documentadas. Reescrever algo que já existe é quase sempre um erro.

Teste o código com dados reais - não com exemplos pequenos

Um código que roda em 0,01 segundo com 10 itens pode demorar 30 segundos com 100.000. Muitos programadores testam só com dados de exemplo e depois se surpreendem quando o sistema vai para produção.

Use dados reais, ou pelo menos simulados com o mesmo volume e padrão. Se seu sistema vai lidar com 50.000 registros por dia, teste com 60.000. Se ele vai processar arquivos de 50 MB, teste com 100 MB. A performance muda de forma não linear. O que parece rápido em pequena escala pode ser um desastre em escala real.

Leia o código como se fosse outra pessoa

Um código eficiente não é só rápido - é claro. Se você precisar explicar o que ele faz mais de duas vezes, ele está muito complexo. Truques de programação que tornam o código mais difícil de entender não são truques - são armadilhas.

Um bom truque melhora performance sem sacrificar legibilidade. Se você precisa de um comentário para explicar uma linha de código, talvez ela deva ser simplificada. Ou dividida. Ou substituída por uma função com nome claro.

Exemplo: em vez de:

if not (a == 0 or b == 0) and c > 0:

Escreva:

if a != 0 and b != 0 and c > 0:

É mais fácil de ler. E o compilador ou interpretador vai otimizar igualmente. A clareza é uma forma de eficiência.

Profiling é seu melhor amigo

Não adivinhe onde está o gargalo. Meça. Em Python, use o módulo cProfile. Ele te diz exatamente quantas vezes cada função foi chamada e quanto tempo levou.

Em um projeto real, um time descobriu que 80% do tempo de execução era gasto em uma função de formatação de data que estava sendo chamada 50.000 vezes. A solução? Cachear o formato e usar um método mais rápido. O tempo total caiu de 12 segundos para 1,8 segundos. Tudo porque alguém decidiu medir, e não chutar.

Profiling não é algo para fazer só no fim. Faça quando o código começar a parecer lento. Faça antes de otimizar. Faça sempre que mudar algo importante.

Conclusão: eficiência é hábito, não sorte

Programar de forma eficiente não depende de ser um gênio. Dependem de pequenos hábitos: pensar antes de escrever um loop, escolher a estrutura de dados certa, medir antes de otimizar, e evitar o que é fácil - quando não é o melhor.

Os grandes sistemas não foram feitos por truques espetaculares. Foram feitos por milhares de pequenas decisões certas. E cada uma dessas decisões começa com uma pergunta simples: Existe uma maneira mais direta, mais rápida, mais limpa?

Se você responder essa pergunta com cuidado, todos os dias, seu código vai crescer - não em linhas, mas em qualidade.