4 Boas Práticas em Python – Dicas Para Usar Sempre!
Aprenda 4 boas práticas em Python que podem fazer a diferença no seu código! São dicas valiosas que vão facilitar o entendimento, tornar seu código mais limpo e otimizar seu processo de programação!
Entre as principais boas práticas em Python estão usar if __name__ == "__main__" para separar código executável de importável; dividir o programa em funções pequenas e claras; adicionar type annotations para indicar os tipos esperados; e usar list comprehension para criar listas de forma concisa. Elas deixam o código mais limpo, legível e fácil de manter.
Se quiser pode acompanhar esse conteúdo em formato de vídeo ou pode acessar o nosso Canal do YouTube para mais vídeos!
O que você aprende neste vídeo
Resposta rápida: Aula reúne quatro boas práticas de Python: usar if __name__ == "__main__": para testar um módulo sem que o teste rode ao importá-lo, dividir funções para que cada uma faça uma única coisa, usar type annotations (faturamento: float) para indicar o tipo esperado, e trocar um for que monta lista por um list comprehension numa linha só.
Neste vídeo (19 min):
- 1:00 - Dica 1, testar módulos: chamar a função direto no fim do arquivo funciona para testar, mas essa linha roda de novo toda vez que o arquivo é importado em outro lugar
- 3:00 - Quando um arquivo é importado, o Python executa todo o código que está fora de função ou classe dentro dele, inclusive a chamada de teste
- 4:00 - O bloco
if __name__ == "__main__":só executa o código quando o arquivo roda diretamente, e fica falso quando ele é importado por outro - 6:00 - Dica 2, divisão de funções: cada função deveria ter um único objetivo, e a função do exemplo calculava a taxa e o imposto ao mesmo tempo
- 8:00 - Separar o cálculo da taxa numa função própria permite reutilizá-la em outros pontos do código sem duplicar a lógica
- 11:00 - Dica 3, type annotations: escrever
faturamento: floatno parâmetro indica o tipo esperado, e o editor passa a sugerir os métodos certos - 12:00 - Uma função que não retorna nada usa
Nonecomo anotação de tipo de retorno - 14:00 - Dica 4, list comprehension: substitui um
forde várias linhas que cria uma lista vazia e vai dandoappend, por uma única linha - 16:00 - Compara o list comprehension com a função
map(), que também aplica uma função a cada elemento de uma lista
Trechos do vídeo:
- O bloco
if __name__ == "__main__":só executa quando o arquivo roda diretamente, e fica falso quando ele é importado por outro arquivo - Quando um arquivo é importado, o Python executa todo o código que está fora de função ou classe dentro dele, e é isso que faz um teste solto disparar de novo
- Cada função deveria ter um único objetivo: separar o cálculo em funções menores permite reutilizar a lógica em outros pontos do código sem duplicar
- Escrever o tipo esperado de um parâmetro, como
faturamento: float, faz o editor de código sugerir só os métodos daquele tipo - Um list comprehension substitui um
forde várias linhas que cria uma lista vazia e vai usandoappend, por uma única linha de código
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.
O que você vai ver hoje?
4 Boas Práticas em Python – Dicas Para Usar Sempre!
Adotar boas práticas de programação é essencial para manter o código organizado, legível e de fácil manutenção.
Nesta aula, vou apresentar quatro boas práticas em Python que você pode aplicar em qualquer projeto: testes de módulos, divisão de funções, anotações de tipo (Type Annotations) e List Comprehension.
Essas dicas vão ajudar a manter seu código fácil de ler, facilitando tanto a manutenção quanto o trabalho colaborativo, permitindo que outros programadores compreendam e expandam o projeto sem dificuldades.
Testando Módulos com if __name__ == “__main__”
Ao desenvolver módulos em Python, é comum separar funções e classes em arquivos distintos para organizá-los e permitir a importação entre eles.
No entanto, antes de importar essas funções para outros módulos, você vai querer testá-las para garantir que estão funcionando corretamente.
Uma maneira prática e segura de fazer isso é usando a estrutura if __name__ == “__main__”.
Com ela, você pode rodar testes de maneira isolada, pois o código dentro desse bloco será executado apenas quando o arquivo for executado diretamente, e não quando for importado como um módulo.
Esse comportamento acontece porque, ao executar um arquivo, o Python atribui automaticamente à variável interna __name__ o valor “__main__” se o arquivo for rodado diretamente.
Por exemplo, no material disponível para download você encontrará dois arquivos: calculos.py e gabarito.py.
No calculos.py, temos a função calcular_imposto, que é importada e usada em gabarito.py.
Imagine que você deseja testar essa função antes de integrá-la ao código final. Basta definir o teste dentro de um bloco if __name__ == “__main__”.
def calcular_taxa(faturamento: float) -> float:
if faturamento < 1000:
taxa = 0
elif faturamento < 10000:
taxa = 0.1
elif faturamento < 500000:
taxa = 0.15
else:
taxa = 0.2
return taxa
def calcular_imposto(faturamento: float) -> float:
taxa = calcular_taxa(faturamento)
imposto = taxa * faturamento
print(imposto)
return imposto
if __name__ == "__main__":
calcular_imposto(1000)Neste exemplo, o código dentro do bloco if __name__ == “__main__” será executado apenas ao rodar diretamente o arquivo calculos.py.

