Programando para a Web em Python

Sumário

Este é o quarto post da série sobre Python + Web. Nós já vimos como fazer requisições HTTP a partir de um programa Python, como fazer extração de dados de conteúdo HTML obtido via HTTP e como lidar com dados em formato JSON retornados por um serviço Web. Porém, até agora trabalhamos somente no lado cliente, obtendo dados via HTTP para então fazer algo com eles. A partir de agora vamos para o lado do servidor, onde iremos escrever o provedor do serviço.

Neste post, veremos como construir um servicinho web bem simples, que retorne para o cliente o dia da semana relativo a determinada data, codificado em formato JSON.

Web em Python

Python é uma linguagem muito versátil, podendo ser usada para vários fins. Um dos nichos em que Python mais tem sido usada ultimamente é no desenvolvimento web. E quando se trata de web, temos várias ferramentas disponíveis para usar com Python. Este post irá apresentar a forma mais simples de todas: o CGI (Common Gateway Interface).

CGI

O funcionamento do CGI é bem simples: ao receber uma requisição, o servidor web roda um programa executável para gerar o conteúdo a ser retornado para o cliente (é esse programinha executável que vamos implementar). Assim, um programinha bem simples que poderia funcionar juntamente com um servidor CGI é:

#!/usr/bin/python

# cabecalho que informa o browser para renderizar como HTML
print "Content-Type: text/html\n\n"
# o conteudo em si
print "<strong>Hello, world!</strong>"

Se você quiser brincar um pouquinho com CGI, siga os seguintes passos:

  1. Crie uma pasta chamada src e dentro dela outra pasta chamada cgi-bin;
  2. Salve o arquivo acima como hello.py dentro da pasta cgi-bin recém criada;
  3. Dê permissão de execução ao arquivo hello.py: chmod +x hello.py;
  4. Pelo shell de comandos do seu sistema operacional, vá até a pasta src e execute o servidorzinho CGI que Python traz consigo: python -m CGIHTTPServer 8000
  5. Abra um navegador e acesse a URL: http://localhost:8000/cgi-bin/hello.py
  6. Como resultado, você deverá ver a mensagem “Hello, world!” em negrito no seu navegador.

Mas, para que faça sentido, é preciso que nosso aplicativo seja capaz de obter eventuais informações que o usuário passar a ele. Usando o módulo cgi, podemos manipular parâmetros fornecidos pelo usuário, dentre outras possibilidades. Veja o exemplo abaixo:

#!/usr/bin/python
import cgi

# obtem referencia as variaveis passadas pelo cliente
fields = cgi.FieldStorage()

# cabecalho que informa o browser para renderizar como HTML
print "Content-Type: text/html\n\n"

nome = fields.getvalue('nome')
print "<strong>Hello, %s!</strong>" % (nome)

Salve o arquivo acima no mesmo diretório cgi-bin com o nome de hellouser.py, dê permissão de execução para o mesmo (chmod +x hellouser.py) e então acesse no seu browser: http://localhost:8000/hellouser.py?nome=Seu Nome Aqui.

Como você deve saber, /hellouser.py?nome=Seu Nome Aqui significa que estamos passando para o “programa” /hellouser.py a variável nome com o valor Seu Nome Aqui, tudo pela URL, através do método HTTP GET.

Preparando a implementação do serviço

Antes de sairmos implementando detalhes do serviço web que nos comprometemos a implementar, vamos criar uma funçãozinha que será parte essencial do nosso projeto. Essa função irá receber 3 valores: dia, mês e ano, e irá retornar o dia da semana em forma de string. Por exemplo:

dia_da_semana(27, 3, 2013) --retorna--> "Quarta-feira"
dia_da_semana(24, 3, 2013) --retorna--> "Domingo"

Para implementá-la, vamos usar o método weekday() dos objetos date, disponível no módulo datetime. A documentação dessa função diz o seguinte (tradução própria):

Retorna o dia da semana como um inteiro, onde Segunda-feira é 0 e Domingo é 6.

Assim, tudo o que teremos que fazer é construir uma instância de date com os dados fornecidos como parâmetro para nossa função, e invocar o método weekday() nesse objeto. Exemplo:

>>> from datetime import date
>>> d = date(2013, 3, 27)
>>> print d.weekday()
2

2 significa que a data em questão, 27/03/2013 cai numa Quarta-feira, visto que Segunda-feira é 0 e que Domingo é 1. Perceba que para construir um objeto do tipo date, nós passamos as informações sobre dia, mês e ano em ordem inversa à que estamos acostumados no Brasil. A assinatura do método construtor de objetos date é:

date(ano, mês, dia)

Perfeito, agora só falta definirmos uma forma de obtermos os nomes dos dias em língua portuguesa. Vamos usar uma abordagem bem simples, mas que resolve nosso problema. Vamos usar uma lista contendo as strings representando os dias da semana. (claro que se fôssemos dar suporte a usuários de vários países, a história seria diferente)

from datetime import date

dias = [
    'Segunda-feira',
    'Terça-feira',
    'Quarta-feira',
    'Quinta-feira',
    'Sexta-feira',
    'Sábado',
    'Domingo'
]

def dia_da_semana(dia, mes, ano):
    try:
        return dias[date(ano, mes, dia).weekday()]
    except ValueError:
        return 'Erro: data mal-formatada.'

Simples, huh? Utilizamos o inteiro retornado pelo método weekday() como índice para nossa lista com os nomes dos dias da semana. Além disso, envolvemos nosso código com try-except pois o usuário pode muito bem fornecer uma data inválida, como 31/02/2013 ou 100/123/2013. O construtor date() levanta a exceção ValueError quando recebe parâmetros que não representam uma data válida.

Feito isso, agora podemos implementar nosso serviço. (leia atentamente o código acima, caso não tenha entendido algo)

Implementando o serviço web

Já vimos como implementar um aplicativozinho web beeeeeeeem simples usando CGI, também já vimos como obter o dia da semana em que determinada data cai, e num post anterior vimos como codificar e decodificar dados em formato JSON. Agora, basta juntarmos as peças para implementar o serviço.

