Olá, Cod3rs! Vocês sabiam que o Python tem um conjunto de princípios chamado “O Zen do Python”?

Nesse artigo, vamos discutir sobre the Zen of Python, uma coleção de 19 aforismos que capturam a filosofia por trás do design e da legibilidade do Python.

Os principios exploram conceitos como legibilidade, simplicidade e a importância de um código bem estruturado. Saber como aderir a esses princípios pode tornar seu código escrito em Python mais elegante, fácil de manter e ‘Pythonico.’

Princípio 01:

Bonito é melhor que feio.

Esse princípio enfatiza a importância de escrever um código que seja visualmente agradável e fácil de ler, isso automaticamente o torna mais fácil de manter e entender.

Vejamos um exemplo prático:

# Código feio
a = 5;b=3;print(a+b)

# Código bonito
a = 5
b = 3
print(a + b)

Princípio 02:

Explícito é melhor que implícito.

Esse princípio salienta que é melhor ser claro e explícito em seu código, em vez de depender de comportamento implícito ou oculto.

Deixar suas intenções claras ajuda a melhorar a legibilidade do código e reduz as chances de confusão quando outras pessoas forem ler algo que você escreveu:

x = 5
y = 3.14

result = x + y  #implicitamente adicionando um int a um float

print(result)  # Output: 8.14 (resultado float)

ao invés, prefira:

x = 5
y = 3.14

result = float(x) + y  # explicitamente convertendo o int x para um float antes da adição 

print(result)  # Output: 8.14 (resultado float)

Princípio 03:

Simples é melhor que complexo.

A simplicidade é valorizada em Python. Escrever um código direto e fácil de entender é mais preferível a soluções complexas e complicadas.

Código simples é mais fácil de manter e menos sujeito a erros.

# Código complexo
numeros = [1, 2, 3, 4, 5]
numeros_quadrado = []
for num in numeros:
   numeros_quadrado.append(num ** 2)


print(numeros_quadrado)  # Output: [1, 4, 9, 16, 25

No código acima, temos uma lista de números e queremos criar uma nova lista chamada numeros_quadrado que contenha os quadrados de cada número na lista original. A implementação envolve inicializar uma lista vazia, iterar sobre os números, calcular o quadrado de cada número e anexá-lo à nova lista.

Agora, vamos simplificar o código usando comprehension:

# Código simples
numeros = [1, 2, 3, 4, 5]
numeros_quadrado = [num ** 2 for num in numeros]


print(numeros_quadrado)  # Output: [1, 4, 9, 16, 25]

Princípio 04:

Complexo é melhor que complicado.

Embora a simplicidade seja incentivada, é reconhecido que às vezes a complexidade é necessária.

Porém, é importante diferenciar entre a complexidade decorrente da natureza do problema e as complicações desnecessárias que podem ser evitadas.

# Codigo complicado
if x > 0:
   if y > 0:
       faca_algo()
   else:
       faca_outra_coisa()
else:
   faca_outra_coisa_diferente()

Ao invés disso, prefira:

# Codico complexo
if x > 0 and y > 0:
   faca_algo()
elif x > 0 and y <= 0:
   faca_outra_coisa()
else:
   faca_outra_coisa_diferente()

Princípio 05:

Linear é melhor que aninhado.

Esse princípio promove a escrita de código com menos níveis de indentação e aninhamento.

Estruturas de código lineares são geralmente mais fáceis de compreender e manter em comparação com estruturas profundamente aninhadas:

# Codigo aninhado
if condicao1:
   if condicao2:
       faca_algo()


# Codigo linear
if condicao1 and condicao2:
   faca_algo()

Princípio 06:

Esparso é melhor do que denso.

Ou seja, não tente “amontoar” tudo na mesma linha.

O código que é espaçado e permite espaço suficiente para respirar entre as instruções é preferível ao código densamente compactado.

# Codigo denso
resultado = a+b+c+d

# Codigo esparso
resultado = a + b + c + d

O uso adequado de espaços em branco, quebras de linha e recuo melhora a legibilidade do código.

Princípio 07:

Legibilidade conta.

A legibilidade do código é altamente valorizada em Python.

O código deve ser escrito de forma clara, compreensível e facilmente interpretado por humanos e outros desenvolvedores.

O exemplo do terceiro principio serve aqui tambem, e outro exemplo interessante seria:

# Codigo menos legivel
x = x + 1

# Codigo mais legivel
x += 1

Princípio 08:

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

Esse princípio sugere que, mesmo em casos especiais ou cenários excepcionais, é importante aderir às regras e aos princípios gerais de codificação.

Consistência e aderencia dos padrões são fundamentais. Nenhum caso é tão especial ao ponto de passar por cima das regras!

Princípio 09:

Embora a praticidade supere a pureza.

Embora aderir às melhores práticas seja importante, a praticidade e as considerações do mundo real devem ter considerações maiores sobre seguir cegamente regras rígidas.

É muito importante encontrar um equilíbrio entre soluções ideais e implementações práticas.

Vejamos um exemplo prático:

# Codigo complexo
def calcular_media(numeros):
   total = sum(numeros)
   quantidade = len(numeros)
   if quantidade == 0:
       return 0
   else:
       return total / quantidade

