The Zen of Python

Beautiful is better than ugly
"Bonito é melhor que feio"

if funcao(x) && y == 0 || z == 'yes':

if funcao(x) and y == 0 or z == 'yes':

Explicit is better than implicit
"Explícito é melhor que implícito"

import os
print os.getcwd()

from os import *
print getcwd()

Simple is better than complex
"Simples é melhor que complexo"

import sqlalchemy
import sqlalchemy.types as sqltypes

def gravar(dados):
    db = sqlalchemy.create_engine('sqlite:///dados.db')
    db.echo = False
    metadata = sqlalchemy.MetaData(db)
        table = sqlalchemy.Table('dados', metadata,
        sqlalchemy.Column('id', sqltypes.Integer, primary_key=True),
        sqlalchemy.Column('peso', sqltypes.Float),
        sqlalchemy.Column('cor', sqltypes.String(32)),
    )
    table.create(checkfirst=True)

    for dado in dados:
        i = table.insert()
        i.execute(**dados)

import json

def gravar(dados):
    with open('dados.json', 'w') as f:
        f.write(json.dumps(dados))

Complex is better than complicated
"Complexo é melhor que complicado"

import MySQLdb

def gravar(dados):
    db = MySQLdb.connect(user='usuario', passwd="senha", host='localhost', db="dados")

    c = db.cursor()
    c.execute("""
        CREATE TABLE IF NOT EXISTS dados
        id int(11) NOT NULL auto_increment,
        peso float,
        cor varchar(32)
        PRIMARY KEY id
        ENGINE=InnoDB CHARSET=utf8
    """)

    insert_sql = (
        "INSERT INTO dados (peso, cor) "
        "VALUES (%s, %s, %s)")

    for dado in dados:
        c.execute(insert_sql,
            (dado['peso'], dado['dor'])
        )

Flat is better than nested
"Linear é melhor do que aninhado"

if i > 0: 
    return funcao(i) 
elif i == 0: 
    return 0 
else: 
    return 2 * funcao(i)

if i>0: return funcao(i) 
elif i==0: return 0 
else: return 2 * funcao(i)

Sparse is better than dense
"Esparso é melhor que denso"

Readability counts
"Legibilidade conta"

public class ClassePrincipal {
    public static void main(String[] args) {
        System.out.println("Olá pythonistas!");
    }
}

print("Olá pythonistas!")

Special cases aren't special enough to break the rules. Although practicality beats purity
"Casos especiais não são especiais o bastante para quebrar as regras. Ainda que praticidade vença a pureza"

Errors should never pass silently. Unless explicitly silenced
"Erros nunca devem passar silenciosamente. A menos que sejam explicitamente silenciados"

try:
    x = funcao(y)
except:
    pass

try:
    x = funcao(y)
except:
    print("Deu ruim!")

In the face of ambiguity, refuse the temptation to guess
"Diante da ambiguidade, recuse a tentação de adivinhar"

There should be one- and preferably only one -obvious way to do it. Although that way may not be obvious at first unless you’re Dutch
"Deveria haver um - e preferencialmente apenas um - modo óbvio para fazer algo. Embora esse modo possa não ser óbvio a princípio a menos que você seja holandês"

Now is better than never. Although never is often better than right now
"Agora é melhor que nunca. Embora nunca freqüentemente seja melhor que já."

If the implementation is hard to explain, it’s a bad idea
"Se a implementação é difícil de explicar, é uma má idéia"

If the implementation is easy to explain, it may be a good idea
"Se a implementação é fácil de explicar, pode ser uma boa ideia"

Namespaces are one honking great idea - let’s do more of those!
"Namespaces são uma grande ideia - vamos ter mais dessas!"

import modelos.cachorro as cachorro
import modelos.gato as gato

def funcao():
    cachorro.perseguir(gato)