Se calculos.py for importado por outro arquivo, como gabarito.py, esse trecho de teste não será executado, mantendo o fluxo do código sem gerar saídas desnecessárias.
Vantagens em usar if __name__ == “__main__”:
- Isolamento de testes: permite testar funções de forma isolada, sem impactar outros módulos.
- Organização: mantém o código de teste no próprio arquivo, sem necessidade de arquivos adicionais.
Quer saber mais sobre essa estrutura e outros conceitos importantes em Python? Confira a aula: Conceitos Importantes em Python que Todo Programador Precisa Saber
Divisão de Funções para Maior Clareza e Modularidade
Outro conceito essencial para organizar seu código em Python é a divisão de funções. Em geral, uma boa função deve ter um único propósito e executar uma tarefa específica.
Essa abordagem facilita a leitura e o entendimento do código, tornando-o mais modular e fácil de manter.
Além disso, torna mais simples realizar futuras atualizações, pois qualquer alteração pode ser feita apenas na função específica, sem interferir no restante do código.
A modularidade também permite a reutilização de funções, evitando a duplicação de código e reduzindo as chances de erros.
Vamos usar novamente a função calcular_imposto como exemplo. Suponha que inicialmente tivéssemos a função escrita da seguinte forma:
def calcular_imposto(faturamento: float) -> float:
if faturamento < 1000:
taxa = 0
elif faturamento < 10000:
taxa = 0.1
elif faturamento < 500000:
taxa = 0.15
else:
taxa = 0.2
imposto = taxa * faturamento
print(imposto)
return impostoEssa função calcula o imposto com base no faturamento, mas observe que ela contém tanto a lógica para definir a taxa quanto o cálculo do valor final do imposto.
Para aumentar a modularidade, podemos dividir essa função em duas, isolando a lógica de definição da taxa em uma função separada chamada calcular_taxa, deixando a função calcular_imposto responsável apenas pelo cálculo final do imposto.
def calcular_taxa(faturamento: float) -> float:
if faturamento < 1000:
taxa = 0
elif faturamento < 10000:
taxa = 0.1
elif faturamento < 500000:
taxa = 0.15
else:
taxa = 0.2
return taxa
def calcular_imposto(faturamento: float) -> float:
taxa = calcular_taxa(faturamento)
imposto = taxa * faturamento
print(imposto)
return impostoDessa forma, tanto a lógica de cálculo de taxas quanto o cálculo do imposto final podem ser atualizados de maneira independente, sem a necessidade de modificar outras partes do código.
Benefícios dessa abordagem:
- Facilidade de manutenção: Se a lógica de qualquer uma das funções mudar, será necessário ajustar apenas a função específica.
- Reutilização: Com as lógicas bem definidas e separadas fica mais fácil reutilizar as funções sem a necessidade de repetir o código.
Saiba como as funções funcionam a partir de nossa aula Funções em Python – Como usar def no Python
Utilizando Type Annotations para Maior Clareza e Segurança
Python é uma linguagem de tipagem dinâmica, o que significa que as variáveis podem mudar de tipo ao longo do código e da execução do programa.
Essa flexibilidade é poderosa e vantajosa, mas também pode levar a erros e confusões no código.
Nesse contexto, as Type Annotations ajudam a documentar o tipo de variável que uma função espera receber e o tipo que ela retorna, tornando o código mais claro e menos suscetível a erros.
As type annotations, ou anotações de tipo, são uma maneira de documentar explicitamente os tipos de dados que funções e variáveis devem receber e retornar.
Em Python, isso é feito usando a sintaxe nome: tipo para os parâmetros das funções e -> tipo para indicar o tipo de retorno.
Por exemplo, nas nossas funções calcular_taxa e calcular_imposto, as anotações de tipo deixam claro que os parâmetros recebidos são do tipo float e que o retorno das funções também são do tipo float.
def calcular_taxa(faturamento: float) -> float:
if faturamento < 1000:
taxa = 0
elif faturamento < 10000:
taxa = 0.1
elif faturamento < 500000:
taxa = 0.15
else:
taxa = 0.2
return taxa
def calcular_imposto(faturamento: float) -> float:
taxa = calcular_taxa(faturamento)
imposto = taxa * faturamento
print(imposto)
return impostoVantagens de utilizar Type Annotations:
- Redução de erros: Facilita a identificação de erros relacionados a tipos, pois o código já indica os tipos esperados.
- Compatibilidade com IDEs: Ferramentas de desenvolvimento, como o Visual Studio Code, podem utilizar essas anotações para fornecer sugestões de código e alertas.
Em projetos com muitas funções interconectadas, as anotações de tipo tornam mais fácil acompanhar quais tipos são necessários em cada parte do código.
Elas são especialmente úteis ao lidar com diferentes tipos de dados entre várias funções, ajudando na manutenção e na compreensão do código por outros programadores.
Simplificando Operações com List Comprehension
Uma prática poderosa em Python é o uso de list comprehension para gerar listas de forma mais concisa e eficiente.
Quando você precisa aplicar uma operação a cada elemento de uma lista e deseja obter uma nova lista com os resultados, o list comprehension é a opção ideal, pois combina a criação da lista e a aplicação da operação em uma única linha de código.
Por exemplo, suponha que você tenha uma lista de faturamentos e deseja calcular o imposto para cada valor. Em vez de utilizar um loop for tradicional, com list comprehension essa lógica é reduzida a uma única linha.
No caso de um loop for tradicional, o código seria assim:
from calculos import calcular_imposto
faturamentos = [1000, 1500, 3000, 4000, 7000, 3000000, 510000]
impostos = []
for faturamento in faturamentos:
impostos.append(calcular_imposto(faturamento))
print(impostos)Com list comprehension, essa mesma lógica fica mais enxuta:
from calculos import calcular_imposto
faturamentos = [1000, 1500, 3000, 4000, 7000, 3000000, 510000]
impostos = [calcular_imposto(faturamento) for faturamento in faturamentos]
print(impostos)
Vantagens do List Comprehension:
- Legibilidade: Código mais curto e direto, fácil de entender para operações simples.
- Performance: Em muitos casos, list comprehension é mais rápido do que loops for convencionais.
Para dominar o list comprehension e saber como utilizá-lo corretamente, veja a nossa aula: O que é List Comprehension no Python e Como Usá-lo
Perguntas frequentes
1. Para que serve o if __name__ == “__main__” no Python?
Esse bloco define o que roda apenas quando o arquivo é executado diretamente, e não quando é importado por outro script. Assim, você separa o código de teste ou execução das funções reutilizáveis. É uma boa prática que evita que trechos rodem sem querer ao importar o módulo em outro projeto.
2. O que são type annotations no Python?
São anotações que indicam os tipos esperados de variáveis, parâmetros e retornos de funções, como def soma(a: int, b: int) -> int. Elas não mudam a execução, mas documentam o código, ajudam editores a detectar erros e facilitam a leitura. São muito recomendadas em projetos maiores e colaborativos.
3. O que é list comprehension no Python?
É uma forma concisa de criar listas em uma única linha, no formato [expressão for item in iterável]. Por exemplo, [n*2 for n in range(5)] gera [0, 2, 4, 6, 8]. Substitui laços mais longos, deixando o código mais limpo e legível, e ainda costuma ser mais rápida que um for tradicional.
4. Por que dividir o código em funções pequenas?
Funções pequenas, cada uma com uma responsabilidade única, tornam o código mais legível, fácil de testar e de reaproveitar. Quando algo dá errado, você localiza o problema mais rápido, e alterações ficam isoladas em um só ponto. É a base de um código organizado e modular, que cresce sem virar bagunça.
Conclusão – 4 Boas Práticas em Python – Dicas Para Usar Sempre!
Nesta aula, você aprendeu quatro boas práticas essenciais em Python: testes de módulos, divisão de funções, Type Annotations e List Comprehension. Essas práticas são fundamentais para escrever um código de qualidade, organizado e fácil de manter.
Embora possa parecer trabalhoso adotar essas práticas no início, a longo prazo elas resultam em um código mais eficiente, fácil de compartilhar, ler e expandir.
Ao aplicar essas práticas em seus projetos, você perceberá uma grande diferença na estrutura e qualidade do seu código. Elas não apenas facilitam o desenvolvimento, mas também garantem que seu código esteja preparado para adaptações e colaborações.
Hashtag Treinamentos
Para acessar outras publicações de Python, clique aqui!
Posts mais recentes de Python
- Cursor para iniciantes: tutorial completo passo a passoCursor para iniciantes: aprenda a instalar, configurar o modelo, usar os modos Plan e Ask e criar sua primeira automação em Python com IA.
- Agente de IA local com Python: crie o seu com OllamaAprenda a criar um agente de IA local com Python, Ollama e LangChain: rode modelos no seu PC, sem pagar por API e sem expor os dados da empresa.
- Como Criar CRM com Codex no VS Code usando Python e FlaskAprenda a criar CRM com Codex no VS Code usando Python, Flask e SQLite, com login, orçamentos e PDF, em fases com testes e commits no Git.
Posts mais recentes da Hashtag Treinamentos
- ChatGPT para criar fórmulas no Excel: 5 exemplos práticosAprenda a usar o ChatGPT para criar fórmulas no Excel com 5 exemplos práticos de SOMA, SOMASES, SE, PROCV e CONT.SES, e veja como pedir certo e validar.
- Cursor para iniciantes: tutorial completo passo a passoCursor para iniciantes: aprenda a instalar, configurar o modelo, usar os modos Plan e Ask e criar sua primeira automação em Python com IA.
- Claude Artifacts: crie dashboards, slides e sites com IAAprenda a usar o Claude Artifacts para criar dashboards, apresentações e sites com IA a partir de um prompt, com exemplos e prompts prontos para copiar.