Só para relembrar, estamos implementando um serviço web que retorna o dia da semana relativo à determinada data fornecida pelo usuário. O usuário irá fornecer a data no formato dd/mm/aaaa. Por exemplo, o usuário pode solicitar a data fazendo uma requisição ao serviço da seguinte forma: http://um.host.qualquer.com/diasemana.py?data=27/3/2013.

Segue o código do nosso serviço:

#!/usr/bin/python
# -*- encoding:utf-8 -*-
import cgi
import json
from datetime import date

dias = [
    'Segunda-feira',
    'Terça-feira',
    'Quarta-feira',
    'Quinta-feira',
    'Sexta-feira',
    'Sábado',
    'Domingo'
]

def quebra_data(data):
    if (data.count('/') == 2 and
            all((x.isdigit() for x in data.split('/')))):
        return [int(x) for x in data.split('/')]
    else:
        raise ValueError

def dia_da_semana(data):
    try:
        dia, mes, ano = quebra_data(data)
        return dias[date(ano, mes, dia).weekday()]
    except ValueError:
        return 'Erro: data mal-formatada.'

print "Content-Type: text/json\n\n"
fields = cgi.FieldStorage()
data = fields.getvalue('data')
dia_str = dia_da_semana(data) if data is not None else 'Erro'
print json.dumps({'data': data, 'diasemana': dia_str})

Como a data fornecida pelo usuário é recebida no programa através do cgi.FieldStorage() sob a forma de string, é preciso que separemos essa data em dia, mês e ano. Para isso, criamos a função quebra_data() que antes de mais nada verifica se a data fornecida pelo usuário está no formato adequado (dia/mês/ano), e caso não esteja, a função levanta uma exceção ValueError para ser capturada pela função dia_da_semana(). Se a data estiver no formato correto, é retornada uma lista com três valores inteiros: dia, mês e ano. O método split(), usado em nossa função quebra_data separa a string em questão em todas as ocorrências do caractere separador fornecido como entrada ('/') e retorna uma lista contendo as substrings.

Ao final de nosso programinha, geramos um dicionário com as informações a serem codificadas em JSON e então imprimimos a informação JSONificada.

Momento “Lição de Vida”

Como você pode perceber lendo o código acima, boa parte da lógica do programa envolve a verificação dos dados fornecidos pelo usuário. Em se tratando de serviços ou aplicativos web, nunca podemos ser relapsos com os dados fornecidos pelo usuário, afinal o sistema está exposto pela web, podendo ser acessado de qualquer lugar do mundo, por pessoas com os mais variados níveis de conhecimento e com as mais variadas intenções. Às vezes, a falta de validação de um simples dado fornecido pelo usuário pode ser o suficiente para que o usuário destrua o nosso serviço ou, o que muitas vezes é pior, obtenha acesso à informações que deveriam ser sigilosas.

Portanto, nunca deixe de verificar todo e qualquer dado que um usuário forneça para o seu sistema. Às vezes ficamos com preguiça, com pena de poluir o código com “todas aquelas validações”, ou até achando que “os nossos usuários nunca tentariam sacanear o sistema”, mas não caia na bobagem de seguir esses pensamentos. Existem várias histórias de sistemas que foram destruídos e de pessoas que perderam seus empregos por deixar de filtrar os dados fornecidos pelo usuário.

Python + CGI está na crista da onda, então?

Não. Programação web com CGI nada mais é do que escrevermos programas que serão executados pelo servidor web quando houver uma requisição para eles. Essa simplicidade toda tem o seu custo: a cada requisição recebida pelo servidor web, ele inicia um novo processo que irá executar o código do recurso solicitado. Assim, recursos que de outra forma poderiam ser compartilhados entre instâncias são perdidos ao fim de cada processo. Conexões com o banco de dados, por exemplo, são reestabelecidas a CADA requisição feita para o serviço quando usamos CGI. Ou seja, sistemas web baseados em CGI dificilmente irão escalar quando necessário for.

Além disso, programar somente com CGI não é muito prático, pois temos que nos preocupar com diversos elementos que podem ser abstraídos e passados para uma outra camada. E outra coisa, código Python imprimindo HTML é muito anos 90! 😉

Para facilitar a nossa vida e resolver alguns dos problemas acima descritos, existem os frameworks para desenvolvimento web, que serão assunto para um próximo post.

Então CGI é inútil?

Não, longe disso. Com CGI, podemos executar programas remotamente e, de lambuja, ver o resultado da execução desse programa em nosso navegador. Se ele gerar HTML na saída, melhor ainda! 🙂

MAS, é claro que não vamos deixar exposto na web um programa que apaga todos os arquivos do disco rígido do servidor em que está rodando. 😛 Só que nada impede que disponibilizemos um scriptzinho inocente via CGI para que outra pessoa possa o acessá-lo remotamente, sem a necessidade de possuir acesso SSH àquela máquina. O legal é que tudo que é preciso para o acesso é um web browser, e, como você sabe, hoje em dia até as TVs possuem web browsers, sem falar nos telefones celulares.

Anúncios

Acessando conteúdo via APIs Web baseadas em JSON

Quem acompanhou os dois posts anteriores (aqui e aqui) sabe que neles nós realizamos buscas por conteúdo dentro de arquivos HTML. Quem conhece código HTML, sabe que ele não é um formato muito amigável para extração de conteúdo, principalmente quando mal-usado pelos desenvolvedores. Apesar disso, conseguimos fazer o webscraper funcionar, graças ao fato de o reddit.com apresentar um HTML com informações bem classificadas, fáceis de serem extraídas. Mas, mesmo assim, baixar um HTML para depois extrair informações dele não é a melhor solução existente.

Alguns serviços na Web fornecem um mecanismo para acesso às informações de forma mais direta, disponibilizando seu conteúdo através de estruturas em formato JSON. Os caras do reddit, que de bobos não tem nada, disponibilizam várias informações através de arquivos JSON. Veja um exemplo em: http://www.reddit.com/r/programming/.json. Se você se assustou com o conteúdo que o browser lhe mostrou ao acessar esse endereço, fique tranquilo, pois já vamos ver do que ele se trata.

JSON – JavaScript Object Notation

JSON (que é lido Jason, como em Sexta-feira 13) é um padrão que estabelece um formato para troca de dados entre programas, sendo usado principalmente na web. Ele tem sido muito usado na web como alternativa ao formato XML, que até então era o padrão de facto para representação de dados a serem trocados.

O interessante do JSON é que nossa aplicação escrita em Python pode enviar e receber dados usando esse formato com aplicações escritas em outras linguagens de uma forma razoavelmente maleável. Cada linguagem fornece uma maneira de transformar dados no formato JSON em objetos nativos da linguagem e vice-versa, de forma que se você descobrir que precisará enviar mais informações do que havia pensado inicialmente, basta adicioná-las no JSON enviado que as demais aplicações já poderão usá-las. Isso permite que você enxergue duas aplicações de linguagens de programação e plataformas diferentes como se fossem duas funções Python que recebem um dicionário como argumento. Além disso, o JSON é um formato que pode ser facilmente compreendido por humanos, sendo também utilizado como formato de arquivos de configuração de alguns programas.

Veja um exemplo de dados em formato JSON (adaptado de http://en.wikipedia.org/wiki/JSON):


{
    "primeiroNome": "Joao",
    "ultimoNome": "Smith",
    "idade": 25,
    "endereco": {
        "rua": "Rua Assis Brasil, 1000",
        "cidade": "Blumenau",
        "estado": "SC"
    },
    "telefones": [
        "5555-5555",
        "9999-9999"
    ],
    "emails": [
        {
            "tipo": "pessoal",
            "endereco": "joao@joao.com"
        },
        {
            "tipo": "profissional",
            "endereco": "joao.smith@algumaempresa.com"
        }
    ]
}

Se quiser ver um exemplo grande de JSON, veja aqui.

Como você deve ter percebido, o conteúdo JSON acima tem o formato BEM similar ao formato adotado para representação de dicionários em Python. Assim como nos dicionários, em JSON um objeto pode ter seus atributos representados sob a forma:

chave:valor

O acesso aos atributos pode ser realizado através das chaves de cada um deles. Para entender melhor, vamos abrir um shell Python e testar o módulo json.

import json
data = '''
    {
        "primeiroNome": "Joao",
        "ultimoNome": "Smith",
        "idade": 25,
        "endereco": {
            "rua": "Rua Assis Brasil, 1000",
            "cidade": "Blumenau",
            "estado": "SC"
        },
        "telefones": [
            "5555-5555",
            "9999-9999"
        ],
        "emails": [
            {
                "tipo": "pessoal",
                "endereco": "joao@joao.com"
            },
            {
                "tipo": "profissional",
                "endereco": "joao.smith@algumaempresa.com"
            }
        ]
    }
'''

Os dados em formato JSON nada mais são do que strings formatadas de acordo com as convenções definidas na especificação. Sendo strings, não temos uma forma simples de acessar os valores armazenados através das chaves. Por exemplo, o seguinte código falha porque data é uma string:

    >>> data['primeiroNome']
    ...
    TypeError: string indices must be integers, not str

Tendo os dados JSONificados (codificados em formato JSON) em uma string, podemos decodificá-los para que, ao invés de uma só string, tenhamos os dados em objetos Python:

json_data = json.loads(data)

Como resultado da decodificação, obtivemos um dicionário:

>>> type(json_data)
<type 'dict'>
>>> print json_data.keys()
[u'telefones', u'ultimoNome', u'idade', u'primeiroNome', u'endereco', u'emails']

Agora, se quisermos acessar o primeiro nome do usuário, fazemos:

>>> print json_data['primeiroNome']
Joao
>>> print json_data['telefones']
[u'5555-5555', u'9999-9999']

O valor correspondente à chave 'telefones' é uma lista, e assim sendo, o acesso aos seus elementos é feito através de um valor do tipo int como índice:

>>> print json_data['telefones'][0]
5555-5555
>>> print json_data['telefones'][1]
9999-9999


A lista é a estrutura para a qual os Arrays representados em JSON são traduzidas em Python.

Vamos agora acessar o nome da rua onde mora o cidadão representado acima:

>>> print json_data['endereco']['rua']
Rua Assis Brasil, 1000


Uma vez tendo sido decodificado o conteúdo JSON, o acesso aos elementos que o compõem é bem fácil, pois o processo de decodificação gera um dicionário. Em resumo, quando obtivermos um conteúdo em formato JSON em uma string, podemos usar a função json.loads() para decodificá-lo, transformando-o em um dicionário Python. O contrário também pode ser feito. Podemos transformar um objeto Python em string JSON, como veremos abaixo:

>>> dict_data = {'nome': 'joao da silva', 'idade': 20, 'telefones': ['99999999', '55555555']}
>>> json_str = json.dumps(dict_data)
>>> print json_str
{"idade": 20, "telefones": ["99999999", "55555555"], "nome": "joao da silva"}
>>> type(json_str)
<type 'str'>

A tabela abaixo mostra um resumo das duas funções vistas:

Função Funcionalidade
json.dumps() Transforma um objeto em string JSON.
json.loads() Transforma uma string JSON em objeto.

Acessando a API Web do reddit

Como comentei anteriormente, o pessoal do reddit disponibiliza uma série de informações em formato JSON, que podem ser acessados através de simples requisições HTTP. Chamamos esse conjunto de recursos que o reddit oferece a outros desenvolvedores de API Web, pois é definida uma interface para funções que retornam as informações desejadas em formato JSON. Dê uma olhada na documentação da API web do reddit em: www.reddit.com/dev/api. Vamos analisar rapidinho uma das funções fornecidas nessa API:


GET /new
    after   fullname of a thing
    before  fullname of a thing
    count   
    limit   the maximum number of items desired (default: 25, maximum: 100)
    show    
    target

A documentação acima indica que podemos obter os links mais recentes publicados no reddit através de um GET HTTP no recurso /new, podendo passar os parâmetros listados logo abaixo. Se você clicar no link api.reddit.com/new, o seu browser irá realizar uma requisição GET para o serviço fornecido pela API em api.reddit.com/new e como resultado irá receber um conteúdo JSON que será mostrado a você. Podemos também passar parâmetros para o serviço, como no link api.reddit.com/new?limit=2 onde passamos o parâmetro limit com valor 2, fazendo com que o serviço nos retorne somente os dois links mais recentes.

Você deve estar achando estranho ficarmos acessando conteúdo JSON no browser, afinal não é tão fácil assim ler e entender do que se tratam os valores que vemos na tela, não é? Fique tranquilo, pois essas APIs não foram feitas para que nós, como usuários do browser as acessemos. Elas foram criadas para que a gente escreva programas que acessem tais recursos e então interpretem o JSON retornado.

Sabendo que a API nos fornece acesso aos links mais controversos do momento através do recurso api.reddit.com/controversial, vamos implementar um programinha que busque a lista com os 5 links mais controversos do reddit no momento. O programa deve gerar a seguinte saída:


x/y - Descrição do link - URL do link
x/y - Descrição do link - URL do link
x/y - Descrição do link - URL do link
x/y - Descrição do link - URL do link
x/y - Descrição do link - URL do link

Onde x representa a quantidade de upvotes (votos positivos) e y a quantidade de downvotes (votos negativos) recebidos pelo post.

Talk is cheap, show me the code

sabemos como acessar um recurso na web e como decodificar o JSON recebido como resposta:

import json
import requests
r = requests.get('http://api.reddit.com/controversial?limit=5')
if r.status_code == 200:
    reddit_data = json.loads(r.content)

Até aí tudo tranquilo. A última linha do código acima cria um dicionário contendo o conteúdo JSON convertido para objetos Python. Mas e o que tem dentro desse dicionário?


{
    'kind': 'Listing',
    'data': {
        'modhash': '',
        'children': [{
                'kind': 't3',
                'data': {
                    'domain': 'i.imgur.com',
                    'banned_by': None,
                    'media_embed': {},
                    'subreddit': 'WTF',
                    'selftext_html': None,
                    'selftext': '',
                    'likes': None,
                    'link_flair_text': None,
                    'id': '1ajwg4',
                    'clicked': False,
                    'title': 'This was the disabled toilet at an airport in Myanmar. I was questioned by security for 25 minutes after taking it.',
                    'media': None,
                    'score': 1,
                    'approved_by': None,
                    'over_18': False,
                    'hidden': False,
                    'thumbnail': '',
                    'subreddit_id': 't5_2qh61',
                    'edited': False,
                    'link_flair_css_class': None,
                    'author_flair_css_class': None,
                    'downs': 25,
                    'saved': False,
                    'is_self': False,
                    'permalink': '/r/WTF/comments/1ajwg4/this_was_the_disabled_toilet_at_an_airport_in/',
                    'name': 't3_1ajwg4',
                    'created': 1363673738.0,
                    'url': 'http://i.imgur.com/gRqqYTq.jpg',
                    'author_flair_text': None,
                    'author': 'mfizzled',
                    'created_utc': 1363644938.0,
                    'distinguished': None,
                    'num_comments': 17,
                    'num_reports': None,
                    'ups': 26
                }
            }, 
            // outros elementos foram omitidos para simplificar
        ],
        'after': 't3_1ajoim',
        'before': None
    }
}

Alguns elementos foram ocultados para simplificar. Se quiser ver o JSON completo, clique aqui.

Para obter a lista contendo todos os posts, vamos acessar a chave 'data' no dicionário reddit_data que obtivemos ao decodificar o JSON recebido. O valor relacionado à chave 'data' possui dentro de si um item cuja chave é 'children', que contém a lista de posts. Nessa lista, obtida acessando reddit_data['data']['children'], temos 5 elementos, cada um contendo dois pares chave-valor: kind e data, sendo que este último contém os dados do link em si. Assim, podemos rapidamente verificar quais dados existem dentro de um link:

      print reddit_data['data']['children'][1]['data']
      {
          'domain': 'imgur.com',
          'banned_by': None,
          'media_embed': {},
          'subreddit': 'funny',
          'selftext_html': None,
          'selftext': '',
          'likes': None,
          'link_flair_text': None,
          'id': '1akkpt',
          'clicked': False,
          'title': 'Girls love when boys can cook...(fixed)',
          'media': None,
          'score': 6,
          'approved_by': None,
          'over_18': False,
          'hidden': False,
          'thumbnail': '',
          'subreddit_id': 't52qh33',
          'edited': False,
          'link_flair_css_class': None,
          'author_flair_css_class': None,
          'downs': 43,
          'saved': False,
          'is_self': False,
          'permalink': '/r/funny/comments/1akkpt/girls_love_when_boys_can_cookfixed/',
          'name': 't3<em>1akkpt',
          'created': 1363692074.0,
          'url': 'http://imgur.com/JfOg96S',
          'author_flair_text': None,
          'author': 'backwardsgiant21',
          'created_utc': 1363663274.0,
          'distinguished': None,
          'num_comments': 7,
          'num_reports': None,
          'ups': 49
      }
      


Veja que os atributos em que estamos interessados estão dentro de data. Para imprimir a URL do segundo link da lista, poderíamos fazer:

>>> print reddit_data['data']['children'][1]['data']['url']
http://imgur.com/JfOg96S

Sabendo disso, agora ficou fácil. Basta percorrer os 5 elementos retornados quando acessamos reddit_data['data']['children'] e obter os dados que precisamos desse elemento. Segue o código:

import json
import requests
r = requests.get('http://api.reddit.com/controversial?limit=5')
if r.status_code == 200:
    reddit_data = json.loads(r.content)
    for link in reddit_data['data']['children']:
        print "%s/%s - %s - %s" % (link['data']['ups'], link['data']['downs'], link['data']['title'], link['data']['url'])

Para tornar nosso código mais reusável, podemos extrair uma função do código acima:

import json
import requests
def get_controversial(limit):
    result = []
    r = requests.get('http://api.reddit.com/controversial?limit=%s' % (limit))
    if r.status_code == 200:
        reddit_data = json.loads(r.content)
        for link in reddit_data['data']['children']:
            result.append((link['data']['ups'], link['data']['downs'], link['data']['title'], link['data']['url']))
    return result

Se você ficou com dúvida sobre como acessamos os elementos que foram retornados no JSON, veja novamente o arquivo JSON do exemplo para entender o porquê de termos acessados as chaves 'data', 'children', 'data', 'ups', etc.

Caso tenha entendido tudinho, sugiro que tente resolver o desafio a seguir.

Desafio

Cada link submetido por usuários no reddit pode ser votado, tanto de forma positiva (upvotes) quanto de forma negativa (downvotes). Esses votos são usados para criar o score (pontuação) do link da seguinte forma:


score = upvotes - downvotes

Essa informação está disponível no JSON, podendo ser acessado através da chave 'score'.

Sabendo disso, escreva um programa que, usando a API Web do reddit, busque a lista com os 20 links mais recentes e apresente somente a URL do link que obtiver o melhor score. Mas, aqui você não deverá utilizar o score tradicional. Você deverá usar um score calculado da seguinte forma:


score = upvotes - downvote * 2

Ou seja, um voto negativo anula dois votos positivos do link. E aí, vai encarar?

Webscraping em Python

No post anterior, vimos como fazer requisições HTTP utilizando a excelente requests. A maioria dos documentos disponíveis na web estão em formato HTML, o que não é um grande problema quando acessamos via browser, pois ele é quem faz o trabalho sujo de renderizar o documento pra gente. Mas, se quisermos extrair apenas determinados trechos de informações que podem nos ser úteis, precisaremos percorrer o documento HTML em busca dessas informações, o que não é nada fácil, visto que além de pouca gente seguir os padrões para composição de documentos HTML, muitas vezes os criadores dos sites de onde queremos obter as informações não estão nem um pouco preocupados em classificar as informações que ali disponibilizam, deixando os dados soltos em uma barafunda de table, div, p, etc.

Nesse post vamos ver como fazer Web Scraping, que é a extração de dados de páginas web.

Scraping no reddit

Como já mencionei no post anterior, o reddit é um agregador de conteúdo submetido pelos usuários, e tem vários subreddits voltados a assuntos específicos. Por exemplo, o subreddit programming é um dos meus preferidos, pois além de apresentar as notícias mais relevantes, também apresenta artigos técnicos e discussões de altíssima qualidade. Veja a imagem abaixo, que contém a página inicial desse subreddit:

http2.1

O objetivo desse post é mostrar como fazer um extrator dos principais links submetidos pelos usuários ao reddit programming, usando uma técnica diferente daquela mostrada no final do post anterior.

O resultado esperado é um programinha em linha de comando que gere a seguinte saída:

Descrição do link - URL do link
Descrição do link - URL do link
Descrição do link - URL do link
Descrição do link - URL do link
Descrição do link - URL do link

A primeira coisa que temos que fazer quando queremos desenvolver um extrator de informações da web é entender a estrutura dos documentos HTML de onde vamos retirar a informação. Vamos dar uma olhada no código-fonte do reddit:

http2.2

Na imagem acima, estou usando o developer tools do Chrome para facilitar a visualização das informações do que precisamos no HTML (ctrl+alt+c abre essa ferramenta). Veja que ele já faz o highlighting das informações tanto no código-fonte quanto no documento renderizado. Assim é moleza descobrir o que precisamos extrair do HTML, não? Podemos ver na imagem acima que cada link submetido pelos usuários fica dentro de um elemento p com um atributo class com valor title, como vemos no trecho abaixo (retirado do reddit):

...
    <a class="title " href="http://www.ocamlpro.com/blog/2013/03/14/opam-1.0.0.html">
        OPAM, a new package manager for OCaml is officially released!
    </a>
    <span class="domain">
        (<a href="http://www.reddit.com/domain/ocamlpro.com/">
            ocamlpro.com
        </a>)
    </span>
...

Dentro do elemento p, temos outro elemento, a, que contém um atributo com a URL em si (href) e que tem como conteúdo o título do link, que também é de nosso interesse. A imagem abaixo mostra em mais detalhes uma parte do conteúdo da página que nos interessa.

http2.3

Perceba que precisamos extrair da página várias instâncias de informação como essa mostrada acima, pois para cada link submetido teremos uma estrutura como a apresentada acima. Assim, teremos que procurar por todas as ocorrências de links no documento HTML e extrair essas informações de lá.

Agora que já sabemos onde está a informação que precisamos em meio à bagunça do HTML, chegou o desafio principal, que é extrair essa informação usando um programinha. Mas, antes de meter a mão na massa, vamos conhecer a ferramenta que vai nos possibilitar fazer a extração dos dados de uma forma mais prática: a biblioteca BeautifulSoup.

BeautifulSoup

No post anterior, no último trecho de código, mostrei uma forma meio tosca de buscar a informação no HTML. Vou repetir aquele código aqui para você lembrar sobre o que estou falando:

import requests

def cria_lista_links(content):
    links = []
    for line in content.split('</p>'):
        index = line.find('class="title ')
        if index != -1:
            href_start = line.find('href="', index) + 6
            href_end = line.find('"', href_start)
            links.append(line[href_start:href_end])
    return links

r = requests.get("http://www.reddit.com/r/programming")
print '\n'.join(cria_lista_links(r.content))

É tosca porque não é muito precisa, visto que nossa busca se baseia somente em uma informação textual dentro de um conjunto de linhas com o HTML. Veja que fazemos a busca usando o caractere de " (aspas duplas) ou a string href= como parâmetro. Se o autor da página mudar de aspas duplas para aspas simples, ou de href= para href =, nossa busca já irá parar de funcionar.

A forma mais confiável de fazermos isso é obtida através do parsing (análise sintática) do conteúdo, de forma que ele nos devolva elementos HTML com seus atributos em uma estrutura bem fácil de manipular. Mas, fazer um bom parser para HTML daria bastante trabalho, ainda mais um parser que funcione bem com todas as variações que são usadas em documentos HTML pela web. A boa notícia é que esse parser já existe e está disponível pra gente através da biblioteca BeautifulSoup, que vamos utilizar daqui pra frente.

Analisando código HTML com BeautifulSoup

Considere o HTML apresentado abaixo. Observe com atenção a sua estrutura.

    <html>
        <head>
            <title>Uma página qualquer</title>
        </head>
        <body>
            <div id="content">
                <div class="content-title">
                    Aqui vai um conteúdo 
                    <a class="link" href="http://www.google.com/">qualquer</a>, 
                    um texto sem fundamento algum, escrito sem a mínima 
                    intenção de despertar qualquer interesse por parte
                    do <a class="link-old"> leitor</a>.
                </div>
                <div class="content-author">
                    Escrito por um autor qualquer, que não tinha algo 
                    melhor para escrever.
                </div>
                <div class="content-data">
                    16/03/2013
                </div>
            </div>
            <div class="footer">
                Nenhum direito reservado.
            </div>
        </body>
    </html>

Para entender melhor o HTML acima, vamos ver a árvore de representação dele: http2.4 Agora vamos iniciar um exemplo de análise do HTML acima usando o BeautifulSoup.

import BeautifulSoup

html_data = '''
<html>
    <head><title>Uma página qualquer</title></head>
    <body>
        <div id="content">
            <div class="content-title">
                Aqui vai um conteúdo 
                <a class="link" href="http://www.google.com/">qualquer</a>, 
                um texto sem fundamento algum, escrito sem a mínima 
                intenção de despertar qualquer interesse por parte
                do <a class="link-old"> leitor</a>.
            </div>
            <div class="content-author">
                Escrito por um autor qualquer, que não tinha 
                algo melhor para escrever.
            </div>
            <div class="content-data">
                16/03/2013
            </div>
        </div>
        <div class="footer">
            Nenhum direito reservado.
        </div>
    </body>
</html>'''

soup = BeautifulSoup.BeautifulSoup(html_data)

*Por praticidade, o conteúdo HTML foi inserido em uma string enorme chamada html_data.

Já podemos extrair informações da página, que foi “parseada” na última linha do trecho acima. Perceba que os atributos existentes em cada elemento possuem os mesmos nomes dos elementos no código HTML (.title por exemplo, se refere ao elemento title da página).

print soup.title
#<title>Uma página qualquer</title>

print soup.title.text
# Uma página qualquer

O atributo text de qualquer elemento sempre retorna o texto que está contido em tal elemento. Podemos também encadear o acesso a elementos. Abaixo, estamos acessando o primeiro div do body do HTML analisado.

print soup.body.div
# <div id="content"><div class="content-title">Aqui vai um conteúdo <a class="link" href="http://www.google.com/">qualquer</a>, um texto sem fundamento algum, escrito sem a mínima intenção de despertar qualquer interesse por parte do <a class="link-old"> leitor</a>.</div><div class="content-author">Escrito por um autor qualquer, que não tinha algo melhor para escrever.</div><div class="content-data">16/03/2013</div></div>

Perceba que no trecho de código acima foi impresso somente um dos dois divs que compõem o body (somente o de id content). Olhando para a árvore e para o valor impresso, vemos que foi impressa toda a subárvore do primeiro div do body. Como temos mais de um div dentro do body, quando tentamos acessar o atributo div, nos é retornado somente o primeiro dos divs. Para obter todos os divs do body, podemos fazer assim:

print soup.body.contents
# [u'\n', <div id="content"><div class="content-title">Aqui vai um conteúdo <a class="link" href="http://www.google.com/">qualquer</a>, um texto sem fundamento algum, escrito sem a mínima intenção de despertar qualquer interesse por parte do <a class="link-old"> leitor</a>.</div><div class="content-author">Escrito por um autor qualquer, que não tinha algo melhor para escrever.</div><div class="content-data">16/03/2013</div></div>, <div class="footer">Nenhum direito reservado.</div>, u'\n']

O atributo contents de um elemento qualquer, retorna os elementos que são seus filhos na árvore do HTML. Ou então, podemos percorrer os “filhos” de um elemento, usando o generator childGenerator():

for x in soup.body.childGenerator():
    print x, '\n'

Como resultado, teremos:

<div id="content"><div class="content-title">Aqui vai um conteúdo <a class="link" href="http://www.google.com/">qualquer</a>, um texto sem fundamento algum, escrito sem a mínima intenção de despertar qualquer interesse por parte do <a class="link-old"> leitor</a>.</div><div class="content-author">Escrito por um autor qualquer, que não tinha algo melhor para escrever.</div><div class="content-data">16/03/2013</div></div 

<div class="footer">Nenhum direito reservado.</div>

Além de acessar os elementos filhos de uma tag, podemos também acessar o elemento pai através do atributo parent. Aí vai um exemplo:

a = soup.body.div.a
print a.parent
# <div class="content-title">Aqui vai um conteúdo <a class="link" href="http://www.google.com/">qualquer</a>, um texto sem fundamento algum, escrito sem a mínima intenção de despertar qualquer interesse por parte do <a class="link-old"> leitor</a>.</div>

Como você pode ver, o elemento pai de a é o próprio div que o antecede.

Buscando por elementos específicos

Se quisermos buscar todos os elementos a de uma página HTML, podemos usar o método findAll():

print soup.findAll('a')
# [<a class="link" href="http://www.google.com/">qualquer</a>, <a class="link-old"> leitor</a>]

O método retorna uma lista contendo todas as ocorrências de elementos do tipo procurado. Também podemos obter elementos através de seus atributos id. Em nosso HTML, temos um div com id="content". Podemos obtê-lo com:

print soup.find(id="content")
# <div id="content"><div class="content-title">Aqui vai um conteúdo <a class="link" href="http://www.google.com/">qualquer</a>, um texto sem fundamento algum, escrito sem a mínima intenção de despertar qualquer interesse por parte do <a class="link-old"> leitor</a>.</div><div class="content-author">Escrito por um autor qualquer, que não tinha algo melhor para escrever.</div><div class="content-data">16/03/2013</div></div>

Ou então, buscar por elementos que estejam classificados em uma classe específica:

print soup.find(attrs={'class':'footer'})
# <div class="footer">Nenhum direito reservado.</div>

Enfim, dá pra fazer muita coisa usando a BeautifulSoup. Se quiser conhecê-la melhor, veja a documentação: http://www.crummy.com/software/BeautifulSoup/bs4/doc/.

Implementando o scraper do reddit

Como vimos anteriormente, um link no reddit possui a seguinte estrutura:

...

    <a class="title " href="http://www.ocamlpro.com/blog/2013/03/14/opam-1.0.0.html">
        OPAM, a new package manager for OCaml is officially released!
    </a>
    <span class="domain">
        (<a href="http://www.reddit.com/domain/ocamlpro.com/">
            ocamlpro.com
        </a>)
    </span>

...

Primeiro, precisamos obter o HTML direto do site do reddit:

import requests
import BeautifulSoup

r = requests.get('http://www.reddit.com/r/programming/')
soup = BeautifulSoup.BeautifulSoup(r.content)

Depois, vamos obter cada elemento a que possua o atributo class com valor igual a "title ". Podemos fazer isso usando o método findAll(), percorrendo o resultado e extraindo os atributos que nos interessam (href e text):

for a in soup.findAll('a', attrs={'class': 'title '}):
    print "%s - %s" % (a.text, a.get('href'))

Podemos melhorar o código acima, criando uma função que obtenha a lista de links de um subreddit qualquer:

import requests
import BeautifulSoup

def get_links_from(subreddit):
    links = []
    r = requests.get('http://www.reddit.com/r/%s/' % (subreddit))
    if r.status_code != 200:
        return None

    soup = BeautifulSoup.BeautifulSoup(r.content)

    for a in soup.findAll('a', attrs={'class': 'title '}):
        links.append((a.text, a.get('href')))
    return links

A função acima retorna uma lista contendo tuplas de pares (título do link, URL do link). Assim, podemos percorrer essa lista, imprimindo os valores:

for link_name, link_url in get_links_from('programming'):
    print "%s - %s" % (link_name, link_url)

for link_name, link_url in get_links_from('python'):
    print "%s - %s" % (link_name, link_url)

Está pronto! Barbada, hein? Que tal agora você começar a estudar aquele site de onde você quer extrair informações e implementar um webscraper?

Boa sorte! 🙂

Leitura adicional

Acessando recursos na web com Python

Uma das coisas mais divertidas de se fazer com um computador é programá-lo para que busque informações na web para que não precisemos ficar clicando em um monte de páginas até chegar à informação que desejamos.

Poderíamos escrever um programa para buscar e mostrar os próximos horários de ônibus de determinada linha de uma forma mais amigável do que o portal da empresa de transporte urbano (busaoemfloripa). Ou então, poderíamos agregar várias informações de estações de monitoramento de chuvas e nível de rios para criar um sistema de apoio à população em épocas de cheia dos rios (enchentes.org). E que tal um programinha que busque na web o horário em que o seu programa de TV favorito será transmitido e que emita um alerta no seu desktop quando estiver chegando a hora? São várias as possibilidades de pequenos aplicativos que podem vir a tornar a nossa vida mais prática. Mas, para implementá-los, precisamos saber fazer algumas coisas:

  1. Acessar recursos que estão na web através de nossos programas.
  2. Filtrar os dados que são retornados nesses recursos para que possamos utilizá-los em nosso programa.

Nesse post, veremos como fazer para acessar recursos da web via HTTP. Mais tarde, em um post futuro, veremos como filtrar os dados retornados para usarmos em nossos programas.

Acessando a web com a API Requests

Antes de mais nada, para seguir este post, você precisará instalar o módulo requests.

Instalando o módulo requests

O módulo pode ser instalado via PIP:

$ pip install requests

Outras formas de instalação podem ser vistas em: http://docs.python-requests.org/en/latest/user/install/

Acessando um recurso simples

Usar o módulo requests é muito simples. Vamos começar acessando um recurso simples na web, como a lista de notícias do reddit programming:

>>> import requests
>>> response = requests.get('http://www.reddit.com/r/programming/')
>>> print response.status_code  # 200 significa requisição OK
200
>>> print len(response.content)
87773
>>> print response.content[:100]  # imprimindo só os 100 primeiros chars
<!doctype html><html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en" ><head><title>prog

A função requests.get() obtém um recurso qualquer através de uma URL passada como argumento. O caso acima é o mais simples possível, pois sequer requer autenticação para fazer a requisição. A chamada a essa função retorna um objeto do tipo Response, que dentre outras coisas contém o status da requisição, que é um código numérico indicando o que aconteceu com a requisição. Esse status pode ser checado antes de acessarmos o conteúdo da requisição, para verificar se esta ocorreu com sucesso ou não.

O conteúdo da resposta enviada pelo servidor é armazenado no atributo content da resposta e pode ser acessado como qualquer outro atributo (response.content no código acima). Como você pode ver, o conteúdo retornado foi um tanto quanto grande (uma string de comprimento 87773), e por isso eu trunquei a impressão do conteúdo no código acima.

Possíveis problemas

Vamos tentar acessar um recurso inválido, como: http://www.google.com/umrecursoinvalido. Se tentarmos acessá-lo via browser, teremos a seguinte resposta:

http1

Ou seja, realizamos uma requisição e o status dessa requisição é 404, que ocorre quando conseguimos nos conectar ao servidor, mas este não encontra o recurso solicitado. Veja o que acontece em nosso código:

>>> response = requests.get('http://www.google.com/umrecursoinvalido')
>>> print response.status_code
404

Outro erro comum é fazermos uma requisição para uma URL inexistente (que não possui mapeamento nos DNS), como por exemplo: http://umaurlquenaoapontapranada.com/. Nesse caso, é disparada uma exceção de erro de conexão, visto que não é possível estabelecer uma conexão com o servidor, sendo impossível assim ter um código de status:

>>> response = requests.get('http://umaurlquenaoapontapranada.com')
Traceback (most recent call last):
  File "", line 1, in
  File "/usr/lib/python2.7/dist-packages/requests/api.py", line 52, in get
    return request('get', url, **kwargs)
  File "/usr/lib/python2.7/dist-packages/requests/api.py", line 40, in request
    return s.request(method=method, url=url, **kwargs)
  File "/usr/lib/python2.7/dist-packages/requests/sessions.py", line 229, in request
    r.send(prefetch=prefetch)
  File "/usr/lib/python2.7/dist-packages/requests/models.py", line 605, in send
    raise ConnectionError(e)
requests.exceptions.ConnectionError: HTTPConnectionPool(host='umaurlquenaoapontapranada.com', port=80): Max retries exceeded with url: /

Veja a lista de possíveis códigos de status HTTP em: http://pt.wikipedia.org/wiki/Anexo:Listadecódigosdestatus_HTTP.

Obtendo um recurso com parâmetros

Quando queremos fazer uma requisição a um recurso na web usando um navegador, é comum passarmos alguns parâmetros na própria URL, através de uma requisição HTTP usando o método GET. Por exemplo, para fazer uma busca no Google, devemos passar um parâmetro q para http://www.google.com/search. Para passar o parâmetro via URL basta adicionar um ? ao final e então adicionar os parâmetros e valores ligados por =. Se passarmos mais de um parâmetro, devemos separá-los por &. Veja um exemplo:

http://www.uma.url.qualquer.com/recurso?parametro1=valor1&parametro2=valor2&maiscoisa=continua

Então, para soliciarmos uma busca ao google.com, podemos fazer uma requisição GET à URL:

http://www.google.com/search?q=o+que+quisermos+pesquisar

Podemos passar os parâmetros para a URL através de um dicionário que passamos como entrada à função requests.get(). O dicionário possui o seguinte formato:

{'nome do parametro 1': 'valor do parâmetro 1', 'nome do parâmetro 2': 'valor do parâmetro 2'}

Vamos fazer então uma busca no Google:

>>> response = requests.get("http://www.google.com/search", params={'q': 'busca qualquer coisa'})
>>> print response.status_code == 200
True

A página HTML que nosso browser iria renderizar se fosse ele o cliente da requisição é então armazenada no atributo response.content. Se você der uma observada no conteúdo desse atributo, verá que não parece nada fácil tirar algo útil dali, pois há uma quantidade enorme de ruído em meio à informação. Em outro post veremos como filtrar os dados de forma a “pegar” somente a parte útil da resposta, ignorando o HTML e outros códigos que vem junto com a resposta.

Acesso com autenticação básica

Alguns recursos que queremos acessar exigem uma autenticação HTTP para liberar o acesso. Como por exemplo, tente acessar a seguinte URL: http://httpbin.org/basic-auth/user/passwd. O navegador irá lhe confrontar com a seguinte tela, solicitando as suas credenciais:

http2

Para passar os dados de usuário e senha com a requisição HTTP que estivermos fazendo, basta passsar um parâmetro chamado auth junto com a requisição. Primeiramente, vamos fazer uma requisição sem passar as credenciais:

>>> r = requests.get("http://httpbin.org/basic-auth/user/passwd")
>>> print r.status_code
401

O código 401 indica que a requisição não pode ser completada porque as credenciais de acesso estão incorretas. Agora vamos passar as credencias corretas (nome de usuário é 'user' e a senha é 'passwd'):

>>> r = requests.get("http://httpbin.org/basic-auth/user/passwd", auth=('user', 'passwd'))
>>> print r.status_code
200

Perceba que auth é um parâmetro que recebe uma tupla com os dados do usuário a ser autenticado.

O método POST

O método GET do protocolo HTTP é usado para a obtenção de dados de algum servidor web. Mas, se quisermos que nosso programa envie dados para algum servidor, devemos utilizar o método POST do HTTP.

Fazer requisições POST em um código Python nos permite inúmeras possibilidades, como por exemplo o preenchimento e submissão automática de formulários na web. Vamos testar o post em um serviço de testes, o httpbin:

>>> r = requests.post('http://httpbin.org/post', data={'comentario': 'huaaaaaaa'})
>>> print r.status_code
200
>>> print r.content
{
  "origin": "xxx.xxx.xxx.xxx",
  "files": {},
  "form": {
    "comentario": "huaaaaaaa"
  },
  "url": "http://httpbin.org/post",
  "args": {},
  "headers": {
    "Content-Length": "20",
    "Via": "1.0 PROXY",
    "Accept-Encoding": "identity, deflate, compress, gzip",
    "Connection": "close",
    "Accept": "*/*",
    "User-Agent": "python-requests/0.12.1",
    "Host": "httpbin.org",
    "Cache-Control": "max-age=259200",
    "Content-Type": "application/x-www-form-urlencoded"
  },
  "json": null,
  "data": ""
}

Conseguimos fazer a requisição e recebemos como resposta um recurso que se parece com um dicionário, mas que na verdade é um conteúdo codificado como JSON, que é um padrão para codificação de objetos para troca de mensagens pela rede (o JSON também será visto em um post futuro).

Um exemplo funcional

No início do post, acessamos o reddit.com usando o requests e obtivemos como resposta um monte de código HTML misturado com o conteúdo que nos interessa. Para quem não conhece, o reddit é um agregador de notícias submetidas e votadas pelos seus usuários. Com o slogan “the front page of the internet”, o reddit possui várias categorias e nelas são listadas as principais notícias/artigos do dia. Sabendo disso, vou mostrar um programinha bem simples e tosco que imprime na tela a lista de links da categoria programming do reddit:

import requests

def cria_lista_links(content):
    links = []
    for line in content.split('</p>'):
        index = line.find('class="title ')
        if index != -1:
            href_start = line.find('href="', index) + 6
            href_end = line.find('"', href_start)
            links.append(line[href_start:href_end])
    return links

r = requests.get("http://www.reddit.com/r/programming")
print '\n'.join(cria_lista_links(r.content))

IMPORTANTE: o código acima não é um exemplo de boas práticas!

O código acima busca o conteúdo HTML e percorre esse conteúdo verificando em cada linha se ela possui o texto 'class="title ', o que indica que a linha é um link. Depois, extraímos a URL de cada link e adicionamos à lista de resultado.

Como você pode ver, é bem fácil fazer esse trabalho de filtragem. Basta um pouquinho de paciência, ler o código HTML e descobrir padrões que possam ser buscados para fazer a filtragem. PORÉM, o código acima está longe de ser a melhor solução para o problema. Em um post futuro, veremos a forma correta de “filtrar” e extrair informações úteis de conteúdo HTML, usando um módulo específico para isso. Mas, o exemplo acima foi apresentado justamente para lhe mostrar que você já tem conhecimento suficiente para fazer o seu próprio programinha para filtrar dados das páginas que você gosta de acessar.

Vá em frente e se tiver dúvidas, comente aqui!

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.

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:

mro

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? 🙂

Leia mais: