Desvendando o Zen do Python: Melhores Práticas e Exemplos Práticos

Introdução

Bonito é melhor que feio

Dica:

Escreva código legível e autoexplicativo, evitando abreviações e complexidades desnecessárias.

Exemplo Prático:

# Ruim
x = 100
y = 200
z = x + y

# Bom
total = 100 + 200

Explícito é melhor que implícito

Dica:

Torne o seu código o mais claro possível, evitando ambiguidades e suposições.

Exemplo Prático:

# Implícito
def calcular(a, b):
    return a + b

# Explícito
def somar(valores):
    total = 0
    for valor in valores:
        total += valor
    return total

Simples é melhor que complexo

Dica:

Prefira soluções simples e diretas em vez de complicar desnecessariamente.

Exemplo Prático:

# Complexo
def fatorial(n):
    if n == 0:
        return 1
    else:
        return n * fatorial(n - 1)

# Simples
import math
math.factorial(n)

Complexo é melhor do que complicado

Dica:

Prefira soluções complexas, mas claras e estruturadas, em vez de soluções complicadas e confusas.

Exemplo Prático:

# Complexo
def fatorial(n):
    if n == 0:
        return 1
    else:
        return n * fatorial(n-1)

# Complicado
import math
math.factorial(n)

Plano é melhor que aninhado

Dica:

Evite aninhar estruturas profundamente, pois isso pode dificultar a leitura e manutenção do código.

Exemplo Prático:

# Aninhado
if x:
 if y:
 if z:
 print("Aninhamento profundo!")

# Plano
if x and y and z:
 print("Sem aninhamento!")

Esparsa é melhor do que densa

Dica:

Prefira código espaçado e bem organizado em vez de código denso e difícil de ler.

Exemplo Prático:

# Densa
for i in range(10):print(i,end='')

# Esparsa
for i in range(10):
    print(i, end='')

Legibilidade conta

Dica:

Escreva seu código de forma que seja fácil de ler, entender e manter por outros programadores.

Exemplo Prático:

# Código pouco legível
def x(a,b,c,d):return a+b+c+d

# Código legível
def soma(a, b, c, d):
 return a + b + c + d

Casos especiais não são especiais o suficiente para quebrar as regras

Dica:

Mantenha consistência e evite fazer exceções desnecessárias às boas práticas.

Exemplo Prático:

# Quebrando a regra
if len(lista) == 0:
 print("Lista vazia!")

# Boa prática
if not lista:
 print("Lista vazia!")

Embora a praticidade vença a pureza

Dica:

Em certas situações, é preferível optar pela praticidade em detrimento da pureza do código.

Exemplo Prático:

# Pureza
def divide(a, b):
    return a / b

# Praticidade
def divide_com_tratamento(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return float('inf') if a > 0 else float('-inf')

Erros nunca devem passar silenciosamente

Dica:

Trate e reporte erros de forma apropriada em vez de ignorá-los. Exemplo Prático:

# Silenciando erros
try:
 resultado = operacao()
except:
 pass

# Tratando erros
try:
 resultado = operacao()
except Exception as e:
 print("Erro:", e)

A menos que explicitamente silenciado

Dica:

A menos que seja explicitamente necessário, não silencie os erros.

Exemplo Prático:

# Silenciando todos os erros
try:
    resultado = operacao()
except:
    pass

# Tratando erros específicos
try:
    resultado = operacao()
except ValueError:
    print("Valor inválido!")

Diante da ambiguidade, recuse a tentação de adivinhar

Dica:

Seja explícito em relação aos detalhes e evite deixar espaço para interpretações ambíguas.

Exemplo Prático:

# Ambíguo
def processar(lista):
    if lista:
        return lista[0]
    else:
        return None

# Explícito
def processar(lista):
    if lista:
        return lista[0]
    return None

Deve haver uma — e preferencialmente apenas uma — maneira óbvia de fazer algo

Dica:

Evite oferecer múltiplas maneiras de realizar uma tarefa, pois isso pode levar à confusão e inconsistência.

Exemplo Prático:

# Múltiplas maneiras
if condicao:
    return True
else:
    return False

# Uma maneira óbvia
return condicao

Embora quebra de simplicidade seja preferível à duplicação de complexidade

Dica:

Se necessário, prefira quebrar a simplicidade do código a introduzir complexidade duplicada.

Exemplo Prático:

# Quebrando a simplicidade
resultado = 0
for numero in numeros:
    resultado += numero * 2

# Duplicando a complexidade
resultado = sum(numero * 2 for numero in numeros)

Os casos especiais não são especiais o suficiente para quebrar as regras

Dica:

Mantenha suas regras consistentes e evite criar exceções desnecessárias.

Exemplo Prático:

# Quebrando a regra
if len(lista) == 0:
    print("Lista vazia!")

# Boa prática
if not lista:
    print("Lista vazia!")

Agora é melhor do que nunca

Dica:

Não deixe a busca pela perfeição impedir o progresso. É melhor começar agora e refinar posteriormente.

Exemplo Prático:

# Perfeição inicial
def funcao():
    pass

# Comece agora, refinar posteriormente
def funcao():
    return None

Embora nunca seja muitas vezes melhor do que certo agora

Dica:

É melhor tomar uma decisão acertada agora do que adiar a ação indefinidamente.

Exemplo Prático:

# Adiando a ação
if condicao:
    return True

# Tomando a decisão agora
if condicao:
    return True
else:
    return False

Se a implementação é difícil de explicar, é uma má ideia

Dica:

Prefira soluções simples e intuitivas em vez de complicar desnecessariamente.

Exemplo Prático:

# Complicado
def funcao(a, b):
    if a and b:
        return True
    elif not a and not b:
        return False
    else:
        return None

# Simples
def funcao(a, b):
    return a and b

Se a implementação é fácil de explicar, pode ser uma boa ideia

Dica:

Soluções simples e claras tendem a ser mais fáceis de entender e manter.

Exemplo Prático:

# Complexo
def funcao(lista):
    resultado = 0
    for item in lista:
        resultado += item
    return resultado

# Simples
def funcao(lista):
    return sum(lista)

Namespaces são uma ótima ideia — vamos ter mais dessas!

Dica:

Use namespaces para evitar conflitos de nomes e organizar melhor o seu código.

Exemplo Prático:

# Sem namespaces
from math import *

# Com namespaces
import math

Continue praticando e explorando os recursos do Python e quem sabe, utilize o que for possível do zen do python em outras linguagens para aprimorar ainda mais suas habilidades como desenvolvedor! 👍