grades = [80, 90, 85, 92, 78]
media = calcular_media(grades)
print(media)  # Output: 85.0

No código acima, temos uma função calcular_media que calcula a média de uma lista de números. No entanto, há uma verificação desnecessária da quantidade da lista para evitar a divisão por zero.

Embora isso garanta a pureza ao lidar com o caso extremo, ele também deixa o código mais complexo.

Agora, vamos simplificar o código aproveitando a praticidade das funções integradas (famoso built-in) do Python:

# Codigo simples
notas = [80, 90, 85, 92, 78]
media = sum(notas) / len(notas) if notas else 0
print(media)  # Output: 85.0

Nesta versão simplificada, usamos a função sum() para calcular a soma das notas e dividir ela pela quantidade da lista utilizando len(). Ao utilizar uma expressão condicional (if notas) antes de fazer a divisão, lidamos com o caso de lista vazia de uma maneira melhor.

Ou seja, embora seja importante buscar pureza e elegância em nosso código, também devemos considerar abordagens práticas que simplifiquem nosso código sem comprometer sua funcionalidade e legibilidade.

Princípio 10:

Os erros nunca devem passar silenciosamente.

Quando ocorrem erros no código, eles devem ser tratados e relatados adequadamente. Ignorar ou esconder erros pode levar a um comportamento inesperado no seu código.

Princípio 11:

A menos que explicitamente silenciado.

(Funciona como uma continuação do principio anterior)

Embora os erros devam ser tratados, pode ser que tenha situações em que silenciar explicitamente um erro é necessário e acaba sendo intencional.

Porém, é importante lembrar que tais casos devem ser claramente documentados e justificados.

# Silenciando todos os erros
try:
   resultado = x / y
except:
   pass

# Silenciando erros especificos
try:
   resultado = x / y
except erroDivisaoPorZer0:
   pass

Princípio 12:

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

Diante de situações ambíguas, é melhor ser explícito e evitar fazer suposições. Clareza e precisão são vitais para a compreensão e manutenção do código.

Ou seja, caso se depare com um código que possa dar um erro “se” tal coisa acontecer, prefira ser explicito pois eventualmente tais suposições vão acontecer.

Princípio 13:

Deve haver uma – e de preferência apenas uma – maneira óbvia de fazer isso.

Python promove uma maneira única, clara e óbvia de realizar tarefas. Isso reduz a confusão entre os desenvolvedores e ajuda a manter um estilo de desenvolvimento consistente entre os projetos.

# código complexo
def encontrar_max(numeros):
   maximo = numeros[0]
   for numero in numeros:
       if numero > maximo:
           maximo = numero
   return maximo

numeros = [5, 2, 8, 1, 9, 4]
maximo = encontrar_max(numeros)
print(maximo) # Output: 9

Aqui, temos uma função que encontra o maior número em uma lista de números. Para simplificar o código e aderir ao princípio de ter uma maneira óbvia, podemos utilizar a função built-in max() em Python:

# codigo simples
numeros = [5, 2, 8, 1, 9, 4]
maximo = max(numeros)
print(maximo)  # Output: 9

Princípio 14:

Embora esse caminho possa não ser óbvio a princípio, a menos que você seja holandês.

Esse princípio apenas brinca com o fato que o criador do Python, Guido van Rossum, é holandês e sugere com humor que algumas escolhas podem fazer mais sentido se você também for.

Princípio 15:

Agora é melhor do que nunca.

É melhor agir e progredir em vez de esperar ou pensar demais.

Escrever um código imperfeito que funcione é preferível a não escrever nenhum código. Você pode ir implementando ele e aos poucos e transformar em algo pythonicamente bonito.

Principio 16:

Embora nunca seja frequentemente melhor do que agora.

Esse princípio completementa o anterior.

Embora seja importante tomar medidas de uma vez, também é importante considerar a qualidade e a correção do código.

Não faça algo só por fazer. Ficar com pressa para entregar uma solução sem uma consideração cuidadosa pode levar a bugs e outros problemas.

Princípio 17:

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

Quando o código é excessivamente complexo ou difícil de explicar, é um sinal de que a implementação pode não ser ideal.

É importante buscar escrever um código intuitivo e que seja autoexplicativo.

Princípio 18:

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

Por outro lado, se o código puder ser facilmente explicado e compreendido, isso é um ótimo sinal e significa que sua implementação será bem projetada.

Código simples e claro é mais suscetível a manutenção e menos sujeito a erros.

Princípio 19:

Namespaces são uma ótima ideia — vamos fazer mais deles!

Este princípio destaca a importância de organizar o código em namespaces e módulos. Em python, eles dão mais simplicidade ao código e o torna mais legível, além de reduzir os conflitos de nomenclatura e aprimorar a reutilização do código.

Conclusão

Neste artigo, vimos como aderir aos princípios do Zen de Python pode te ajudar a aprimorar suas práticas de desenvolvimento, melhorar a colaboração e fazer parte de uma comunidade que valoriza simplicidade, clareza e elegância. Aprimorando assim a arte de escrever um código ‘Pythonico’.