Bem-vindo à aula de número 98 do nosso curso de Python! Nesta aula, vamos mergulhar nas boas práticas que diferenciam um código meramente funcional de um código profissional, elegante e sustentável. Você já sabe escrever programas em Python, mas agora é hora de polir suas habilidades para produzir código que seja não apenas correto, mas também legível, idiomático e alinhado com a comunidade Python.

Vamos explorar quatro pilares fundamentais: a PEP 8 (o guia de estilo oficial), o Zen do Python (os princípios filosóficos que orientam o design da linguagem), o conceito de código idiomático (pythonic) e a prática de code review. Ao final, você terá um conjunto de ferramentas mentais para escrever código que outros desenvolvedores (e você mesmo no futuro) agradecerão.

PEP 8

A PEP 8 (Python Enhancement Proposal 8) é o guia de estilo oficial para código Python. Ela define convenções sobre como formatar o código, nomear identificadores, organizar importações, entre outros aspectos. Seguir a PEP 8 é essencial para garantir consistência em projetos, facilitar a leitura e a colaboração. Muitos projetos open source e empresas exigem conformidade com a PEP 8.

Principais recomendações da PEP 8:

  • Indentação: use 4 espaços por nível, não tabs.
  • Limite de linha: mantenha linhas com no máximo 79 caracteres (99 para docstrings/comentários).
  • Espaçamento: use espaços ao redor de operadores, após vírgulas, e em atribuições.
  • Nomes: use snake_case para funções e variáveis, CamelCase para classes, e UPPER_CASE para constantes.
  • Importações: coloque cada import em uma linha separada, organize em ordem padrão (stdlib, terceiros, locais) e evite importações curinga (from module import *).
  • Linhas em branco: use duas linhas em branco entre funções e classes, e uma linha em branco entre métodos.

Exemplo de código seguindo a PEP 8:

import os
import sys

from django.conf import settings

MAX_CONNECTIONS = 100

class DatabaseConnection:
    """Gerencia conexões com o banco de dados."""

    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.connected = False

    def connect(self):
        if not self.connected:
            self.connected = True
            print(f"Conectando a {self.host}:{self.port}")

def main():
    conn = DatabaseConnection("localhost", 5432)
    conn.connect()

if __name__ == "__main__":
    main()

Ferramentas como flake8, pycodestyle e black podem ajudar a verificar e formatar automaticamente seu código conforme a PEP 8.

The Zen of Python

O Zen do Python é um conjunto de 19 princípios que capturam a filosofia de design da linguagem. Foi escrito por Tim Peters e pode ser acessado no interpretador Python com import this. Esses princípios servem como guia para escrever código que seja claro, simples e bonito.

Os princípios mais conhecidos incluem:

  • Bonito é melhor que feio.
  • Explícito é melhor que implícito.
  • Simples é melhor que complexo.
  • Complexo é melhor que complicado.
  • Legibilidade conta.
  • Erros nunca devem passar silenciosamente.
  • Agora é melhor que nunca.

Vamos ver um exemplo prático: o princípio "Explícito é melhor que implícito" sugere que devemos evitar truques que tornem o código obscuro. Por exemplo, em vez de usar if len(lista) > 0:, prefira if lista:, pois é mais explícito sobre a intenção de verificar se a lista não está vazia.

# Não pythonico (implícito)
if len(nomes) > 0:
    print("Há nomes")

# Pythonico (explícito)
if nomes:
    print("Há nomes")

O Zen do Python não é um conjunto de regras rígidas, mas sim uma filosofia que nos orienta a tomar decisões de design que priorizam a clareza e a simplicidade.

Idiomático (pythonic)

Escrever código idiomático, ou "pythonic", significa usar os padrões e construções que são naturais à linguagem Python, aproveitando seus recursos para escrever código mais expressivo e eficiente. Código pythonic é geralmente mais legível e mais fácil de manter, pois segue as convenções da comunidade.

Alguns exemplos de código pythonic:

  • Compreensão de listas em vez de loops tradicionais.
  • Desempacotamento de tuplas para trocar valores ou extrair elementos.
  • Uso de enumerate em vez de range(len(...)).
  • Context managers (with) para gerenciar recursos.
  • Uso de zip para iterar sobre múltiplas sequências.

Exemplo de código não idiomático vs. idiomático:

# Não idiomático
cores = ['vermelho', 'verde', 'azul']
for i in range(len(cores)):
    print(i, cores[i])

