Publicado por

Valdir Stumm Jr

Postado no

11 de março de 2013

Publicado em

estruturas, misc, oo

comentários

2 Comentários

Os métodos mágicos de Python

Obs.: Códigos testados com a versão 2.7 do Python.

Quem está chegando em Python normalmente fica um pouco confuso ao ler o código de uma classe e perceber um monte de métodos com underscores (__) no nome. Para entender o que são esses métodos, vamos ver um exemplo.

Uma classe para números binários

Suponha que, por algum motivo, você receba a tarefa de implementar uma classe para representação de números em base binária.

class Binario(object):

    def __init__(self, valor_dec):
        self.valor_dec = valor_dec
        self.valor_bin = bin(self.valor_dec)  #bin() é uma função builtin

b = Binario(5)
print b

Se executarmos o código acima, teremos em b um objeto do tipo Binario, que representa o valor 5 em base-2. 5 em base binária é 101. Porém, a execução da linha print b mostrou a seguinte saída na tela:


<__main__.Binario object at 0x28286d0>

Isso porque o print executa a função str() no objeto recebido. Essa função, por sua vez, procura por um método chamado __str__() no objeto a ser impresso. Como não definimos um método com esse nome em nossa classe, o interpretador continua sua busca pelo método na classe que está acima de Binario na hierarquia de classes, que é object. Lá ele encontra o método __str__, que então retorna o texto <__main__.Binario object at 0x28286d0>, contendo o endereço do objeto na memória.

O método __str__() deve retornar uma representação em forma de string do valor do objeto. Para personalizar essa mensagem, ou seja, para fazer com que o print em objetos do tipo Binario mostre uma sequência de 0s e 1s representando o número binário em questão, vamos adicionar um método __str__() à nossa classe:

class Binario(object):

    def __init__(self, valor_dec):
        self.valor_dec = valor_dec
        self.valor_bin = bin(self.valor_dec)

    def __str__(self):
        return "%s" % (self.valor_bin)

b = Binario(5)
print b

Agora, o resultado da execução do código acima é o seguinte:

0b101

Que é o formato retornado pela função bin() quando chamada. O prefixo 0b é adicionado para indicar que se trata de um número binário. Podemos facilmente nos livrar desse prefixo para representar o número binário na tela usando operadores de slicing:

def __str__(self):
    return "%s" % (self.valor_bin[2:])

Beleza! Agora nosso número binário pode ser impresso corretamente na tela! 🙂

Sem perceber e sem chamá-los em lugar algum, já utilizamos dois métodos mágicos de Python:

__init__: método chamado para inicialização do objeto, logo após a sua construção;
__str__: método chamado pela função str() para obter o valor do objeto em forma de string;

Chamamos eles de métodos mágicos porque eles resolvem o nosso problema sem sequer termos que chamá-los. Quem os chama são códigos de outras classes/programas, que esperam que nossos objetos forneçam tais métodos.

E se agora quisermos comparar objetos do tipo Binario em operações relacionais como >, <, >=, <=, != e ==? Se tentarmos comparar duas instâncias de Binario usando algum desses operadores, podemos ter respostas inesperadas, visto que eles não irão fazer o que esperamos. O esperado é que a > b retorne True se o valor de a for maior do que o valor de b. Porém, onde definimos qual valor será usado para comparação dos objetos? Como não fizemos isso, o interpretador irá usar o id de ambos os objetos para a comparação.

Para definir como os objetos de nossa classe serão comparados, podemos implementar o método mágico __cmp__. Na documentação oficial, vemos instruções sobre como implementar esse método para que nossos objetos possam ser comparados e usados em operações relacionais:

object.__cmp__(self, other) Deve retornar um inteiro negativo se self < other, zero se self == other, ou um número positivo se self > other.

Vamos então implementar o nosso método __cmp__. Podemos, para isso, usar o valor em decimal, que armazenamos internamente na variável self.valor_dec:

def __cmp__(self, other):
    if self.valor_dec > other.valor_dec:
        return 1
    elif self.valor_dec < other.valor_dec:
        return -1
    else:
        return 0

Que poderia também ser escrito como:

def __cmp__(self, other):
    return self.valor_dec - other.valor_dec

Tendo adicionado o código acima à classe Binario, agora podemos utilizar nossos objetos em operações relacionais:

b = Binario(1)
c = Binario(2)
if b < c:
    print "OK"

Mais uma vez, nosso método é executado sem que o chamemos explicitamente. Além dos métodos que vimos aqui, existem vários outros métodos mágicos que podemos implementar em nossos objetos para que o comportamento deles se pareça mais com o comportamento de objetos nativos da linguagem. Vou listar alguns deles a seguir:

__add__(self, other): para adicionarmos a possibilidade de aplicação do operador + aos nossos objetos. Para os outros operadores, também existem métodos mágicos (subtração(-): __sub__; multiplicação(*): __mul__, divisão(/): __div__, módulo(%): __mod__, potência(**): __pow__);
__call__(self): faz com que o objeto seja chamável (executável), assim como uma função é;
__len__: retorna o comprimento do objeto (se for um container);
__getitem__(self, key): para containers, retorna o elemento correspondente à chave key;

São muitos os métodos. Se você quiser conhecê-los melhor, sugiro dar uma olhada nesse texto (em inglês): http://www.rafekettler.com/magicmethods.html.

Os métodos mágicos (magic methods), também chamados de métodos dunderscore (double-underscore) ou de métodos especiais, são muito úteis pois permitem que objetos de nossas classes possuam uma interface de acesso semelhante aos objetos nativos da linguagem. A função sorted(), por exemplo, ordena os elementos de um iterável de acordo com o valor dos objetos que a compõe. Se definirmos nosso método de comparação, a função sorted() irá usá-lo para fazer a ordenação dos elementos da lista. Assim, é possível que códigos de terceiros lidem com nosso código sem sequer conhecê-lo. Veja mais sobre esse conceito em: Polimorfismo.

Publicado por

Valdir Stumm Jr

Postado no

1 de março de 2013

Publicado em

comentários

1 comentário

Entendendo “tudo é objeto em Python”

Nessa última semana, li um excelente post sobre o modelo de execução do Python escrito pelo Jeff Knupp e tive vontade de escrever sobre um assunto que é tratado por ele no post: muita gente fala que em Python tudo é um objeto, mas nem todos entendem o que isso realmente significa. Vou tentar ilustrar aqui com um exemplo que acho bem interessante, que é a declaração de classes.

A palavra reservada class

Antes de ler o livro Learning Python, eu tinha uma ideia um pouco distorcida sobre classes em Python. Para mim, a palavra class tinha um quê de mágica envolvida. Com a leitura, aprendi que class é um construtor de objetos, e não somente uma declaração existente no código. Isso porque class é executada pelo interpretador quando encontrada no código, e o resultado dessa execução é um novo objeto existente no escopo do módulo. A diferença deste para um construtor qualquer, é que este constrói objetos do tipo type, permitindo assim que criemos objetos desse tipo recém criado. Vamos ver um exemplo rápido no interpretador:

>>> class Teste(object): pass
>>> print type(Teste)
<type 'type'>

Talvez você esteja pensando: “grande coisa, é a mesma coisa que em outras linguagens orientadas a objetos que já usei…”. Mas se acalme aí, pois o melhor ainda está por vir. Tendo criado o objeto Teste com a declaração class, agora podemos acessá-lo como qualquer outro objeto. Podemos acrescentar atributos à classe:

>>> Teste.x = 0
>>> print Teste.x
0
>>> t1 = Teste()
>>> print t1.x
0

Perceba que acrescentamos o atributo x ao objeto Teste, e que isso faz com que instâncias dessa classe passem a possuir esse atributo. E aí, você fazia isso em Java? Isso permite que, por exemplo, adicionemos métodos a uma classe já existente:

>>> def funcao(self): print 'valor de x:', self.x
>>> Teste.f = funcao
>>> t2 = Teste()
>>> t2.f()
valor de x: 0

Como a palavra def também cria objetos (do tipo function), podemos manipular funções como se fossem outros objetos quaisquer. Preste atenção à linha 2 do trecho acima (Teste.f = funcao) e perceba que não estamos fazendo uma chamada à função funcao. O que fizemos foi criar um atributo f em Teste, e então fizemos com que esse atributo referencie o objeto funcao, que incidentalmente é um objeto “executável”, um objeto function. Assim, todas as instâncias de Teste passam a ter também uma função f em seu escopo.

Feito isso, peço que releia os trechos de código acima e depois, diga se a seguinte linha de código irá funcionar ou não:

>>> t1.f()

O que você acha? A resposta é: a linha acima é executada com sucesso e a saída na tela de sua execução é mostrada abaixo:


valor de x: 0

Algo estranho? Perceba que t1 foi instanciado antes de adicionarmos o método f à classe Teste. Como ele incorporou esse método? Para entender isso, é preciso entender o modelo de resolução de nomes e hierarquia de objetos em Python.

Hierarquia de classes

Quando criamos uma classe, como fizemos com o objeto Teste, estamos criando um objeto que descende de object, que é um objeto do tipo type e que possui vários atributos e métodos que são herdados pelas classes descendentes. Ao criarmos uma instância de Teste, como t1 e t2, estamos criando objetos que descendem de Teste, e por transitividade, descendem também de object. Veja a imagem abaixo:

Essa é a hierarquia existente em tempo de execução em Python. Sempre que tentamos acessar um atributo de um objeto, o interpretador faz o seguinte: verifica se o objeto em questão possui tal atributo; caso não possua, verifica se o objeto que está imediatamente acima na hierarquia possui tal atributo, e faz isso sucessivamente até encontrar ou chegar a object. Se chegar em object e nem ele possuir o atributo procurado, ocorre um AtributeError. Isso é feito para cada acesso a atributos, em tempo de execução. Isso explica o porquê de t1.f() ter funcionado corretamente, mesmo t1 tendo sido criado antes de termos adicionado f a Teste. O que ocorre é bem simples: ao tentar acessar t1.f(), o interpretador busca por f em t1 e não encontra. Assim, busca por f no objeto imediatamente acima de t1, que é Teste, o encontra lá e executa o código do objeto.

Interessante, não? 🙂

Variáveis, valores e referências

Já vi muita gente tendo problemas em código Python simplesmente por não entender direito como Python lida com os conceitos de variáveis. Considere o exemplo abaixo:

>>> x = [1, 2, 3]
>>> y = x
>>> x.append(4)
>>> print y
************

Qual o resultado esperado pela execução da última linha (print y)? Se você ficou na dúvida, mesmo que por um curto período de tempo, leia este post até o fim, que você irá entender melhor.

Nome

Grave o seguinte:

Em Python, uma variável é apenas um NOME que REFERENCIA a um OBJETO.

Veja o exemplo abaixo:

>>> x = 42

O código acima é muitas vezes lido como “atribui o valor 42 à variável x”. Mas, o que Python faz é o seguinte: cria um objeto do tipo int que possui 42 como valor, cria o nome x e faz com que o nome x referencie o objeto (do tipo int) 42. Assim, toda vez que o nome x for usado em seu código, ele será automaticamente substituído pelo valor do objeto que este nome referencia (42). A imagem abaixo ilustra melhor a relação entre x e 42.

Continuando o exemplo anterior, o que acontece se fizermos o seguinte?

>>> x = x + 1

É simples, o nome x passa a fazer referência a um novo objeto do tipo int, cujo valor é 43.

A imagem a seguir dá uma idéia melhor sobre o que acontece.

Objetos do tipo int são imutáveis. x = x + 1 cria um novo objeto do tipo int (cujo valor é determinado pela soma de x com 1) e faz com que x passe a referenciar esse novo objeto. Se você observar a imagem acima, verá que não há mais seta alguma apontando para o valor 42, isto é, não há mais nenhum nome fazendo referência àquele objeto. Normalmente, um objeto que não possui nome algum o referenciando vira candidato a coleta de lixo, que é um mecanismo que elimina da memória objetos que não são mais necessários. Mas, o interpretador Python não realiza esse processo em objetos do tipo int e do tipo str (quando pequenos). Ao invés disso, ele mantém esses objetos em uma espécie de cache, para não ter que recriá-los em um futuro próximo e a todo momento em que forem necessários. Se quiser confirmar isso:

>>> 42 is 42  # ambos são o mesmo objeto
True
>>> 'ola' is 'ola'
True
>>> [] is []  # o mesmo já não vale para listas
False

Como comentei anteriormente, toda vez que um nome de variável aparece em uma expressão, esse nome é substituído pelo valor do objeto ao qual ele faz referência. Sabendo disso, considere a expressão abaixo:

>>> y = x

O interpretador cria um novo nome y e faz com que ele referencie o objeto referenciado por x, como mostra a figura abaixo:

Agora, o que acontece se fizermos o seguinte?

>>> x = 10

É criado um objeto int com valor 10, e x então passa a referenciar a esse novo objeto.

Tá, e daí?

E daí que entendendo isso tudo, você achará mais natural alguns comportamentos em Python. Por exemplo, teste o seguinte código e tente entender o que acontece:

>>> x = [1, 2, 3]
>>> y = x
>>> x.append(4)
>>> print x
[1, 2, 3, 4]
>>> print y
[1, 2, 3, 4]

Como mostra a imagem abaixo, y = x faz com que y passe a referenciar o mesmo objeto que x referencia.

Assim, x.append(4) tem efeito sobre o objeto referenciado agora pelas duas variáveis (x e y).

Isso ocorre porque listas, em Python, são objetos mutáveis. O método append() modifica a lista de modo in-place, isto é, as modificações são feitas no próprio objeto, sem a necessidade de criação de uma nova lista, como ocorreria com objetos imutáveis, como strings ou ints, por exemplo.

Mutável vs Imutável

Vamos ver agora um exemplo da diferença entre um objeto mutável (lista) e um objeto imutável (string). Temos dois objetos, l e s:

>>> l = [1, 2, 3]
>>> s = 'abc'

Queremos adicionar um novo elemento ao fim de cada um deles. Com a lista podemos usar o método append():

>>> l.append(4)

Que adiciona o valor 4 ao final de l, modificando-a. Com a string, não temos esse método disponível, então vamos usar o operador de concatenação:

>>> s = s + 'd'

O lado direito da expressão acima cria uma nova string com o conteúdo de s acrescido do caractere 'd' e faz com que o nome s passe a referenciar essa nova string. Ou seja, ao invés de modificar, foi criado um novo objeto. O antigo valor de s ('abc') passa então a ficar sem referência alguma a ele.

Quem é quem?

Para confirmar se duas variáveis referenciam o mesmo objeto, podemos usar o operador de identidade is que verifica se duas variáveis possuem como valor o mesmo objeto.

>>> x = [1, 2, 3]
>>> y = x
>>> x is y
True

Outra forma de verificar se duas variáveis se referem ao mesmo objeto é usando o comando id(), que retorna o identificador do objeto, que nada mais é do que um número inteiro que cada objeto possui para ser unicamente identificado:

>>> print id(x)
30008456
>>> print id(y)
30008456

Tanto x quanto y se referem ao objeto com o identificador 30008456, isto é, ao mesmo objeto ([1, 2, 3]).

Agora, se o que você deseja é fazer uma cópia do objeto lista, de modo que uma modificação na cópia não interfira no objeto original, existem algumas formas de fazer isso: usando o operador de fatiamento (slicing) ou o método copy(), disponível no módulo copy.

>>> x = [1, 2, 3]
>>> y = x[:] # cria uma nova lista com todo conteúdo de x e atribui a y
>>> x is y
False
>>> import copy
>>> y = copy.copy(x)
>>> x is y
False

Perceba que o método copy.copy() faz apenas o que chamamos de cópia rasa da lista, pois se a lista em questão possuir outras listas aninhadas, estas não serão copiadas, sendo somente suas referências copiadas. Para cópias profundas, use copy.deepcopy().

Passagem de parâmetros

Outra confusão muito comum é a passagem de parâmetros para funções. Veja o exemplo abaixo e tente descobrir o resultado da execução:

def func(x, y):
    x = x + 1
    y.append(4)

x = 1
y = [1, 2, 3]
func(x, y)
print 'x:', x
print 'y:', y

(Pare por um momento se for necessário antes de seguir a leitura e analise o código acima para descobrir o resultado.)

O resultado pode ser visto abaixo:

x: 1
y: [1, 2, 3, 4]

A função func recebeu dois argumentos. De forma leiga, poderíamos dizer que ambos sofreram alterações dentro da função, mas somente na lista a alteração persistiu fora do escopo da função. Isso tem uma explicação bem clara: para qualquer objeto passado para uma função, é feita uma cópia da referência do objeto para o escopo local da função. Assim, se o objeto for mutável, uma operação como append(), por exemplo, vai afetar o objeto referenciado pela variável e assim a alteração persiste fora do escopo da função. Com um objeto imutável, não é possível alterar o objeto em si. O que se faz é alterar a referência (x = x + 1, por exemplo). Como a referência é apenas uma cópia, qualquer alteração feita sobre ela não irá ter efeito na referência do escopo de fora. Por isso, x permanece referenciando o mesmo objeto (1) no escopo global após a função ter terminado.

Resumindo: para entender o comportamento da passagem de parâmetros em Python, basta entender a diferença entre objetos mutáveis e imutáveis, e também lembrar que toda variável em Python nada mais é do que uma referência para algum objeto da memória.

Além disso, é conveniente deixar de lado um pouco aquela noção de que x = x + 1 (ou operações parecidas) altera(m) o objeto. Lembre sempre que o lado direito da expressão (x + 1) cria um novo objeto e que o lado esquerdo da expressão (x =) faz com que o nome x passe a referenciar o novo objeto. Mais nada. 🙂

Pronto!

O conceito de variáveis e objetos em Python é bem simples e consistente. Fique atento ao seu código, principalmente quando você precisa realizar cópias de objetos, o que em Python não é feito usando o operador =. Ah, não se esqueça outras linguagens implementam esses conceitos de formas diferentes. Veja: Other languages have “variables”… Python has “names” .

Publicado por

Valdir Stumm Jr

Postado no

26 de janeiro de 2013

Publicado em

estruturas

comentários

1 comentário

Simplificando as coisas com namedtuples

Antes de conhecer e até mesmo nos primeiros projetos que desenvolvi usando Python, era bem comum que eu escrevesse classes que não continham método algum (a não ser os famigerados getters/setters e o construtor). Elas eram normalmente usadas para representar objetos que tinham um papel mais passivo, como por exemplo, uma classe para representar as mensagens que o cliente passava para o servidor:

class Message(object):
    headers = []
    content = None
    from_addr = None
    to_addr = None

Ou então:

class Message(object):
    def __init__(self, content, from_addr, to_addr):
        self.headers = []
        self.content = content
        self.from_addr = from_addr
        self.to_addr = to_addr

    def add_header(self, info):
        self.headers.append(info)

Além disso, eu definia os setters/getters para cada atributo (muitas vezes sem pensar se iria precisar deles ou não, afinal, a maioria das IDEs já geravam tudo pra mim).

Mas aos poucos veio a sensação de que eu estava subutilizando Python criando classes somente para representação de objetos simples assim. Afinal, além de ser uma linguagem com tipagem dinâmica, Python ainda oferece várias estruturas para representação dos dados. Minha primeira idéia foi utilizar tuplas para representar os objetos a serem trocados entre os elementos. Por exemplo, poderia representar uma mensagem através de uma tupla de 4 elementos:

message = ([], content, from_addr, to_addr)

Assim, para imprimir o conteúdo da mensagem, eu teria que fazer:

print message[1]

Assim, seria sempre necessário saber em qual posição da tupla determinado campo está armazenado. Um atentado à legibilidade e manutenção do código! Depois, pensei em usar dicionários:

message = {'headers': [], 'content': content, 'from_addr': from_addr, 'to_addr': to_addr}

Feito! O problema da legibilidade tinha acabado. Agora eu poderia acessar o campo content usando o nome do campo como chave:

print message['content']

Mas, ainda não me parecia uma solução muito adequada. Foi então que veio a luz: descobri a namedtuple, que faz parte do pacote collections. O próprio Guido Van Rossum, criador da linguagem Python, recomendou recentemente o uso de namedtuples para representação de objetos. Além de evitar a sobrecarga sintática que a definição de uma classe dá ao código, ela também oferece melhor desempenho.

Usando as namedtuples

A definição de estruturas para representação de objetos com namedtuples é bem simples. Veja o exemplo abaixo:

>>> import collections
>>> Message = collections.namedtuple('Message', 'headers content from_addr to_addr')

A segunda linha acima mostra a criação de uma namedtuple que chamamos de Message, e que possui 4 campos: headers, content, from_addr e to_addr. O primeiro argumento que passamos para a factory namedtuple() é o nome para o novo tipo (em nosso caso, Message) e o segundo argumento é uma string contendo os nomes dos campos da estrutura, separados por espaços em branco ('headers content from_addr to_addr'). A chamada à collections.namedtuple() retorna uma nova subclasse de tuple, podendo assim ser usado como se fosse um novo tipo.

Tendo a estrutura definida, podemos então criar objetos do tipo Message da seguinte forma:

>>> m = Message([], "Hello, server!", "me", "some.address.com")

A partir daí, o acesso aos campos da mensagem é feito exatamente como faríamos com instâncias de classes que definimos:

>>> print m.content
Hello, server!
>>> m.headers.append("alguma informação")
>>> print m.headers
["alguma informação"]
>>> m.to_addr = "localhost"
>>> print m.to_addr
localhost

Barbadinha, né? A partir de agora, quando for criar uma nova classe para representação de algo em seu projeto, verifique se não é o caso de definir o novo tipo usando namedtuples ao invés de uma nova classe. Se for possível, use a namedtuple. Mas, nem sempre uma namedtuple será suficiente para representar determinados objetos. Nesses casos, as classes são a solução mais adequada.

Publicado por

Valdir Stumm Jr

Postado no

10 de janeiro de 2013

Publicado em

estruturas

comentários

3 Comentários

Desempacotamento de tupla

Tuple unpacking, ou em bom português, desempacotamento de tupla. Tá aí algo que usamos pra caramba, mas sobre o qual pouco ouvimos falar. Desempacotar uma tupla pode ser explicado como o ato de atribuir os elementos dela individualmente a outros objetos. Veja um exemplo de desempacotamento de tupla:

>>> t = (1, 2, 3, 4)
>>> a, b, c, d = t  # "desempacotando" uma tupla
>>> print b * c
6

No exemplo acima, o primeiro elemento da tupla t é atribuído para o nome a. O segundo elemento de t é atribuído para b, e assim por diante. É óbvio que, para desempacotar uma tupla, é necessário que tenhamos no lado esquerdo da expressão a quantidade necessária de variáveis para receber os valores. Veja uma situação que gera um erro por tentarmos desempacotar uma tupla de 4 elementos para 3 variáveis:

>>> t = (1, 2, 3, 4)
>>> a, b, c = t
Traceback (most recent call last):
  File "", line 1, in
ValueError: too many values to unpack

"ValueError: too many values to unpack", que significa “valores demais para desempacotar".

Mas isso é útil para quê?

Já viu uma função retornando mais de um valor em um único return em Python?

def f(x):
    return x, x*2, x*3

valor, dobro, triplo = f(2)

Isso é algo bastante comum em código Python. O código da segunda linha (return x, x*2, x*3) na realidade retorna apenas um valor, que é uma tupla. A expressão x, x*2, x*3 cria uma tupla de 3 elementos, apesar de não estar envolta em parênteses. Assim sendo, a chamada de função f(2) retorna uma tupla de 3 valores, que são então desempacotados para as variáveis valor, dobro e triplo, respectivamente.

Percorrendo listas de tuplas

Quando temos uma lista contendo tuplas, podemos percorrê-la assim como qualquer outra lista. Veja:

>>> lista = [(1, 2, 3), (2, 4, 6), (4, 8, 12), (8, 16, 24)]
>>> for tupla in lista:
...     print tupla
...
(1, 2, 3)
(2, 4, 6)
(4, 8, 12)
(8, 16, 24)

Dentro do for, poderíamos desempacotar os valores de cada tupla, se precisássemos usá-los individualmente:

>>> lista = [(1, 2, 3), (2, 4, 6), (4, 8, 12), (8, 16, 24)]
>>> for tupla in lista:
...     a, b, c = tupla
...     print a * b * c
...
6
48
384
3072

Mas, poderíamos fazer melhor, desempacotando os elementos dentro da expressão do for:

>>> lista = [(1, 2, 3), (2, 4, 6), (4, 8, 12), (8, 16, 24)]
>>> for (a, b, c) in lista:
...     print a * b * c
...
6
48
384
3072

Poderíamos também omitir os parênteses na hora de desempacotar as tuplas:

>>> lista = [(1, 2, 3), (2, 4, 6), (4, 8, 12), (8, 16, 24)]
>>> for a, b, c in lista:
...     print a * b * c
...
6
48
384
3072

Mas nem tudo interessa

Considere que nas tuplas da lista lista acima, somente nos interessa o primeiro elemento de cada tupla. Para não precisar criar dois novos nomes (b e c) que nunca serão usados, podemos utilizar um idioma que é um tanto comum em código python: usar o caractere de undescore _ como o nome da variável que vai receber o primeiro e último valores das tuplas:

>>> lista = [(1, 2, 3), (2, 4, 6), (4, 8, 12), (8, 16, 24)]
>>> for a, _, _ in lista:
...     print a * 2
...
2
4
8
16

Lembre-se: usamos isso somente em casos em que os elementos não serão necessários no escopo do for.

O _ é utilizado comumente como um nome para não me interessa. Por exemplo*, em uma tupla contendo nome, sobrenome e apelido, em um momento em que estamos interessados apenas no nome e no sobrenome, poderíamos usar o _ para indicar que o apelido não é importante neste momento:

dados_pessoais = ('Joao', 'Silva', 'joaozinho')
...
nome, sobrenome, _ = dados_pessoais

*Exemplo adaptado dessa resposta no StackOverflow.com

Como o autor da resposta no link acima comenta, é preciso tomar cuidado com o uso do _, pois ele também é utilizado em outros contextos e isso pode gerar confusão e mau-funcionamento. Ele é bastante usado com a biblioteca de internacionalização gettext como um atalho para funções usadas com muita frequência.

Então é isso. O desempacotamento de tuplas é um dos recursos que eu considero mais legais em Python, pois elimina bastante código desnecessário. Até a próxima! 🙂

Publicado por

Valdir Stumm Jr

Postado no

31 de dezembro de 2012

Publicado em

misc

comentários

1 comentário

Deu erro! E agora, o que eu faço?

Traceback (most recent call last):
  File "novo.py", line 12, in <module>
    hello()
  File "novo.py", line 10, in hello
    monta_lista(10)
  File "novo.py", line 5, in monta_lista
    return x[max]
IndexError: list index out of range

Se você sente calafrios só de ver a mensagem de erro acima, este post é para você. Você já ficou p*** da vida com o interpretador porque aquele programa recém escrito, perfeitinho, começou a apresentar mensagens de erro indecifráveis? Vá com calma, na maioria esmagadora dos casos, a culpa não é do interpretador, da linguagem, do sistema operacional ou do hardware. A culpa é quase sempre sua! (lembre-se sempre disso). Frases como “esse compilador está errado!” são muito comuns nos momentos de frustração, mesmo para programadores experientes. Mas caia na real, o compilador/interpretador só está fazendo o trabalho dele, o errado da história, em geral, é você*.

No momento de desespero, quando você não está entendendo o que está acontecendo para que o seu programa tenha problemas, é preciso que você conheça os mecanismos adequados para simplificar a tarefa de descobrir os problemas em seu código. Neste post nós vamos ver como podemos proceder para facilitar a descoberta de erros no nosso código. Vamos começar pelo basicão: como encontrar e identificar o erro em nosso código.

*É claro que não é impossível que você realmente tenha encontrado algum defeito no compilador ou no sistema operacional, mas esgote todas as possibilidades antes de partir para tal hipótese.

Entendendo melhor as mensagens de erro do Python

O traceback é a informação que o interpretador Python fornece para nos ajudar a identificar o problema em nosso código. Ele contém algumas informações úteis:

a sequência de chamadas de funções até o ponto onde ocorreu o problema;
o número da linha onde o erro foi gerado;
o tipo de erro que ocorreu, bem como uma pequena mensagem informativa sobre o ocorrido.

Às vezes o traceback parece meio enigmático, mas você verá que é bem fácil de entendê-lo. Vejamos um exemplo de um traceback bem simples:

Traceback (most recent call last):
  File "erro1.py", line 4, in <module>
    print (z+y)/x
ZeroDivisionError: integer division or modulo by zero

Mesmo sem olhar o código que o gerou, já podemos extrair algumas informações úteis:

o erro foi gerado na linha 4 do arquivo erro1.py;
o erro que ocorreu é chamado de ZeroDivisionError, indicando que ocorreu uma tentativa de dividir um valor por zero;
o código da linha que gerou o problema é print (z+y)/x

Olhando agora para o código-fonte do programa que gerou o erro acima, podemos identificar logo o erro:

1  x = 0
2  y = 10
3  z = 3
4  print (z+y)/x

Tá na cara, estamos dividindo um valor por x, sendo que x é zero. Divisão por zero é uma indefinição matemática e nem o computador sabe lidar com isso.

Outro exemplo

Agora você está escrevendo um programinha que vai manipular uma lista com valores aleatórios.

#! -*- encoding:utf-8 -*-
from random import shuffle
TAM = 5
lista = range(TAM)
shuffle(lista)
print 'Primeiro:', lista[0]
print 'Último:', lista[TAM]

Ao executar, se depara com o seguinte saída, incluindo um traceback:

Primeiro: 3
Último:
Traceback (most recent call last):
  File "/home/user/src/erro2.py", line 7, in <module>
    print 'Último:', lista[TAM]
IndexError: list index out of range

Perceba que as duas primeiras linhas acima fazem parte da saída gerada pelo seu programinha. Vamos agora encontrar e identificar o erro:

De acordo com o traceback, o erro foi gerado na linha 7 do nosso arquivo. Essa é a última linha (print 'Último:', lista[TAM]).
Outra informação muito importante na saída apresentada acima é o tipo de erro que ocorreu: IndexError: list index out of range (adaptado em pt-br: Erro de índice: índice fora da faixa da lista). O IndexError significa que estamos tentando acessar alguma posição da lista que vai além do tamanho dela. Por exemplo, em uma lista de dez elementos, você não pode acessar o décimo-primeiro elemento, pois ele não existe. Se você tentar, vai receber um IndexError na cabeça.

Agora você já tem alguma informação sobre o que pode estar acontecendo: é na última linha e é algum problema relacionado a acesso a posições inexistentes da lista.

Vamos, antes de mais nada lembrar rapidinho como se dá a indexação de listas (e outras sequências) em Python. Veja a lista abaixo, e seus respectivos índices:

lis
+-----+-----+-----+-----+-----+
|  2  |  9  |  6  |  8  |  7  |
+-----+-----+-----+-----+-----+
   0     1     2     3     4

Você já sabe que o índice para acesso ao primeiro elemento da lista lis é 0. Para imprimir o primeiro elemento, você faria print lis[0]. Sabendo que o primeiro índice é 0, fica óbvio que o último não é o tamanho da lista, mas sim o tamanho da lista – 1. Ou seja, em uma lista de 5 elementos (como lis), para imprimir o último elemento, você deve utilizar print lis[4] ao invés de print lis[5]. Agora reveja o traceback e o código-fonte do programa e descubra o erro. 😛

Mais um exemplo

Agora você vai fazer um programa para montar e imprimir URLs de acordo com os parâmetros de protocol, host e path. Veja abaixo o exemplo:

def URL(protocol, host, path):
    return protocol + "://" + host + "/" + path 

def print_urls():
    print URL('http', 'www.example.com', 'path/to/file.html')
    print URL('ftp', 'www.example.com', 'path/to/file.html')
    print URL('http', 'www.example.com', 2)

print_urls()

Porém, pra variar, ao executar, lá vem o maldito traceback (apesar de odiá-lo, acredite, seria muito pior sem ele).

http://www.example.com/path/to/file.html
ftp://www.example.com/path/to/file.html
Traceback (most recent call last):
File "/home/user/src/erro3.py", line 11, in <module>
  print_urls()
File "/home/user/src/erro3.py", line 8, in print_urls
  print URL('http', 'www.example.com', 2)
File "/home/user/src/erro3.py", line 2, in URL
  return protocol + "://" + host + "/" + path 
TypeError: cannot concatenate 'str' and 'int' objects

E agora, o que diabos está acontecendo? Primeiramente, você deve tentar entender a saída do programa. Veja que as duas primeiras linhas indicam que as duas primeiras tentativas de impressão de URLs ocorreram com sucesso. Então, mesmo sem olhar o traceback, você já imagina que algo ocorreu de errado na terceira URL (que deveria mostrar http://www.example.com/2). Analise o traceback, seguindo o procedimento que vimos anteriormente (encontrar onde pode estar o erro e então identificá-lo, para depois corrigí-lo).

A antepenúltima linha do traceback diz que o erro está na linha 2, na função URL (File "/home/user/src/erro3.py", line 2, in URL). A linha 2 é return protocol + "://" + host + "/" + path. Mas peraí, se você olhar o traceback de cima para baixo, verá que ele aponta várias linhas como fontes do erro: 11, 8 e 2. Observe que ele mostra o rastro (trace) de chamadas de funções que levaram ao código com defeito. Como o próprio traceback nos mostra, ocorreu a seguinte chamada de funções que levou ao erro apresentado acima:

print_urls()  -->  print URL('http', 'www.example.com', 2)  -->  return protocol + "://" + host + "/" + path 
    11                                 8                                                2

Talvez você não esteja conseguindo descobrir o erro. Então, vamos analisar mais uma informação do traceback: o tipo do erro. De acordo com o que foi apresentado na última linha do erro, temos um erro do tipo TypeError (erro de tipagem), com a mensagem de erro: cannot concatenate 'str' and 'int' objects (não é possível concatenar objetos dos tipos ‘str’ e ‘int’). Ou seja, estamos em algum lugar passando um número inteiro para ser concatenado às strings que são utilizadas para compor a URL. Agora ficou moleza, pois na linha 8 estamos passando o argumento 2 (um valor do tipo int) para o parâmetro path da função URL() (que é usado nessa função para ser concatenado a valores do tipo str). Para corrigir é fácil, basta substituir o 2 do tipo inteiro pelo '2' do tipo string. A linha 8 ficaria assim:

print URL('http', 'www.example.com', '2')

Mas às vezes os erros não estão tão explícitos assim, e somente analisar o traceback não é o suficiente para descobrirmos o problema de nosso código. Então teremos que partir para outras abordagens, como veremos a seguir.

(Se você quiser conhecer os principais erros e exceções que podem ocorrer em Python, consulte a documentação oficial.)

Muito além do traceback

Muitas vezes é preciso que analisemos a execução do programa em questão. Essa análise envolve descobrirmos os valores que as variáveis estão assumindo e quais caminhos no código o programa está percorrendo durante sua execução. A forma mais comum que existe para fazermos isso e que para muitos é a solução definitiva para o problema, é encher o código de prints, mostrando assim no console os valores das variáveis, para que possamos ver se o programa está se comportando da forma desejada. Existem outras formas também, usando ferramentas específicas, que permitem que o programa seja pausado, executado linha por linha e inspecionado. Tanto o uso dos prints quanto o uso de ferramentas específicas é chamado de depuração de código (debugging, eliminação de bugs).

O print

Quem nunca encheu o código de prints para tentar entender o que está se passando no programa atire a primeira pedra. Acaba que essa é a solução mais natural para o cara que está iniciando. A regra é simples: imprima o valor das variáveis que lhe interessam, principalmente em pontos como entradas de expressões condicionais (if-elif-else); antes, durante e depois da execução de um laço de repetição (for, while); antes e depois da chamada de uma função que modifica valores de nossas variáveis; e em toda situação que ficamos na dúvida sobre o que está acontecendo com nossas variáveis.

Veja um exemplo do uso de prints para depurar um programa:

x = 0
x = faca_algo_com(x)
print 'pre-while: %s' % (x, )
while x > 0:
    x = faca_algo_com(x)
    if x % 2 == 0:
        x += 1
    print 'while: %s' % (x, )
print 'pos-while: %s' % (x, )

No exemplo acima, usamos 3 prints para termos melhor entendimento do que está acontecendo durante a execução do programa. Em programas que já lançam muitos valores na saída padrão, pode ser útil lançar as mensagens de depuração na saída padrão de erros do shell, para que possamos, se preciso for, analisá-las em separado do resto do programa:

import sys
x = 0
x = faca_algo_com(x)
sys.stderr.write('pre-while: %s\n' % (x, ))
while x > 0:
    x = faca_algo_com(x)
    if x % 2 == 0:
        x += 1
    sys.stderr.write('while: %s\n' % (x, ))
sys.stderr.write('pos-while: %s\n' % (x, ))

Mas, tenha cuidado, pois às vezes o excesso de informações vai atrapalhar mais do que ajudar.

Os loggers

Uma alternativa interessante aos prints é o uso de loggers. O log de um programa é, em geral, um objeto no qual registramos informações, para uma possível análise posterior. Em geral, utilizamos o log para registro da ocorrência de eventos durante a execução de um programa. A ideia principal é basicamente a mesma do que usar os prints, mas na prática existem várias vantagens no uso de um logger.

O recurso mais interessante dos loggers é a possibilidade de “categorizar” as informações que vamos jogando na tela, de acordo com o seu grau de importância. Por exemplo, o mecanismo de logging padrão do Python possui 5 níveis: DEBUG, INFO, WARNING (nível padrão), ERROR e CRITICAL. Veja o exemplo:


import logging

logging.debug('depurando ...')
logging.info('informando ...')
logging.warning('alertando ...')
logging.error('assustando ...')
logging.critical('apavorando ...')

Se o programa acima for executado, a saída será:

WARNING:root:alertando ...
ERROR:root:assustando ...
CRITICAL:root:apavorando ...

Perceba que as duas primeiras linhas do logging não foram refletidas na saída do programa. Isso porque o nível padrão do logger é o warning, o que significa que somente mensagens de warning e de categorias mais importantes (no caso, error e critical) serão impressas.

Usando o logger, podemos incluir várias mensagens de depuração no código, e ativar seu aparecimento na saída do programa somente quando tivermos interesse.

Veja mais em: http://docs.python.org/2/library/logging

O debugger

Depuradores são ferramentas feitas para auxiliar o desenvolvedor a descobrir falhas em seu código. Eles permitem que executemos um programa passo-a-passo, que a cada passo inspecionemos as variáveis, que verifiquemos em que seção do código está a execução do programa, além de outros recursos. Para mim, o melhor dos recursos é poder inspecionar os valores aos quais as variáveis referenciam durante a execução passo-a-passo do programa.

O depurador que vamos ver em seguida é o pdb, que é o depurador padrão distribuído com Python. Basta que executemos o depurador, informando a ele qual o programa que queremos depurar. Por exemplo, para depurar um programa chamado prog.py, invocamos o pdb
da seguinte forma (em um shell do sistema operacional):

$ python -m pdb prog.py

Teste você mesmo, baixando o arquivo prog.py. Veja na imagem a seguir um exemplo de execução de um programa usando o pdb:

Ao iniciar a execução, o depurador para e aguarda por comandos do usuário, que podem ser: execute a atual e pule para a próxima linha, entre dentro da função, mostre o valor de uma variável/expressão, mostre o código fonte, etc.

Alguns comandos úteis do pdb:

list: mostra um trecho do código em execução, com destaque para a linha atual;
next: comando que indica ao pdb que ele deve seguir para a próxima linha de execução, sem adentrar em funções quando houverem chamadas;
step: indica ao pdb para que ele siga em frente, entrando na função se a linha atual for uma chamada de função;
pp <nome_de_variável>: mostra na tela o valor referenciado pela variável nome_de_variável.

A seguir, vou apresentar um processo de depuração, para que você entenda melhor do que se trata e como podemos fazê-lo. Vamos testar um programa que faz a multiplicação de dois valores através de sucessivas somas:

def multiplica(x, y):
  result = 0
  while y > 0:
      result = result + x
      y = y - 1
  return result

z = 10
k = 2
r = multiplica(z, k)
print r

Veja o vídeo abaixo, onde demonstro uma pequena sessão de depuração do programa acima:

Como você pode perceber, o mais interessante do uso do depurador é a análise detalhada que é possível que façamos enquanto o programa está em execução. No vídeo, inspecionamos os valores de variáveis (com o comando pp), verificamos o código em execução do programa (o list mostra a linha em execução atualmente, bem como algumas linhas acima e abaixo), passamos de linha em linha (usando o comando next) e até mesmo entramos em funções, para verificar o que é feito dentro delas (com o comando step). Normalmente, é disso que se trata uma sessão de depuração, uma análise do programa em execução, inspeção de valores, verificação de caminhos percorridos pela execução no código do programa. Assim, o programador pode obter boas pistas sobre o problema que está enfrentando.

A seguir, uma tabela contendo os principais comandos do pdb e suas funcionalidades:

Comando	Atalho	Uso
help	h	Mostra a ajuda do comando.
break x	b	Insere um breakpoint na linha x, um ponto de parada, até o qual o programa será executado sem interatividade. A partir dali, a execução fica sob o controle do usuário do depurador.
step	s	Prossegue a execução até a próxima linha de código, inclusive entrando em funções.
next	n	Parecido com step, mas executa chamadas a funções como comandos comuns, sem entrar nelas.
pp exp	pp	Imprime o valor da expressão exp, podendo exp ser uma simples variável ou uma expressão complexa.
quit	q	Fecha o depurador

Mais comandos em: http://docs.python.org/2/library/pdb.html#debugger-commands

Veja mais sobre o pdb em (em inglês):

Breakpoints

Para que você não precise excutar o programa todo, linha por linha, next por next, desde o começo até o ponto que lhe interesse, você pode usar um breakpoint. Um breakpoint é um ponto de parada, de forma que o programa é executado normalmente (sem interatividade) até o momento em que encontrar o breakpoint. A partir dali, o depurador passa a aguardar pelos comandos do usuário. Breakpoints são muito úteis, pois em geral estamos interessados na depuração de somente um trecho do código, onde desconfiamos que esteja ocorrendo o erro.

winpdb

Se você prefere um ambiente gráfico, vários IDEs fornecem a integração com depurador na sua interface. Basta escolher um IDE e usar a depuração sempre que for preciso.

Mas, se você não quiser usar um IDE só por isso, você pode utilizar o winpdb, que é um depurador gráfico para Python. Em uma janela só, você vê o código, uma marcação indicando a linha em execução, uma tabela contendo todas as informações que estão no escopo local e global, além de suportar avaliação de expressões, e até mesmo, mudanças nos valores das variáveis do programa em tempo de execução.

No vídeo a seguir eu mostro um exemplo de execução de um programa usando o winpdb:

Enfim…

Se você sofre muito para encontrar os problemas existentes no seu código, aprenda a usar um depurador, seja ele gráfico ou em texto, e se acostume a usá-lo. Usar um depurador acaba sendo muito mais eficiente do que encher o código com prints, pois ele permite que paremos a execução em um determinado ponto, que alteremos valores, e que analisemos com mais calma a execução do programa, tendo sempre uma visão melhor do estado atual deste.

Atenção: os códigos apresentados neste post foram elaborados com o único propósito de mostrar uma situação em que erros podem ocorrer. Assim, de forma alguma eles podem ser considerados exemplos de boas práticas.

Publicado por

Valdir Stumm Jr

Postado no

27 de novembro de 2012

Publicado em

banco de dados, misc

comentários

7 Comentários

Armazenando senhas de forma segura

Dica ao leitor: não deixe de ler a seção “O mecanismo correto”.

Diga aí, você anota a senha do seu email em um post-it e deixa ele colado em seu monitor, visível a qualquer um? Aposto que não, pois seria muito fácil para alguém acessar sua conta e mandar emails engraçadinhos para seus contatos. Da mesma forma que você protege sua senha, os aplicativos que utilizam informações de login e senha para autenticar usuários (como o seu serviço de email) também devem cuidar das senhas armazenadas neles, não devendo nunca guardá-las em texto puro. Vamos ver nesse post como funciona a autenticação, e as melhores práticas para implementar esse serviço na sua aplicação de forma razoavelmente segura.

Autenticação

Você já parou para pensar em como funciona a autenticação em um serviço de email? Primeiro, você digita o seu nome de usuário e senha em um formulário web, como o exemplo abaixo:

Usuário: pythonhelp
  Senha: *******

Esses dados são então enviados para o servidor que está fornecendo o serviço de autenticação do seu email. Lá dentro, o serviço de autenticação irá procurar por um usuário chamado pythonhelp no banco de dados de usuários. Se encontrá-lo, irá realizar uma comparação (mais para frente veremos que não é uma simples comparação de duas strings) para verificar se a senha fornecida no formulário web corresponde à senha do usuário. Em caso positivo, a autenticação ocorre com sucesso e você pode então acessar sua conta de email. Em caso negativo, aquela mensagenzinha chata avisando que você errou seu nome de usuário ou sua senha aparece na tela. (A propósito, você já percebeu que a maioria dos serviços não informa se o que erramos foi o nome de usuário ou se foi a senha? Esse tipo de informação é usualmente interessante para um invasor em potencial.)

Deixando de lado alguns detalhes, a autenticação funciona basicamente da forma descrita acima. Antes de vermos como isso tudo poderia ser implementado, veremos como NÃO deve ser implementado um serviço de autenticação.

Como NÃO implementar autenticação

Vamos desenvolver o serviço de autenticação para a nossa aplicação. Para isso, criamos uma tabela no banco de dados chamada USUARIOS, que contém duas informações sobre cada usuário: seu nome de usuário e sua senha. Como você pode ver abaixo, armazenamos a senha dos usuários em texto puro, ou seja, as senhas estão visíveis a qualquer pessoa que obtiver acesso ao banco de dados.

+--------------+
| USUARIOS     |
+--------------+------------------------+
|    NOME      |        SENHA           |
+--------------+------------------------+
| joaozinho    | teste                  |
+--------------+------------------------+
| pedrinho     | teste123               |
+--------------+------------------------+
| maria        | t35t3                  |
+--------------+------------------------+

Para fazer a autenticação, basta que o usuário forneça a sua senha e que comparemos a senha fornecida com a que está armazenada no BD.

Isso até funciona, mas eu é que não forneceria a minha senha para um sistema meia-boca desses que vai armazená-la em texto puro no banco de dados. Sabe por quê? Porque uma vez que alguém obtenha acesso ao banco de dados do sistema, basta isso para quebrar a privacidade de todos os usuários:

user@host:~/$ sqlite usuarios.db
sqlite> select * from usuarios;
joaozinho|teste
pedrinho|teste123
maria|t35t3

Que coisa, não? As senhas estão expostas. Falha de segurança gravíssima! Sabendo que a maioria dos usuários usa a mesma senha para os logins em vários sites, dá pra ter uma idéia do estrago né?

Lição número 1: JAMAIS ARMAZENE SENHAS EM TEXTO PURO!

Um jeito melhor

Agora que você já sabe como não fazer, vamos ver uma forma um pouquinho melhor (ainda não a correta) de implementar um mecanismo de autenticação.

Dessa vez nós não vamos armazenar as senhas dos usuários no BD. O que vamos armazenar é uma informação relacionada à senha e gerada a partir dela, o chamado hash da senha.

O que é o Hash?

O hash de um valor é o resultado da aplicação de uma função de hashing a tal valor. Esse resultado é, em geral, muito diferente do valor original. Uma função de hashing H recebe como entrada um valor x e retorna como resultado o hash h correspondente àquele valor:

H(x) -> h

Vamos calcular o hash do valor 'teste123':

H('teste123') -> 'aa1bf4646de67fd9086cf6c79007026c'

Vamos agora calcular o hash do valor 'teste12':

H('teste12') -> '0940004e70ce8d82b440d3c1244dfdee'

Vamos calcular novamente o hash do valor 'teste123':

H('teste123') -> 'aa1bf4646de67fd9086cf6c79007026c'

Agora vamos aplicar a função de hash ao valor 'aa1bf4646de67fd9086cf6c79007026c' (que é o hash de 'teste123'):

H(‘aa1bf4646de67fd9086cf6c79007026c’) -> ‘0728a200630cec4b33e33e20646bc54a’

Observando com atenção, você pode notar algumas coisas sobre as funções de hash:

A função de hash gera um resultado cujo valor é muito diferente do valor original.
Quando alteramos levemente o valor de entrada para a função de hash, o valor retornado por ela muda completamente (veja os exemplos de aplicação nas entradas 'teste123' e 'teste12'). Isso é chamado de efeito avalanche.
Quando aplicamos H novamente à entrada 'teste123', obtivemos o valor idêntico ao obtido pela primeira vez. Ou seja, a função de hash é determinística.
O último exemplo nos mostra que uma função de hash não é reversível, isto é, dado o hash de um valor, não conseguiremos descobrir o valor original através desse hash.

A partir das observações acima, podemos inferir algumas propriedades que as funções de hash possuem:

É improvável (muito improvável mesmo) que você modifique a entrada da função sem modificar o resultado dela.
É impossível gerar o valor de entrada a partir do resultado.
É muito difícil (muito mesmo) encontrar dois valores para os quais a função de hashing produza o mesmo resultado.
Sempre que aplicada ao mesmo valor x, uma mesma função H(x) irá retornar o mesmo resultado h.

* Nos exemplos acima, usei o algoritmo de hashing MD5, embora existam vários outros que poderiam ser igualmente usados, como SHA-1, SHA-256, etc.

Autenticação com hash

Conhecendo as propriedades acima, podemos criar um mecanismo de autenticação mais seguro. O objetivo é armazenar as informações de senha de forma mais protegida, em vez de deixá-la exposta em texto puro.

A primeira idéia pode ser simplesmente armazenar apenas o hash da senha. Parece uma boa idéia, afinal, a propriedade 2 diz que se alguém roubar o valor do hash da sua senha, não conseguirá obter a senha propriamente dita, e a propriedade 4 nos possibilita verificar se a senha está correta comparando o hash do que o usuário digitou com o hash armazenado no banco de dados.

Veja abaixo como ficaria o nosso novo BD de usuários. Para cada usuário, armazenamos o hash da senha que ele forneceu no cadastro.

+-----------+
| USUARIOS  |                                  
+-----------+----------------------------------+
| NOME      |         HASH DA SENHA            |
+-----------+----------------------------------+
| joaozinho | 698dc19d489c4e4db73e28a713eab07b |
+-----------+----------------------------------+
| pedrinho  | aa1bf4646de67fd9086cf6c79007026c |
+-----------+----------------------------------+
| maria     | c7ac7410983dc7efbb2e5c062c515b7d |
+-----------+----------------------------------+

Quando o usuário quiser se autenticar no sistema, teremos em mãos a senha fornecida por ele na tela de login, mas não podemos compará-la diretamente ao valor armazenado no banco, pois o que está armazenado é o hash da senha. O serviço de autenticação deverá aplicar a função de hash sobre a senha fornecida pelo usuário e comparar o resultado com o que está armazenado no BD. Se o valor obtido for idêntico ao hash armazenado no banco de dados para aquele usuário, a autenticação ocorre com sucesso. Caso contrário, erro de autenticação.

Agora as senhas estarão um pouquinho mais seguras. Isso mesmo, somente um pouco, pois existem meios para descobrir o valor da senha original através do hash dela. A próxima seção vai descrever um pouco isso.

Ataques ao banco de dados de senhas (ou hashes delas)

Uma coisa que acontece com frequência é um sistema sofrer uma invasão e os invasores realizarem uma cópia do seu banco de dados. Considere que os invasores roubaram o seguinte banco de dados:

+-----------+
| USUARIOS  |                                  
+-----------+----------------------------------+
| NOME      |         HASH DA SENHA            |
+-----------+----------------------------------+
| joaozinho | 698dc19d489c4e4db73e28a713eab07b |  <-- hash de "teste"
+-----------+----------------------------------+
| pedrinho  | aa1bf4646de67fd9086cf6c79007026c |  <-- hash de "teste123"
+-----------+----------------------------------+
| maria     | 2a1bdbdad93b1081007abc4b419d8f0b |  <-- hash de "t35t3"
+-----------+----------------------------------+
|    ...    |               ...                |
+-----------+----------------------------------+

O que eles poderiam fazer com esses dados? De acordo com as propriedades que vimos sobre as funções de hashing, não seria possível extrair o valor original que gerou o hash, então você imaginaria que as senhas estariam seguras dessa maneira.

Teoricamente, sim. Mas agora imagine que o invasor (uma pessoa muuuuuuito paciente), de posse do hash da senha do usuário joaozinho (698dc19d489c4e4db73e28a713eab07b), comece a fazer alguns testes com valores comumente usados como senhas:

>>> import hashlib
>>> print hashlib.md5('123').hexdigest()
202cb962ac59075b964b07152d234b70
>>> print hashlib.md5('abcde').hexdigest()
ab56b4d92b40713acc5af89985d4b786
>>> print hashlib.md5('bla').hexdigest()
128ecf542a35ac5270a87dc740918404
>>> print hashlib.md5('teste').hexdigest()
698dc19d489c4e4db73e28a713eab07b

Opa! O invasor acabou de descobrir a senha do joaozinho (teste), pois o hash obtido para essa string é o mesmo hash que está armazenado para o joaozinho no BD. Se ele continuar testando valores que considera prováveis de serem usados como senha, ele pode, eventualmente, acabar fazendo:

>>> print hashlib.md5('teste123').hexdigest()
aa1bf4646de67fd9086cf6c79007026c

Então ele terá descoberto a senha do usuário pedrinho, pois o hash gerado para teste123 possui o mesmo valor que está armazenado para esse usuário. A esse tipo de ataque, chamamos de Ataque por força bruta.

Imagino que você esteja pensando que o invasor terá muito trabalho para descobrir a senha do usuário maria, testando milhões de possibilidades antes de chegar em t35t3. Pois é. Se ele for testando manualmente, dificilmente irá descobrir a senha. Mas imagine agora que o invasor tenha escrito um programa que gere uma tabela gigantesca contendo possíveis senhas e seus hashes:

+----------------------------------+---------------------+
|              HASH                |       SENHA         |
+----------------------------------+---------------------+
| ...                              | ...                 |
+----------------------------------+---------------------+
| 698dc19d489c4e4db73e28a713eab07b | teste               |
+----------------------------------+---------------------+
| e959088c6049f1104c84c9bde5560a13 | teste1              |
+----------------------------------+---------------------+
| 38851536d87701d2191990e24a7f8d4e | teste2              |
+----------------------------------+---------------------+
| 56c1056afb34f0d5ad809821d417a52b | t3st3               |
+----------------------------------+---------------------+
| 2a1bdbdad93b1081007abc4b419d8f0b | t35t3               |
+----------------------------------+---------------------+
| ...                              | ...                 |
+----------------------------------+---------------------+
| 128ecf542a35ac5270a87dc740918404 | bla                 |
+----------------------------------+---------------------+
| 14a310c18e7ee2627b3de4ff82b11e76 | bl4                 |
+----------------------------------+---------------------+
| ...                              | ...                 |
+----------------------------------+---------------------+

Tendo essa tabela pré-calculada, uma vez que o invasor esteja de posse do hash da senha da maria (2a1bdbdad93b1081007abc4b419d8f0b), basta pesquisar por esse hash na tabela de hashes. Se encontrar um registro que possua tal hash, basta obter a senha que o acompanha.

É evidente que essa tabela deve ser gigantesca, gigantesca mesmo, para conter uma boa quantidade de combinações de valores de senhas. Para “facilitar o trabalho”, invasores do mundo todo colaboram na criação e busca em tabelas desse tipo. Essas tabelas são conhecidas como Rainbow Tables.

Não só isso, os próprios usuários colaboram com os invasores, usando as mesmas senhas em vários lugares, ou usando palavras simples de adivinhar, de forma que bem antes duma tabela dessas cobrir todas as possibilidades de hash, ela já pode ser extremamente útil para os invasores.

Lição número 2: O HASH SOZINHO NÃO FAZ MILAGRE!

Evitando as Rainbow Tables

Para lidar com isso, existe uma técnica chamada de salgar senhas (tradução literal do inglês “salting passwords”), que consiste em adicionar um “temperinho” na senha antes de armazenar. A idéia é gerar uma string contendo alguns valores aleatórios e concatenar essa string à senha do usuário na hora gerar o hash. Assim, ao invés de tomar somente a senha do usuário como entrada, a função de hashing passa a tomar como entrada também a string aleatória (chamada de salt, ou sal). Esse sal também é armazenado no BD para que posteriormente seja possível que o serviço de autenticação realize a verificação.

O que isso traz de segurança para o sistema? Vamos visualizar uma tabela que armazena o nome do usuário, o hash da concatenação entre senha e sal, e o sal. A senha de cada usuário é a mesma senha mostrada lá no início do post.

+-----------+
| USUARIOS  |                                  
+-----------+----------------------------------+-----------+
| NOME      |       HASH DE (SENHA+SAL)        |    SAL    |
+-----------+----------------------------------+-----------+
| joaozinho | e3e923b2c0d3890270a2cb6d52b13bf6 |   h6ja8   |
+-----------+----------------------------------+-----------+
| pedrinho  | 046b8f04069efab205d9f7bcc099e3d3 |   5uoWB   |
+-----------+----------------------------------+-----------+
| maria     | 960e18e4dc393660fdf3caba8634f38e |   jtm7a   |
+-----------+----------------------------------+-----------+

Veja como foram gerados os hashes armazenados:

>>> print hashlib.md5('teste'+'h6ja8').hexdigest()
e3e923b2c0d3890270a2cb6d52b13bf6
>>> print hashlib.md5('teste123'+'5uoWB').hexdigest()
046b8f04069efab205d9f7bcc099e3d3
>>> print hashlib.md5('t35t3'+'jtm7a').hexdigest()
960e18e4dc393660fdf3caba8634f38e

Está achando estranho o fato de termos armazenado o sal em texto puro no BD? Pois é, se o invasor roubar nossa base, ele terá de lambuja o valor do sal. Mas isso não é um problema, pois o objetivo principal de salgarmos a senha é impossibilitar a utilização de rainbow tables, afinal a idéia principal por trás dessas tabelas é o cálculo prévio dos hashes de vários valores. Ao roubar o sal e o hash de uma senha, o invasor teria que recalcular toda a rainbow table para poder descobrir a senha do usuário. E essa tarefa é muito custosa.

Assim, se cada usuário possuir um sal diferente, a rainbow table terá que ser recalculada para cada usuário, tornando essa atividade praticamente impossível.

Considere que o invasor possui a rainbow table abaixo, bem como o hash (e3e923b2c0d3890270a2cb6d52b13bf6) e o sal (h6ja8) do usuário joaozinho (roubados da base de dados de usuários).

+----------------------------------+---------------------+
|              HASH                |       SENHA         |
+----------------------------------+---------------------+
| ...                              | ...                 |
+----------------------------------+---------------------+
| 698dc19d489c4e4db73e28a713eab07b | teste               |
+----------------------------------+---------------------+
| e959088c6049f1104c84c9bde5560a13 | teste1              |
+----------------------------------+---------------------+
| 38851536d87701d2191990e24a7f8d4e | teste2              |
+----------------------------------+---------------------+
| 507eb04c9c427e9f961e47a7204fac41 | teste3              |
+----------------------------------+---------------------+
| ...                              | ...                 |
+----------------------------------+---------------------+
| 128ecf542a35ac5270a87dc740918404 | bla                 |
+----------------------------------+---------------------+
| df5ea29924d39c3be8785734f13169c6 | blabla              |
+----------------------------------+---------------------+
| ...                              | ...                 |
+----------------------------------+---------------------+

Para obter a senha do usuário, o invasor terá que recalcular toda a tabela. Por exemplo, terá que calcular o hash de “testeh6ja8”, de “teste1h6ja8”, e assim por diante, até encontrar o hash correspondente. Considerando que ela pode ter zilhões de registros, essa é uma tarefa bastante demorada. Imagine recalcular toda a tabela para todas as possíveis combinações de valores no sal.

Perceba que o sal que utilizamos é bastante curto. Quanto mais longo for o sal, mais protegidas contra rainbow tables as senhas estarão, pois o número de combinações possíveis de valores para o sal aumentam exponencialmente.

Dessa forma, o sal derruba a maior força das rainbow tables, que é a busca rápida por elementos (que ocorre graças ao cálculo prévio dos valores). Ao usar valores de sal suficientemente longos, estamos aumentando MUITO (MUITO MESMO) a quantidade de entradas que uma rainbow table deve ter para servir como uma base de hashes pré-calculados (segundo a Wikipedia, hoje em dia são usados salts de até 128 bits). Se, além disso, usarmos um sal diferente para cada usuário, então tornamos impossível o uso de tabelas pré-computadas para a descoberta das senhas dos nossos usuários.

Mas, ainda assim, hashes salgados não são a solução definitiva para armazenamento de senhas. Leia a próxima seção para descobrir o porquê.

O mecanismo correto

Mesmo sendo um mecanismo muito mais seguro do que armazenando a senha em texto puro ou o hash simples, o armazenamento de hashes de senhas salgadas ainda não é a melhor solução. Apesar de amplamente utilizados, os algoritmos de hashing como MD5 e SHA-1 não são recomendados para o armazenamento de senhas, pois são bastante velozes para realizar o hashing de um valor. Um algoritmo rápido torna a geração de ataques via força bruta e rainbow tables mais fácil, pois o tempo necessário para gerar as tabelas acaba sendo pequeno.

Um algoritmo para uso no armazenamento de senhas tem como requisito ser lento. Lento o suficiente para atrapalhar o atacante, mas não o bastante para atrapalhar o usuário.

Uma forma recomendada de armazenar as senhas dos usuários é usando o bcrypt. O BCrypt é um mecanismo criptográfico criado para lidar com senhas. Assim sendo, uma de suas características é ser demorado para geração do hash.

Para ter uma idéia da diferença na velocidade dos dois mecanismos, observe o resultados de uns testes que fiz usando o timeit:

$ python -m timeit -s "import bcrypt; salt = bcrypt.gensalt()" "bcrypt.hashpw('teste', salt)"
10 loops, best of 3: 243 msec per loop

$ python -m timeit -s "import hashlib" "hashlib.md5('teste')"
1000000 loops, best of 3: 0.409 usec per loop

Enquanto o MD5 gera os hashes em uma média de 0.409 microsegundos por hash, o bcrypt leva em média 243 milisegundos por hash.

Instalando o bcrypt

A implementação Python do bcrypt não está disponível com a biblioteca-padrão, portanto é necessário instalá-la através do gerenciador de pacotes pip:

sudo pip install py-bcrypt

Obs.: o módulo é escrito em linguagem C, portanto o código será compilado. Para isso, é necessário possuir instalados (em sistema Ubuntu): build-essential e python-dev.

Alternativamente, num sistema Debian ou Ubuntu você pode instalar o pacote no repositório do apt:

sudo apt-get install python-bcrypt

Usando o bcrypt

Assim como a maioria dos módulos Python, o bcrypt é facinho de usar. Vamos fazer alguns exemplos.

Gerando o hash de uma senha

>>> import bcrypt
>>> print bcrypt.hashpw('teste123', bcrypt.gensalt())
$2a$12$axTaPizQ6q2V8VCLseqEq.Rwm1aZVx7oimvjPmmLWTNE3uW15xpIu

Execute o código acima no seu interpretador Python local e perceba a diferença no tempo de resposta entre o bcrypt e o MD5.

Verificando a senha do usuário

Para verificar se determinado hash é correto, devemos passá-lo como argumento para a função hashpw, juntamente com a senha:

>>> print bcrypt.hashpw("teste123", "$2a$12$axTaPizQ6q2V8VCLseqEq.Rwm1aZVx7oimvjPmmLWTNE3uW15xpIu")
$2a$12$axTaPizQ6q2V8VCLseqEq.Rwm1aZVx7oimvjPmmLWTNE3uW15xpIu

Se ela retornar o mesmo hash que foi passado como argumento, é porque o hash corresponde à senha passada como primeiro argumento.

Podemos então criar uma função de validação de senha de usuário:

def valida_senha(senha_digitada, hash_senha):
    return bcrypt.hashpw(senha_digitada, hash_senha) == hash_senha

Um sistema de autenticação usando BD

Vamos agora implementar um mecanismo para autenticação de usuários, usando sqlite3 e bcrypt.

# -*- encoding:utf-8 -*-
import bcrypt
import sqlite3

def valida_senha(senha_digitada, hash_senha):
    return bcrypt.hashpw(senha_digitada, hash_senha) == hash_senha

def insere_usuario(conexao, usuario, senha):
    hash_senha = bcrypt.hashpw(senha, bcrypt.gensalt())
    conexao.execute('insert into USUARIOS values ("%s", "%s")' % (usuario, hash_senha))
    conexao.commit()

def usuario_autenticado(conexao, usuario, senha):
    cursor = conexao.execute('select SENHA from USUARIOS where NOME = "%s"' % (usuario,))
    dados = cursor.fetchone()
    hash_senha = str(dados[0])
    return valida_senha(senha, hash_senha)

# alguns testes
if __name__=='__main__':
    conexao = sqlite3.connect('arquivo.db')
    insere_usuario(conexao, 'maria', 'teste')
    insere_usuario(conexao, 'joao', 'teste123')
    if usuario_autenticado(conexao, 'joao', 'teste123'):
        print 'joao está autenticado!'
    else:
        print 'Xiiiii...'

Antes de terminar …

O post mostrou quão simples é a implementação de um mecanismo seguro para armazenamento das senhas dos usuários em um banco de dados. Agora você não tem mais desculpas para implementar a autenticação usando senhas armazenadas em texto puro.

Se você armazena as senhas em texto puro, é fácil alterar seus algoritmos de autenticação e gerar os hashes das senhas existentes (faça backup antes, claro :)). Vale a pena gastar um tempinho corrigindo isso em seu sistema.

Finalizando, o py-bcrypt é tão simples de ser utilizado que me deixa à vontade para deixar como lição final:

LIÇÃO FINAL: USE O BCRYPT PARA ARMAZENAMENTO DE SENHAS DE USUÁRIOS!

LIÇÃO DEFINITIVA: NÃO SEJA RELAPSO COM AS INFORMAÇÕES DOS SEUS USUÁRIOS!

all() e any()

A linguagem Python é recheada de atalhos úteis, que não só facilitam nossa vida na hora de resolver problemas, mas que também fazem você pensar soluções de forma diferente. Este post é sobre duas funções Python que agem sobre listas de booleanos, e se revelam úteis na prática.

Imagine que você tenha uma lista de inteiros, e você precisa verificar se todos são pares. Você pode pensar: “Fácil, é só percorrer a lista, e verificar para cada elemento se ele é divisível por 2. Se algum não for, posso setar uma variável avisando que é falso e tá feito!” Tendo o raciocínio pronto, você senta o traseiro na cadeira e escreve um código tipo esse:

listaDeInteiros = [2, 6, 4, 7, -2]
todosSaoPares = True
for i in listaDeInteiros:
    if i % 2 == 0:
        todosSaoPares = False
        break
if todosSaoPares:
    print 'Todos sao pares'
else:
    print 'Tem algum impar'

E está ótimo, o código funciona numa boa, as variáveis estão claras, e tudo o mais. Todavia, com o passar do tempo você se dá conta que esse tipo de problema começa a repetir. Seguidamente você precisa verificar se uma condição é verdadeira (ou falsa) para os elementos de uma lista, e acaba fazendo muitas muitas versõezinhas parecidas desse código. Agora você pode precisar descobrir se todos os elementos de uma lista são inteiros positivos, e lá vai você de novo:

listaDeInteiros = [2, 6, 4, 7, -2]
todosSaoPositivos = True
for i in listaDeInteiros:
    if i <= 0:
        todosSaoPositivos = False
        break
if todosSaoPositivos:
    print 'Todos sao positivos'
else:
    print 'Tem algum negativo'

Perceba como o código é bem similar ao anterior, praticamente só altera a condição, e os nomes das coisas. Devido a frequência com que aparecem problemas parecidos com esse, Python fornece um jeito mais sucinto de escrever esse tipo de lógica. Usando as funções pré-definidas all e any, seu código ficará mais fácil tanto de escrever como de ler, uma vez que você as aprende. Veja como ficaria o código para verificar se todos os elementos são pares usando all:

listaDeInteiros = [2, 6, 4, 7, -2]
if all(i % 2 == 0 for i in listaDeInteiros):
    print 'Todos sao pares'
else:
    print 'Tem algum impar'

Podemos obter resultado semelhante usando a função any. Tente perceber todas as diferenças:

listaDeInteiros = [2, 6, 4, 7, -2]
if not any(i % 2 != 0 for i in listaDeInteiros):
    print 'Todos sao pares'
else:
    print 'Tem algum impar'

all()

A função all() é muito simples e também muito útil. A documentação oficial da função diz o seguinte:

`all(iterável)` Retorna `True` se todos os elementos do iterável forem verdadeiros (ou se o iterável for vazio).
Ou seja, a função recebe como parâmetro um objeto iterável (uma lista ou uma tupla, por exemplo) e verifica se todos os elementos desse iterável possuem o valor True. Como o próprio nome diz, all() (todos, em português) verifica se todos os elementos contidos em uma sequência são verdadeiros.

Isso pode ser muito útil quando temos uma lista e precisamos, antes de qualquer coisa, verificar se os elementos dessa lista satisfazem determinada condição.

Por exemplo, antes de passarmos uma lista de strings para uma função que não trata strings vazias, poderíamos fazer o seguinte:

if all(s != '' for s in lista_de_strings):
    funcao_que_nao_trata_strings_vazias(lista_de_strings)
else:
    print "Erro: strings vazias existem na lista!"

No exemplo acima usamos uma generator expression (s != '' for s in lista_de_strings) para gerar o iterável contendo booleanos para passar como entrada para a função all().

Simples, expressivo e eficiente.

any()

A função builtin any() é parecida com a função all(), porém ela retorna True se algum dos elementos do iterável for True. Por exemplo, poderíamos usá-la para verificar se pelo menos um dos elementos de lista_de_strings é uma string vazia.

if any(s == '' for s in lista_de_strings):
    print "Erro: strings vazias existem na lista!"
else:
    funcao_que_nao_trata_strings_vazias(lista_de_strings)

all() e any() como alternativas a and e or

Uma expressão booleana como:

if cond1 and cond2 and cond3 and cond4 and cond5:
    # faça algo

será verdadeira somente se todas as condições testadas forem verdadeiras. Como poderíamos escrever a expressão acima utilizando a função all()?

if all([cond1, cond2, cond3, cond4, cond5]):
    # faça algo

E uma expressão composta por ors lógicos, como poderia ser reescrita?

if cond1 or cond2 or cond3 or cond4 or cond5:
    # faça algo

A expressão acima (cond1 or cond2 or cond3 or cond4 or cond5) será verdadeira se alguma das condições for verdadeira. Ou seja, poderíamos usar a função any():

if any([cond1, cond2, cond3, cond4, cond5]):
    # faça algo

As funções all() e any() podem então ser vistas como aplicações dos operadores and e or aos elementos de sequências.

all() e any() combinados com map()

Já vimos como as funções all() e any() são práticas. Vamos ver agora que, quando combinadas com outros recursos que Python oferece, essas funções passam a ser mais poderosas, dando maior expressividade ao código escrito.

Anteriormente, vimos o funcionamento da função map(): ela aplica uma função a cada elemento de uma sequência e retorna o resultado disso em uma nova lista. Por exemplo:

>>> import math
>>> lista1 = [1, 4, 9, 16, 25]
>>> lista2 = map(math.sqrt, lista1)
>>> print lista2
[1.0, 2.0, 3.0, 4.0, 5.0]

Como poderíamos combinar a função map() com as funções all() ou any()? Vamos a um exemplo.

Considere que temos duas listas contendo números inteiros ([1,2,3,4,5] e [1,4,2,3,5]) e precisamos saber se essas listas possuem elementos de mesmo valor posicionados nas mesmas posições em ambas as listas. Isso poderia ser feito da seguinte forma:

>>> import operator
>>> map(operator.eq, [1,2,3,4,5], [1,4,2,3,5])
[True, False, False, False, True]
>>> any( map(operator.eq, [1,2,3,4,5], [1,4,2,3,5]) )
True

Na segunda linha, usamos a função map() para comparar a igualdade (operator.eq) dos elementos das duas listas (mais informações sobre o módulo operator aqui). Tal linha aplica a função eq (que recebe dois argumentos, os elementos a serem comparados) a pares de elementos das duas listas passadas como argumentos, iniciando por 1 e 1, passando por 2 e 4, 3 e 2, 4 e 3, e, por fim, 5 e 5. Cada comparação gera um booleano que é adicionado à lista que a função map() retorna como resultado. Então, basta que apliquemos a função any() para verificar se para algum dos pares de elementos o eq retornou True. Se em qualquer das posições a lista de resultado do map tiver o valor True, significa que as duas listas possuem elemento cujo valor e posição sejam iguais nas duas listas.

Para finalizar

all() e any() fazem parte do grupo de recursos de Python que todo pythonista deve ter no bolso para utilizar sempre que for preciso. Além de evitar longas linhas de expressões booleanas, essas funções nos permitem dar maior legibilidade ao nosso código.

Ah, fique atento, pois ambas as funções estão disponíveis somente a partir da versão 2.5 do Python.

Publicado por

Valdir Stumm Jr

Postado no

17 de outubro de 2012

Publicado em

shell

comentários

32 Comentários

virtualenv: ambientes virtuais para desenvolvimento

O post de hoje não será tão estreitamente relacionado à dicas sobre código Python como foram os anteriores. Ele irá tratar sobre o ambiente usado para o desenvolvimento em sua máquina.

Para quem está envolvido no desenvolvimento de vários projetos em paralelo, é bastante comum que um projeto tenha dependências de bibliotecas diferentes das usadas pelos outros projetos.
Em um ambiente Ubuntu Linux, por exemplo, os módulos Python instalados no sistema são armazenados em /usr/lib/python2.7/dist-packages/ (para Python 2.7). Dessa forma, se tivermos desenvolvendo dois projetos diferentes, eles estarão compartilhando algumas bibliotecas. E se for necessário que o projeto A utilize a versão x de determinado módulo, enquanto que o projeto B deve utilizar a versão y do mesmo módulo? Como os dois projetos, A e B, utilizam os módulos instalados no mesmo local do disco, fica difícil satisfazer esse requisito.

Outra situação muito comum de acontecer é estarmos desenvolvendo ou testando uma aplicação em um ambiente sobre o qual não temos permissões para a instalação de pacotes no sistema. Sabendo que muita gente passa por situações parecidas, foi criado o virtualenv. Se tivermos o virtualenv à disposição, podemos criar um ambiente virtual em nossa pasta pessoal e instalar os pacotes necessários dentro desse ambiente, sem a necessidade de ter privilégios de super-usuário. Quando for necessário lidar com vários projetos ao mesmo tempo, podemos criar um ambiente virtual para cada projeto, ambos na mesma máquina.

Assim, o virtualenv é uma ferramenta que permite que criemos, com o perdão da redundância, ambientes virtuais isolados para projetos Python. Por exemplo, se tivermos dois projetos, A e B, podemos criar dois ambientes virtuais, um para cada um dos projetos. Poderíamos chamá-los de venvA e venvB, por exemplo. Quando criamos esses dois ambientes, é criado um diretório com o nome de cada ambiente, com o seguinte conteúdo cada um:

bin  include  lib  local

Dentro do diretório bin, são criados arquivos binários (executáveis) necessários em um ambiente de desenvolvimento Python:

$ ls bin/
activate          activate.fish     easy_install    get_env_details
pip-2.7           postdeactivate    predeactivate   activate.csh
activate_this.py  easy_install-2.7  pip             postactivate
preactivate       python

Perceba que temos, dentre os arquivos listados, o interpretador Python (python), além de outras ferramentas importantes como o pip, que pode ser usadoo como instalador de pacotes do virtualenv. Existem também arquivos que são relacionados ao próprio ambiente virtual. Assim, cada ambiente virtual terá seus próprios executáveis para interpretar seus programas e gerenciar seus pacotes. Além disso, é criado também um diretório lib/python2.7/site-packages/, onde serão armazenados os pacotes que você instalar para aquele ambiente. Ou seja, ambos os ambientes venvA e venvB possuirão seu próprio interpretador Python, bem como suas próprias bibliotecas de código. Assim, cada projeto poderá ter versões específicas de determinados pacotes, sem a ocorrência de conflitos entre versões.

Como usar o virtualenv?

O virtualenv pode ser instalado de várias formas. A forma mais comum é através do gerenciador de pacotes pip. Tendo o pip instalado, você pode instalar o virtualenv com o seguinte comando:

user@host:~/$ sudo pip install virtualenv

Tendo feito isso, agora podemos começar a criar os ambientes virtuais para projetos Python. Primeiramente, vamos criar um ambiente:

user@host:~/$ virtualenv NomeDoAmbiente

Após executado o comando acima, será criado, no diretório atual, um subdiretório chamado NomeDoAmbiente, contendo aquela mesma estrutura já comentada anteriormente. Após o ambiente ter sido criado, precisamos ativá-lo:

user@host:~/$ source ./NomeDoAmbiente/bin/activate
(NomeDoAmbiente)user@host:~/$

Você irá perceber que o prompt do seu shell é alterado após a execução do comando acima, sendo a partir daí, precedido pelo nome do ambiente virtual ativo entre parênteses (veja acima). Isso faz também com que sua variável de ambiente $PATH passe a apontar, em primeiro lugar, para a pasta bin de dentro do ambiente virtual, de forma que quando você chamar o interpretador Python pela linha de comando, o executável que será aberto será o interpretador que está instalado dentro do ambiente virtual atual, pois será o primeiro encontrado no $PATH.

Instalando pacotes dentro do ambiente virtual

Uma vez que ativamos o ambiente virtual que desejamos usar, podemos então instalar os pacotes que forem necessários para nosso projeto. Por exemplo, considere que estamos trabalhando em nosso ambiente (ativado anteriormente), chamado de NomeDoAmbiente, e desejamos instalar o pacote Django. Podemos utilizar o gerenciador de pacotes pip que está instalado dentro de nosso ambiente virtual NomeDoAmbiente:

(NomeDoAmbiente)user@host:~/$ pip install Django
Downloading/unpacking Django
    Downloading Django-1.4.1.tar.gz (7.7Mb): 7.7Mb downloaded
    Running setup.py egg_info for package Django
Installing collected packages: Django
    Running setup.py install for Django
Successfully installed Django
Cleaning up...

Agora, podemos abrir um shell Python dentro do ambiente NomeDoAmbiente recém criado, e testar se o Django está mesmo instalado:

(NomeDoAmbiente)user@host:~/$ python
Python 2.7.2+ (default, Jul 20 2012, 22:15:08) 
[GCC 4.6.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import django
>>> django.__file__
'/home/user/NomeDoAmbiente/local/lib/python2.7/site-packages/django/__init__.pyc'

Tudo certo, o Django está instalado corretamente dentro do ambiente NomeDoAmbiente.

Para sair do ambiente virtual ativo, utilize o comando deactivate.

Gerando lista de dependências do projeto

Lembra quando você envia um projeto pronto para o chefe e ele manda um email dizendo que o projeto não funciona? Muitas vezes, o problema é que o computador do chefe não possui instaladas as bibliotecas que o projeto necessita. Nessa situação, a dupla virtualenv + pip nos ajuda novamente.

Uma vez que estejamos utilizando ambientes virtuais para nossos projetos, e que estejamos instalando todos os pacotes necessários via pip, temos facilmente em mãos a lista de pacotes dos quais nosso projeto depende. Para obter essa lista, basta utilizar o comando freeze do pip:

(NomeDoAmbiente)user@host:~/$ pip freeze
Django==1.4.1
Werkzeug==0.8.3
argparse==1.2.1
distribute==0.6.24
django-bootstrap-toolkit==2.5.8
django-extensions==0.9
django-registration==0.8
wsgiref==0.1.2

Tal comando escreve na saída-padrão a lista de pacotes (bem como suas versões), de cada uma das dependências instaladas via pip no projeto ativo. De posse dessa lista, podemos agora facilmente enviar a lista de dependências para o nosso chefe, utilizando as informações fornecidas pelo pip freeze para garantir que a máquina do chefe irá satisfazer todas as dependências do nosso projeto. Primeiro, devemos armazenar em um arquivo as informações geradas pelo pip freeze:

(NomeDoAmbiente)user@host:~/$ pip freeze > requirements.txt

Após isso, podemos enviar o arquivo requirements.txt para o chefão e, usando o pip, ele poderá executar:

(NomeDoAmbiente)anotheruser@anotherhost:~/$ pip install -r requirements.txt

O comando acima irá instalar as versões especificadas dos pacotes listados no arquivo fornecido como entrada. Tendo instalado corretamente os pacotes listados, nosso projeto estará com todas as dependências satisfeitas no computador do chefe, e poderá ser executado sem problemas.

virtualenvwrapper

Existe outro projeto, chamado virtualenvwrapper, que é um wrapper sobre o virtualenv, e que provê uma série de facilidades para a manipulação de ambientes virtuais. Vale muito a pena dar uma conferida nele!

Utilizando o virtualenvwrapper, a ativação de um ambiente fica muito mais simples:

user@host:~/$ workon NomeDoAmbiente
(NomeDoAmbiente)user@host:~/$

Além disso, ele provê vários atalhos para facilitar a nossa vida, como o cdvirtualenv, que troca o diretório atual para o diretório do virtualenv ativo. Alguns outros aliases úteis:

cdsitepackages: troca o diretório atual para o diretório onde os pacotes Python do ambiente virtual ativo estão instalados.
lssitepackages: comando muito útil para listarmos os arquivos/diretórios presentes no diretório de instalação dos módulos do ambiente virtual ativo.
mkvirtualenv NOME: cria um ambiente virtual chamado NOME.
dentre outros 😉

virtualenv embutido no Python 3.3

A versão 3.3 do Python traz consigo a possibilidade de criarmos ambientes virtuais sem a necessidade de instalação do pacote virtualenv separadamente, ou seja, o virtualenv fará parte da distribuição oficial do Python. Mais informações podem ser encontradas na documentação oficial: http://docs.python.org/dev/library/venv.html.

Enfim…

O virtualenv é extremamente útil quando você está trabalhando com vários projetos ao mesmo tempo, ou em um ambiente sobre o qual você não tenha permissões de super-usuário. Mas fique atento, pois o virtualenv irá instalar uma versão de cada biblioteca e dos executáveis para cada um dos seus ambientes virtuais, o que irá consumir mais espaço em disco.

Publicado por

Valdir Stumm Jr

Postado no

25 de setembro de 2012

Publicado em

estruturas, listas

comentários

14 Comentários

Filas e Pilhas em Python

Você pode não perceber, mas boa parte dos programas que você usa no dia-a-dia utilizam internamente os tipos abstratos de dados chamados filas e pilhas. Eles são chamados dessa forma porque representam uma estrutura de dados com operações associadas que definem um certo comportamento. Eles são muito úteis para o programador pois podem ser utilizados em diversas situações e têm um grande poderde simplificar algoritmos. A seguir, explicarei cada uma dessas estruturas e demonstrarei como poderíamos implementá-las em Python.

Filas

Tenho certeza que você já sabe como uma fila funciona. Pense na fila que você pega toda vez que vai ao supermercado. Para que você seja atendido, é preciso que todas as pessoas que estiverem na sua frente na fila sejam atendidas ou desistam para que você seja atendido, certo? Por isso, podemos dizer que a idéia da fila é que o último a entrar na fila seja o último a sair.

                                     _________
                                    | o caixa |
------------------------------------|_________|
 o    ~o    @    &     Q    0    O     0
/|\    []  {0\  /|\   /|\  /||  /-\   /0|
/ \    |\   |\  / \    |\  /|   |-|   / \
você   p6   p5  p4     p3  p2    p1   p0
-------------------------------------------

No exemplo acima, é preciso que p0, p1, p2, p3, p4, p5 e p6 sejam atendidas para que seja a sua vez de passar as compras e pagar por elas. Uma estrutura de dados Fila funciona da mesma maneira. Uma fila é uma estrutura utilizada especificamente para armazenamento temporário de dados na memória. Diferentemente de uma lista, que também serve para esse fim, uma fila possui regras quanto a qual elemento será retirado e onde será inserido um novo elemento. Em uma lista, é possível inserir elementos em qualquer posição e retirar quaisquer elementos, não importando sua posição. Em uma fila, os novos elementos que são inseridos são sempre posicionados ao final dela. Quando se faz a retirada de um elemento de uma fila, sempre iremos retirar o elemento que há mais tempo está nela (o primeiro). Imagine um servidor Webque é capaz de atender a, no máximo, 2 requisições simultâneas. O que acontece quando chega uma terceira requisição no momento em que o servidor já está ocupado atendendo a 2 requisições? A solução mais óbvia seria colocar a nova requisição em uma área de espera. Assim, quando o servidor terminar de atender uma das atuais 2 requisições, ele poderá retirar a nova requisição da área de espera e atendê-la. E se, enquanto o servidor estiver ocupado atendendo a 2 requisições, chegarem em sequência 5 novas requisições?

   ______              
  |  r0  |       [ r6  r3]
  |  r1  |       [  r5   ]
  |______|       [r4  r2 ]
    /  \  
Servidor Web    Área de espera

O servidor poderia colocar as novas requisições em uma área de espera, e sempre que houver disponibilidade, retirar uma de lá e processá-la, até que não hajam mais requisições a serem processadas. A solução é boa, mas para ser justo com as solicitações que chegam dos usuários, o servidor deve processar primeiro as que já estão esperando há mais tempo, correto? Assim, o melhor a se fazer é utilizar uma filapara armazenar as requisições que estão em espera.

        ______    
       |  r0  |           
       |  r1  |      saída  -----------------------  entrada
       |______|      <----   r2  r3  r4  r5  r6     <------
         /  \               -----------------------
     Servidor Web                 Fila de espera

Dessa forma, a requisição que está há mais tempo esperando é a primeira a sair da fila quando o servidor tiver disponibilidade.

Implementando uma fila

Uma fila nada mais é do que uma estrutura de armazenamento com políticas de ordem de entrada e saída de elementos. Assim, ela pode ser implementada usando uma lista, por exemplo. Como poderíamos fazer? Sabemos que as listas oferecem alguns métodos conhecidos para inserção/remoção de elementos:

.append(elemento): adiciona elemento ao final da lista;
.insert(índice, elemento): insere elemento após a posição índice;
.pop(índice): remove e retorna o elemento contido na posição índice.

Para inserir elementos, podemos usar o método append(), que insere um elemento ao final de uma lista. Para a retirada de elementos, podemos utilizar o método pop(x), que retira e retorna um elemento da posição x. Em se tratando de uma fila em que estamos inserindo elementos no final, de qual posição devemos retirar os elementos? Acertou quem pensou “da primeira”. Isso mesmo vamos remover o primeiro elemento utilizando pop(0). Veja:

>>> fila = [10, 20, 30, 40, 50]
>>> fila.append(60)  # insere um elemento no final da fila
>>> print fila
[10, 20, 30, 40, 50, 60]
>>> print fila.pop(0) # remove o primeiro elemento da lista
10
>>> print fila
[20, 30, 40, 50, 60]
>>> print fila.pop(0) # remove o primeiro elemento da lista
20
>>> print fila
[30, 40, 50, 60]
>>> print fila.pop(0) # remove o primeiro elemento da lista
30
>>> print fila
[40, 50, 60]

Você deve estar se perguntando: “e se eu fizesse o contrário, inserindo no início e removendo do final, funcionaria também como uma fila?” Sim, funcionaria. Pois, da mesma forma, teríamos a política do primeiro a entrar, primeiro a sair também conhecida como First-In, First-Out, ou simplesmente FIFO. Agora, para criar uma forma consistente de usar filas em Python, vamos criar uma classe para encapsular as operações da fila. Podemos definir uma classe Filaque internamente tenha uma lista representando o local onde serão armazenados os elementos. Essa classe deverá ter dois métodos principais:

insere(elemento): recebe como entrada um elemento a ser inserido na fila.
retira(): remove um elemento da fila e o retorna para o chamador.

Complete a implementação de fila abaixo, de acordo com o que foi explicado acima. O código completo se encontra no final deste texto, para que você possa comparar.

class Fila(object):
    def __init__(self):
        self.dados = []

    def insere(self, elemento):
        __________________________________

    def retira(self):
        __________________________________

Tendo a classe acima definida em um arquivo fila.py, poderíamos importar o módulo e usar tal classe:

>>> import fila
>>> f = fila.Fila()
>>> f.insere(10)
>>> f.insere(20)
>>> f.insere(30)
>>> print f.retira()
10
>>> print f.retira()
20

Importante: segundo a própria documentação oficial Python, uma lista não é a estrutura mais recomendada para a implementação de uma fila, porque a inserção ou remoção de elementos do início da lista é lenta, se comparada à inserção/remoção do final da lista. Assim, é sugerido que seja usado um deque (collections.deque).

Só isso?

Não, nós vimos apenas as filas “comuns”. Voltando ao exemplo da fila do supermercado, imagine que você está chegando aos caixas e ainda não decidiu qual deles vai usar. Aí você vê que o caixa de atendimento preferencial para idosos/gestantes/deficientes possui apenas 3 pessoas na fila, enquanto que os outros caixas têm filas com no mínimo 10 pessoas. Como o caixa não é exclusivo para idosos, você vai lá e entra na fila. Outras pessoas percebem a sua “sagacidade” (:P) e fazem o mesmo. Fica tudo certo até que chega um idoso para entrar na fila e todas as pessoas que estão na fila são obrigados a ceder sua vez para o idoso. E eis que chega o clube da terceira idade inteiro para ser atendido logo em seguida. O que acontece? As pessoas que estão na fila cedem sua vez para os idosos, e assim, seu atendimento vai sendo postergado cada vez mais. Enfim, esse é um exemplo de uma fila de prioridades. Elementos (as pessoas) que possuem maior prioridade, saem antes da fila. Se quiser saber mais, veja aqui.

Pilhas

Assim como as filas, aposto que você sabe exatamente como funciona uma pilha. Pense em uma pilha de papéis sobre uma mesa. Se você precisar adicionar um papel a essa pilha, você o adiciona sobre a pilha, ou seja, no topo dela, certo? E quando vai retirar um papel da pilha, você começa pelo que estiver no topo, certo? Ou seja, diferentemente da fila (FIFO), em uma pilha o último a entrar nela, é o primeiro a sair (Last-In, First-Out — LIFO). Veja abaixo uma ilustração de como funciona uma pilha. No primeiro item da ilustração (1), temos uma pilha composta por 5 elementos, que foram inseridos cronologicamente na seguinte ordem: p0, p1, p2, p3, e, por fim, p4. A segunda parte da ilustração (2) mostra o estado da pilha p após ter sido realizada a inserção de um novo elemento (p5). A terceira parte (3) mostra a pilha p após haver a retirada de um elemento. Como você pode ver, o elemento retirado foi o último a ter sido inserido (p5). Na última parte da ilustração (4), é apresentada mais uma retirada de elemento da pilha, desta vez p4. Se houvessem mais operações de retirada, teríamos a retirada, em ordem, dos elementos: p3, p2, p1 e p0.

|          |    |----p5----|    |          |    |          |
|----p4----|    |----p4----|    |----p4----|    |          |
|----p3----|    |----p3----|    |----p3----|    |----p3----|
|----p2----|    |----p2----|    |----p2----|    |----p2----|
|----p1----|    |----p1----|    |----p1----|    |----p1----|
|----p0----|    |----p0----|    |----p0----|    |----p0----|
============    ============    ============    ============
  Pilha p       p.insere(p5)     p.retira()      p.retira()
    (1)             (2)              (3)            (4)

Tranquilo, né? O que você deve lembrar sobre as pilhas é que ela usa uma política LIFO (Last-In, First-Out) para inserção/retirada de elementos.

Onde as pilhas são usadas?

Talvez a mais famosa utilização de pilhas em computação esteja no gerenciamento de chamadas de função de um programa. Uma pilha pode ser usada para manter informações sobre as funções de um programa que estejam ativas, aguardando por serem terminadas. Considere o seguinte exemplo:

def ola():
    print "olá, "
    mundo()

def mundo():
    print "mundo!"

def olamundo():
    ola()

olamundo()

A primeira função a ser chamada é a olamundo(), que por sua vez chama a função ola(), então a função olamundo() é empilhada, pois seu término depende do término da função ola(). Essa, por sua vez, chama a função mundo() e é empilhada. Ao terminar a execução da função mundo(), a função ola() é desempilhada e sua execução termina de onde havia parado (chamada à função mundo()). Como não há mais nada a ser executado nessa função, sua execução termina, e a função olamundo()é desempilhada e sua execução continua, encerrando assim o programa.

                 ola()
olamundo()  -->  olamundo()  --> olamundo() -->   Fim do programa.

Outra utilização de pilhas é a verificação do balanceamento de parênteses. Como saber se os seguintes parênteses estão balanceados, isto é, se para cada abre-parênteses, existe um fecha-parênteses correspondente?

(((((((((((((((((()()()()))))))())))()))()))()))((()))))

Uma forma bem simples de resolver esse problema é ler a sequência de parênteses, um por um e, a cada abre-parênteses que encontrarmos, vamos empilhá-lo. Quando encontrarmos um fecha-parênteses, devemos desempilhar um abre-parênteses, pois encontramos um fecha-parênteses correspondente a ele. Assim, ao final da avaliação da sequência acima, se ela estiver balanceada corretamente, não restarão elementos na pilha. Vejamos um exemplo mais simples:

(())()

                (
Pilha       (   (   (       (

Leitura     (   (   )   )   (   )   FIM

Repare agora em uma sequência desbalanceada:

(())(

                (
Pilha       (   (   (       (   (

Leitura     (   (   )   )   (   FIM

Perceba que a leitura de parênteses da entrada terminou, mas a pilha não estava mais vazia.

Implementação

Agora eu lhe pergunto: o que muda da implementação da fila para a implementação da pilha? A diferença é pouca, mas é muito importante. Assim como para as filas, para a implementação de pilhas podemos utilizar uma lista como estrutura para armazenamento dos dados. Basta agora definir como será o funcionamento:

Iremos inserir e retirar elementos do início da lista?
Ou iremos inserir e retirar elementos do final da lista?

Sabendo que em Python a inserção e remoção de elementos no final de uma lista é menos custoso do que fazer as mesmas operações no início dela, vamos adotar a segunda opção. Então, complete o código abaixo e teste em seu computador.

class Pilha(object):
    def __init__(self):
        self.dados = []

    def empilha(self, elemento):
        __________________________________

    def desempilha(self):
        __________________________________

p = Pilha()
p.empilha(10)
p.empilha(20)
p.empilha(30)
p.empilha(40)
print p.desempilha(),
print p.desempilha(),
print p.desempilha(),
print p.desempilha(),

O programa acima, se implementado corretamente, deverá mostrar o seguinte resultado na tela:

40 30 20 10

Para adicionar um elemento no final de uma lista, basta usar o método append(). E para remover o último elemento da lista? .pop(tamanho_da_lista-1) é o que devemos fazer. E para obter o tamanho da lista, podemos usar a função len(). Então:

def desempilha(self):
    return self.dados.pop(len(dados)-1)

Ou então, podemos usar self.dados.pop(-1). O acesso ao índice -1é a forma pythônica de se referir ao último elemento de uma sequência.

def desempilha(self):
    return self.dados.pop(-1)

Mais alguma operação?

Outra operação fundamental que deve estar disponível em uma Pilha, é um método que retorne um booleano indicando se a pilha está vazia. Um jeito bem simples seria usando a builtin len() sobre a nossa lista interna self.dados e verificando se ela retorna 0como resultado.

def vazia(self):
    return len(self.dados) == 0

Finalizando…

Tanto a fila quanto a pilha são estruturas importantes pra caramba e sua implementação deve fornecer um bom desempenho, visto que elas são amplamente usadas nos programas que compõem o nosso dia-a-dia. As implementações vistas aqui nesse post possuem fins didáticos apenas. Embora funcionem de forma adequada para serem utilizadas, elas não utilizam os recursos mais adequados para obter o melhor desempenho. Para usar na prática, existem soluções prontas e muito mais recomendadas, como por exemplo o módulo python queue, que pode ser usado tanto para implementação de Filas quanto para a implementação de Pilhas.

Códigos completos

Abaixo, seguem os códigos completos para a Fila e para a Pilha.

Fila

class Fila(object):
    def __init__(self):
        self.dados = []

    def insere(self, elemento):
        self.dados.append(elemento)

    def retira(self):
        return self.dados.pop(0)

    def vazia(self):
        return len(self.dados) == 0

Pilha

class Pilha(object):
    def __init__(self):
        self.dados = []

    def empilha(self, elemento):
        self.dados.append(elemento)

    def desempilha(self):
        if not self.vazia():
            return self.dados.pop(-1)

    def vazia(self):
        return len(self.dados) == 0

Uma classe para números binários

Compartilhar:

A palavra reservada class

Hierarquia de classes

Compartilhar:

Nome

Tá, e daí?

Mutável vs Imutável

Quem é quem?

Passagem de parâmetros

Pronto!

Compartilhar:

Usando as namedtuples

Compartilhar:

Mas isso é útil para quê?

Percorrendo listas de tuplas

Mas nem tudo interessa

Compartilhar:

Entendendo melhor as mensagens de erro do Python

Outro exemplo

Mais um exemplo

Muito além do traceback

O print

Os loggers

O debugger

Breakpoints

winpdb

Enfim…

Compartilhar:

Autenticação

Como NÃO implementar autenticação

Um jeito melhor

O que é o Hash?

Autenticação com hash

Ataques ao banco de dados de senhas (ou hashes delas)

Evitando as Rainbow Tables

O mecanismo correto

Instalando o bcrypt

Usando o bcrypt

Gerando o hash de uma senha

Verificando a senha do usuário

Um sistema de autenticação usando BD

Antes de terminar …

Leia mais sobre o assunto

Compartilhar:

all()

any()

all() e any() como alternativas a and e or

all() e any() combinados com map()

Para finalizar

Compartilhar:

Como usar o virtualenv?

Instalando pacotes dentro do ambiente virtual

Gerando lista de dependências do projeto

virtualenvwrapper

virtualenv embutido no Python 3.3

Enfim…

Compartilhar:

Filas

Implementando uma fila

Só isso?

Pilhas

Onde as pilhas são usadas?

Implementação

Mais alguma operação?

Finalizando…

Códigos completos

Fila

Pilha

Compartilhar: