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!
Se quiser pode acompanhar esse conteúdo em formato de vídeo ou pode acessar o nosso Canal do YouTube para mais vídeos!
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 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
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
- Biblioteca NumPy: o que é, vantagens e como usar
Aprenda como usar a biblioteca NumPy no Python para otimizar o processamento de dados e melhorar sua eficiência em projetos de ciência de dados. - Set em Python: o que é, quando e como usar no seu projeto Aprenda tudo sobre sets em Python: o que são, como usar e quando aplicar. Descubra operações com conjuntos e vantagens sobre listas!
- ETL com Python: guia completo para criar pipelines de dados Aprenda como construir pipelines ETL com Python do zero! Descubra as melhores bibliotecas, resolva desafios comuns e torne-se um especialista!
Posts mais recentes da Hashtag Treinamentos
- Exercícios de Listening em Inglês – Como Melhorar sua Compreensão Faça estes exercícios de listening em inglês e melhore sua compreensão! Descubra técnicas e estratégias para praticar e evoluir no aprendizado do idioma!
- TCP e UDP: o que são, diferenças e quando usar Entenda o que é TCP e UDP, as diferenças entre os protocolos, suas vantagens e quando usar cada um. Aprenda com exemplos práticos e linguagem acessível.
- Power Apps: o que é, benefícios e como usar Descubra o que é Power Apps, como a ferramenta revoluciona a criação de aplicativos e como você pode começar a usá-la hoje mesmo!
Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.