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: float no 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 None como anotação de tipo de retorno
• 14:00 - Dica 4, list comprehension: substitui um for de várias linhas que cria uma lista vazia e vai dando append, 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 for de várias linhas que cria uma lista vazia e vai usando append, 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.

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

Python Impressionador

Você vai aprender a linguagem de Programação que mais cresce no Mundo para fazer automações incríveis, desenvolver sites, fazer análises de dados, trabalhar com Ciência de Dados, Inteligência Artificial, mesmo que você nunca tenha tido nenhum contato com Programação na vida.

Começar agora

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 imposto

Essa 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 imposto

Dessa 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 imposto

Vantagens 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

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

• 
  Curso Básico de Python: Saia do Zero em 10 Aulas Grátis18 de setembro de 2026
  Aprenda com o curso básico de Python gratuito da Hashtag: 10 aulas práticas, exercícios e projetos reais para sair do zero em programação.
• 
  Agentes RAG com Python: como criar um assistente de IA17 de setembro de 2026
  Aprenda a criar Agentes RAG com Python do zero: LangChain, FAISS e OpenAI para montar um assistente de IA que responde com base nos seus documentos.
• 
  25 Tipos de Gráficos em Python: Guia Completo com Código26 de agosto de 2026
  Aprenda a criar os principais tipos de gráficos em Python com Plotly: barras, pizza, mapas e mais, com código pronto para copiar e usar.

Posts mais recentes da Hashtag Treinamentos

• 
  Planilha de Controle de Notas Fiscais no Excel [Grátis]2 de outubro de 2026
  Baixe a planilha de controle de notas fiscais no Excel grátis: calcule ISS e retenções, veja o que está em aberto e gere a cobrança de cada nota de serviço.
• 
  Qual IA usar na empresa: ChatGPT, Claude ou Perplexity?2 de outubro de 2026
  Qual IA usar na empresa: veja as diferenças entre ChatGPT, Claude e Perplexity e quando cada um rende mais em cada área da sua equipe.
• 
  Apostilas Gratuitas em PDF: Excel, Power BI, Python e IA30 de setembro de 2026
  Baixe apostilas gratuitas em PDF de Excel, Power BI, Python, Claude e agentes de IA, com exercícios e gabarito. Escolha a sua e comece hoje.