# Idiomático
for i, cor in enumerate(cores):
    print(i, cor)

Outro exemplo: usar f-strings para formatação de strings, em vez de concatenação ou format():

nome = "Maria"
idade = 30

# Não idiomático
print("Nome: " + nome + ", idade: " + str(idade))

# Idiomático
print(f"Nome: {nome}, idade: {idade}")

Escrever código pythonic não é sobre usar os recursos mais avançados, mas sim sobre escolher a forma mais clara e expressiva de expressar uma operação.

Code review

Code review é o processo de revisão sistemática do código por outros desenvolvedores, com o objetivo de encontrar bugs, melhorar a qualidade e compartilhar conhecimento. É uma prática fundamental em equipes de desenvolvimento, especialmente em projetos open source e em ambientes ágeis.

Durante um code review, o revisor analisa o código em busca de problemas como:

  • Erros lógicos e bugs.
  • Violações de boas práticas (PEP 8, padrões da equipe).
  • Falta de testes ou testes inadequados.
  • Complexidade desnecessária.
  • Problemas de segurança e desempenho.

Para fazer um code review eficaz, siga estas dicas:

  • Revise o código, não a pessoa: foque no código e em como melhorá-lo, não em críticas pessoais.
  • Seja específico: aponte linhas exatas e sugira soluções concretas.
  • Equilibre elogios e críticas: reconheça o que está bom.
  • Priorize problemas: separe o que é essencial do que é opcional.
  • Use ferramentas: plataformas como GitHub, GitLab ou Bitbucket oferecem funcionalidades de review.

Exemplo de um comentário em um code review:

# Código original
result = []
for i in range(10):
    if i % 2 == 0:
        result.append(i)
return result

# Comentário do revisor:
# "Sugiro usar uma compreensão de lista para simplificar: [i for i in range(10) if i % 2 == 0]"

Adotar code review em seu fluxo de trabalho ajuda a manter a qualidade do código e a disseminar conhecimento entre os membros da equipe.

Boas práticas e observações finais

Além dos tópicos abordados, aqui vão algumas observações finais para consolidar seu aprendizado:

  • Consistência é mais importante que a regra: se o projeto já tem um estilo, siga-o, mesmo que divirja da PEP 8 em alguns pontos.
  • Documentação: escreva docstrings claras para módulos, classes e funções.
  • Testes: escreva testes para seu código; isso é parte das boas práticas.
  • Ferramentas: utilize linters (como pylint) e formatadores (como black) para automatizar a conformidade.
  • Comunidade: participe de projetos open source para ver exemplos de código bem escrito e praticar code review.

Lembre-se: boas práticas não são um fim em si mesmas, mas um meio para criar software mais confiável e sustentável.

Exercícios

  1. Reescreva o trecho abaixo seguindo a PEP 8 (atenção à indentação, espaçamento e nomes):
    def soma(a,b):
    return a+b

class Calculadora:
    def __init__(self,valor):
        self.valor=valor
    def somar(self,outro):
        return self.valor+outro

    ✓ Resposta: 
    def soma(a, b):
    return a + b

class Calculadora:
    def __init__(self, valor):
        self.valor = valor

    def somar(self, outro):
        return self.valor + outro
  2. Cite três princípios do Zen do Python e explique como eles influenciam a escrita de código.

✓ Resposta: Exemplos: "Bonito é melhor que feio" incentiva código legível; "Explícito é melhor que implícito" evita magia; "Simples é melhor que complexo" prega soluções diretas.
  • Transforme o código abaixo em uma versão pythonic usando compreensão de lista:
    quadrados = []
for i in range(10):
    quadrados.append(i ** 2)

    ✓ Resposta: 
    quadrados = [i ** 2 for i in range(10)]
  • Em um code review, um colega sugeriu usar with open(...) as f: em vez de f = open(...). Explique por que essa é uma boa sugestão.

    • ✓ Resposta: O with garante que o arquivo seja fechado automaticamente, mesmo em caso de exceção, evitando vazamento de recursos. É mais seguro e idiomático.
  • Escreva uma função processar_dados que receba uma lista de números e retorne uma lista apenas com os números pares, mas usando filter e lambda (pythonic).

    • ✓ Resposta: 
    def processar_dados(numeros):
    return list(filter(lambda x: x % 2 == 0, numeros))

    Referências