Melhores Práticas em Python

Este artigo explica as melhores práticas em Python.

Vamos explicar as melhores práticas em Python com exemplos reais de código, apresentando formas de escrever códigos legíveis e fáceis de manter.

YouTube Video

Melhores Práticas em Python

Priorize a legibilidade acima de tudo

Primeiro, vamos ver como 'priorizar a legibilidade acima de tudo'.

Python é uma linguagem que valoriza a 'legibilidade'. Primeiramente, priorize escrever um código cuja intenção seja clara à primeira vista.

1# Bad example: unclear variable names
2a = 10
3b = 5
4c = a * b

Neste código, os nomes das variáveis não transmitem seu significado, então leva tempo para que outros entendam depois.

1# Good example: descriptive variable names
2price = 10
3quantity = 5
4total_cost = price * quantity

Ao tornar os nomes das variáveis específicos, seu código funciona como documentação.

Escreva código explícito

Em seguida, vamos analisar o conceito de 'escrever código explícito'.

Em Python, 'intenção explícita' é preferida em relação ao 'comportamento implícito'.

1# Bad example: implicit truthy check
2if data:
3    process(data)

Neste código, não está claro o que se espera de data, criando um ambiente propício para bugs.

1# Good example: explicit condition
2if len(data) > 0:
3    process(data)

Ao tornar as condições explícitas, a intenção do código corresponde à sua especificação.

Mantenha as funções pequenas e focadas em uma única responsabilidade

Em seguida, vamos analisar 'manter as funções pequenas e com uma única responsabilidade'.

Quando uma função faz muitas coisas, testar e manter o código torna-se difícil.

1# Bad example: doing too many things
2def handle_user(user):
3    save_to_database(user)
4    send_email(user)
5    write_log(user)

Neste código, os processos ficam fortemente acoplados, tornando difícil o reuso e a modificação.

1# Good example: single responsibility
2def save_user(user):
3    save_to_database(user)
4
5def notify_user(user):
6    send_email(user)
7
8def log_user(user):
9    write_log(user)

Ao dividir as funções, seus papéis ficam claros e os testes tornam-se mais fáceis.

Use dicas de tipos ativamente

A seguir, vamos analisar o uso ativo de dicas de tipos.

Dicas de tipos funcionam como documentação e são uma ferramenta poderosa para evitar bugs.

1# Bad example: Without type hints
2def add(a, b):
3    return a + b

Neste código, os tipos de argumentos e valores de retorno não são claros, aumentando a chance de uso incorreto.

1# Good example: With type hints
2def add(a: int, b: int) -> int:
3    return a + b

Com dicas de tipos, a conclusão da IDE, a análise estática e a legibilidade melhoram bastante.

Indique explicitamente a possibilidade de retornar None

Agora, vamos analisar 'indicar explicitamente a possibilidade de retornar None'.

Funções que podem retornar None frequentemente passam despercebidas pelos que as utilizam.

1# Bad example: Ambiguous return value
2def find_user(user_id):
3    if user_id == 1:
4        return {"id": 1, "name": "Alice"}
5    return None

Neste código, não está claro se haverá um valor de retorno.

1# Good example: explicit return type
2from typing import Optional, Dict, Any
3
4def find_user(user_id: int) -> Optional[Dict[str, Any]]:
5    if user_id == 1:
6        return {"id": 1, "name": "Alice"}
7    return None

Ao usar Optional, você indica a possibilidade de retornar None como um tipo.

Não capture exceções de forma muito ampla

A seguir, vamos analisar o conceito de 'não capturar exceções de forma muito ampla'.

O tratamento de exceções deve capturar apenas o que for realmente necessário.

1# Bad example: catching all exceptions
2try:
3    result = int(value)
4except Exception:
5    result = 0

Este código pode ocultar bugs que deveriam ter sido percebidos.

1# Good example: catch specific exception
2try:
3    result = int(value)
4except ValueError:
5    result = 0

Restringindo as exceções, você não deixará de perceber problemas inesperados.

Gerencie recursos de forma segura com a instrução with

Agora, vamos analisar 'como gerenciar recursos com segurança utilizando a instrução with'.

Recursos como arquivos e locks devem sempre ser liberados de forma confiável.

1# Bad example: manual close
2file = open("data.txt")
3content = file.read()
4file.close()

Neste código, se ocorrer uma exceção, o método close() pode não ser chamado.

1# Good example: using context manager
2with open("data.txt") as file:
3    content = file.read()

Com a instrução with, a limpeza é feita com segurança, mesmo que haja uma exceção.

Utilize compreensões de listas adequadamente

A seguir, veremos 'como utilizar as compreensões de listas adequadamente'.

Processos simples de transformação podem ser escritos de forma concisa usando compreensões de listas.

1# Bad example: Verbose loop
2squares = []
3for i in range(10):
4    squares.append(i * i)

Neste código, é difícil identificar o processo principal.

1# Good example: Clear list comprehension
2squares = [i * i for i in range(10)]

Com o uso adequado de compreensões de listas, a legibilidade do código aumenta.

Evite números mágicos

Agora, vamos analisar 'como evitar números mágicos'.

Escrever números e strings diretamente deixa seu significado pouco claro.

1# Bad example: magic number
2if status == 404:
3    handle_not_found()

Neste código, pressupõe-se que você sabe o significado de 404.

1# Good example: named constant
2NOT_FOUND = 404
3
4if status == NOT_FOUND:
5    handle_not_found()

Nomear torna as intenções claras.

Escreva código que seja fácil de manter, não apenas código que 'funciona'

Por fim, vamos analisar 'a importância de escrever código que seja fácil de manter, e não apenas que funcione'.

O ponto importante é se você no futuro, ou outras pessoas, conseguirão entender o código.

1# Bad example: Hard to maintain
2def f(x):
3    return x * 1.08 + 100

Neste código, a especificação não pode ser compreendida a partir do próprio código.

1# Good example: Easy to maintain
2TAX_RATE = 1.08
3BASE_FEE = 100
4
5def calculate_total(price: float) -> float:
6    return price * TAX_RATE + BASE_FEE

Ao refletir significado nos nomes, o código torna-se a própria especificação.

Resumo

As melhores práticas em Python se resumem a escrever código fácil de entender, em vez de código engenhoso. Construir pequenos hábitos leva a códigos com menos bugs, que podem ser usados por muito tempo.

Você pode acompanhar o artigo acima usando o Visual Studio Code em nosso canal do YouTube. Por favor, confira também o canal do YouTube.

YouTube Video