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)