Livro grátis: “Python para Desenvolvedores”!

Há alguns dias atrás fui informado do lançamento (sob licença CC) de um livro sobre Python chamado Python para Desenvolvedores. Para quem não conhece Python, ou ainda está iniciando nessa excepcional linguagem, trata-se de um excelente recurso de aprendizado, apresentando uma infinidade de exemplos e mostrando, na prática, um pouco do que pode ser feito com ela. Congratulações ao autor, Luiz Eduardo Borges!

Não deixe de baixar o livro e, claro, aprender Python. O único problema é que você provavelmente não irá querer olhar para trás…

Errata

O livro ainda é bem novo, por isso é meio óbvio que existem ajustes a serem feitos. Por isso, para ajudar a tornar o livro ainda melhor, eu resolvi dar a minha humilde contribuição.

Como infelizmente eu não consegui contato com o autor do livro, resolvi publicar aqui os erros que eu encontrei no mesmo.

Página 21

Creio que a explicação dos operadores lógicos and e or está simples demais, considerando que o público-alvo do livro é de desenvolvedores, ou seja, pessoas com um pouco mais de experiência na área. Trecho:

and: retorna verdadeiro se e somente se receber duas expressões que forem verdadeiras.

Na verdade, o operador and não retorna verdadeiro ou falso. Se ambos os operandos são valores considerados verdadeiros, ele retorna o último operando avaliado. Do contrário, ele retorna o primeiro operando considerado falso:

'' and True # Retorna: ''
0 and ''    # Retorna: 0
1 and True  # Retorna: True
True and 1  # Retorna: 1

A mesma idéia vale para o operador or. Trecho:

or: retorna falso se e somente se receber duas expressões que forem falsas.

Este operador também não retorna valores literais de verdadeiro ou falso, e sim o primeiro operando considerado verdadeiro ou o último considerado falso se não existirem operandos verdadeiros:

False or "" # Retorna: ''
True or 1   # Retorna: True
0 or 1      # Retorna: 1
False or [] # Retorna: []

Na minha opinião, desenvolvedores Python devem saber que os operadores and e or têm essas propriedades. Isso até ajuda a deixar os códigos mais “pythonicos”. Um exemplo (idiota, mas enfim) seria:

# Versão não muito pythonica
def not_so_good(**kwargs):
    params = kwargs
    if not kwargs:
        params = {'default': 1234}
    print params
 
not_so_good()         # Imprime: {'default': 1234}
not_so_good(a=1, b=2) # Imprime: {'a': 1, 'b': 2}
 
# Versão um pouco melhor
def good(**kwargs):
    params = kwargs or {'default': 1234}
    print params
 
good()         # Imprime: {'default': 1234}
good(a=1, b=2) # Imprime: {'a': 1, 'b': 2}

Páginas 27, 30, 75, 131, 140

Em vários lugares o autor diz que X é mais eficiente que Y, mas não especifica em que especificamente essa eficiência se traduz: menor consumo de memória, processamento mais rápido, coisas do tipo. Seria legal saber em que exatamente X é mais eficiente que Y.

Página 39

No 7o item da lista, faltou um espaço após a vírgula.

Página 92

Trecho:

Na herança múltipla, a nova classe deriva de várias classes já existentes. A diferença mais significativa em relação à herança simples é a ordem de resolução de métodos (em inglês, Method Resolution Order- MRO), que segue o chamado algoritmo diamante. No algoritmo diamante, a resolução será feita a partir da esquerda, descendo até encontrar a classe em comum entre os caminhos dentro hierarquia. Quando encontra a classe em comum, passa para o caminho à direita. Ao esgotar os caminhos, o algoritmo prossegue para a classe em comum e repete o processo.

A herança múltipla funciona de forma diferente em classes clássicas e classes de estilo novo. A “resolução diamante”, onde a pesquisa de herança é estritamente profunda primeiro, depois da esquerda para direita, é usada somente em classes clássicas. Nas classes de estilo novo, a pesquisa de herança é feita da esquerda para direita primeiro, depois em profundidade:

# Hierarquia de "classes clássicas"
class A: attr = 1
class B(A): pass
class C(A): attr = 2
class D(B, C): pass
 
d = D()
d.attr # Retorna: 1
 
# Hierarquia de "classes de estilo novo"
class A(object): attr = 1
class B(A): pass
class C(A): attr = 2
class D(B, C): pass
 
d = D()
d.attr # Retorna: 2

O código mostra claramente que, dependendo do tipo de classe (clássica ou de estilo novo), a resolução do atributo attr é feita de forma diferenciada.

Bom, por enquanto é isso! Espero que o autor leve esses pontos em consideração para fazer do livro Python para Desenvolvedores um livro ainda melhor!