Otimização de código é algo muito importante, mas você sabe até que ponto vale a pena otimizar um código?
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:
Na aula de hoje, quero abordar um tema importante que muitas pessoas têm dúvidas: a otimização de código!
Você sabe até que ponto vale a pena otimizar um código? A ideia aqui é que você entenda como otimizar da melhor forma, sem exageros. Lembre-se de que, além de ser otimizado, seu código precisa ser fácil de ler e entender.
Vamos descobrir qual é esse “limite” em que devemos nos questionar se a otimização do código não está sendo excessiva!
A regra geral que devemos seguir ao otimizar um código é priorizar o equilíbrio entre a simplificação do código e a sua manutenção e clareza.
Ou seja, é crucial garantir que o código, além de otimizado, tenha uma leitura fácil e clara para que outros programadores, colegas de trabalho e até mesmo você consigam olhar para ele e compreender o que foi feito.
Para visualizarmos e compreendermos melhor esse processo de otimização de código e como o excesso de otimização pode ser prejudicial, vamos utilizar o código abaixo:
def calcular_imposto(faturamento):
if faturamento:
imposto = 0.3 * float(faturamento)
return imposto
faturamento_loja = input("Faturamento:")
imposto = calcular_imposto(faturamento_loja)
print("Imposto foi de:", imposto)Nesse código, caso o usuário não forneça um valor válido para o faturamento da loja, por exemplo, deixe-o vazio, o imposto retornado será None.
Para tratar esse problema, precisamos garantir que o usuário insira algum valor para o faturamento da loja. Nesse caso, podemos criar uma condição que fará essa validação.
def calcular_imposto(faturamento):
if faturamento:
imposto = 0.3 * float(faturamento)
return imposto
faturamento_loja = input("Faturamento:")
if faturamento_loja:
imposto = calcular_imposto(faturamento_loja)
else:
imposto = 0
print("Imposto foi de:", imposto)Esse código já está correto. Ele cumpre o propósito de verificar se a informação do faturamento da loja foi inserida corretamente.
No entanto, quando temos uma estrutura condicional que realiza apenas uma ação, que é atribuir um valor à variável imposto, podemos simplificar o código da seguinte forma:
def calcular_imposto(faturamento):
if faturamento:
imposto = 0.3 * float(faturamento)
return imposto
faturamento_loja = input("Faturamento:")
imposto = calcular_imposto(faturamento_loja) if faturamento_loja else 0
print("Imposto foi de:", imposto)Perceba que ainda temos a estrutura condicional, porém de forma simplificada, e ainda é possível compreender claramente o que ela faz.
Podemos otimizar ainda mais esse código:
def calcular_imposto(faturamento):
if faturamento:
imposto = 0.3 * float(faturamento)
return imposto
faturamento_loja = input("Faturamento:")
imposto = calcular_imposto(faturamento_loja) or 0
print("Imposto foi de:", imposto)Nesse caso, estamos atribuindo à variável imposto o resultado da função calcular_imposto ou 0. Isso significa que, se o valor retornado pela função calcular_imposto for None, o programa irá considerar o segundo valor atribuído, no caso o 0.
Ambos os códigos irão funcionar corretamente. Se executarmos tanto o nosso primeiro código otimizado quanto o segundo, e não passarmos nenhum valor para o faturamento, teremos o resultado de 0.
No entanto, repare como a segunda otimização deixa a leitura menos intuitiva e clara. Na primeira, conseguimos bater o olho no código e compreender claramente o que essa linha de código quer fazer:
imposto = calcular_imposto(faturamento_loja) if faturamento_loja else 0Já na segunda otimização, não fica tão claro logo de cara:
imposto = calcular_imposto(faturamento_loja) or 0Este é um exemplo bem simples, então pode parecer que não há essa complicação. Mas imagine isso sendo replicado em um código maior, com mais variáveis e funções. Isso pode tornar a leitura e compreensão dele mais demorada.
Na primeira opção, as condições estão explícitas, e isso é algo fundamental para facilitar a compreensão e clareza do código. Você pode evitar ser redundante, mas priorize fazer isso mantendo as regras de forma explícita.
Na aula de hoje, discutimos a importância da otimização de código e até que ponto vale a pena realizar essa otimização. Não há uma regra fixa para isso, e com a prática, você desenvolverá uma melhor percepção e equilíbrio entre um código otimizado e um código legível.
Como dica e parâmetro, pode ser interessante sempre verificar se as regras e condições estão claras em seu código, de modo que, ao dar uma rápida olhada, seja possível compreender o que cada linha está fazendo. Isso não apenas facilita o seu próprio trabalho, mas também torna o código mais acessível para outras pessoas que possam interagir com ele.
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 Python e virar uma referência na sua empresa? Inscreva-se agora mesmo no Python Impressionador