Resolvi colocar um exemplo para demonstrar o funcionamento
do decorador @classmethod. Como se pode ver na execução,
nesse código, após chamar o método unpack, é criado um novo
objeto do tipo MinhaClasse.


#!/usr/bin/python
# -*- coding: utf-8 -*-

class MinhaClasse:
    def __init__(self, raw, prev):
        print ("Criando a classe MinhaClasse")
        self.raw = raw
        self.prev = prev

    #Método estático unpack
    @classmethod
    def unpack(cls, raw, prev=None):
        print ("Tipo='%s' com o raw='%s' e prev='%s'" % (cls.__name__, raw, prev))
        return cls(raw=raw, prev=prev)

if __name__ == '__main__':
    MinhaClasse.unpack("raw content", "prev content") #Não precisa de instância, o método é chamado como o nome da classe
    #Não precisa informar o valor de cls porque implicitamente ele sabe que deve ser passado o tipo da classe, ou seja "MinhaClasse"

Rodrigo Lira,

 

Como eu já disse anteriormente, no ano passado eu tirei a certificação da Microsoft 70-480 (Programming in HTML5 with Javascript and CSS3). Na ocasião, alguns amigos meus estavam estudando para retirar a certificação por conta própria e eu tinha feito um curso pelo Porto Digital. Para ajudar nos estudos deles, eu acabei agrupando todo os conteúdos do curso e uma séria de questões resolvidas.  Lembro de ter estudado por essas questões e ter tido bastante sucesso fazendo isso.  Por isso resolvi disponibilizar todo o conteúdo aqui.

https://www.dropbox.com/sh/hk8bwsl6wq6886e/sb0zq6xiAe

OBS.: Vi que já tinha publicado um link semelhante, mas num post em inglês. Se você já leu o outro então não vai achar nenhuma novidade aqui.

Ótima ferramenta para ensinar programação em Android

Tudo feito a partir do Drag e Drop e você ainda pode buildar e rodar direto no seu aparelho.

http://appinventor.mit.edu/explore/

Estava desenvolvendo um script e precisava de alguma estrutura que permitisse-me fazer manipulações da seguinte forma:

dicionario[dia][hora][chave1] = x
dicionario[dia][hora][chave2] = y

Ou seja, basicamente criar dicionários aninhados. Eu poderia manipular de forma mais espartana um dicionário e criar uma estrutura aninhada, porém eu queria fazer isso de uma forma mais direta. Queria que essa criação fosse invisível a mim. Dessa forma, eu encontrei o defaultdict. O defaultdict é uma classe do módulo collections em python que faz exatamente o que queria. Infelizmente pra meu azar, essa classe só foi inserida na versão 2.5 da linguagem e a versão que eu tinha disponível no servidor era apenas a 2.4 – old but gold.

Depois de uma pesquisada na internet, encontrei uma implementação da classe defaultdict no qual venho usando desde então nos meus scripts. Abaixo segue a implementação e um exemplo de uso.

CODE

http://pastebin.com/8LDaqW4G
#!/usr/bin/python

class defaultdict(dict):
    def __init__(self, default_factory=None, *a, **kw):
        if (default_factory is not None and
            not hasattr(default_factory, '__call__')):
            raise TypeError('first argument must be callable')
        dict.__init__(self, *a, **kw)
        self.default_factory = default_factory
    def __getitem__(self, key):
        try:
            return dict.__getitem__(self, key)
        except KeyError:
            return self.__missing__(key)
    def __missing__(self, key):
        if self.default_factory is None:
            raise KeyError(key)
        self[key] = value = self.default_factory()
        return value
    def __reduce__(self):
        if self.default_factory is None:
            args = tuple()
        else:
            args = self.default_factory,
        return type(self), args, None, None, self.items()
    def copy(self):
        return self.__copy__()
    def __copy__(self):
        return type(self)(self.default_factory, self)
    def __deepcopy__(self, memo):
        import copy
        return type(self)(self.default_factory,
                          copy.deepcopy(self.items()))
    def __repr__(self):
        return 'defaultdict(%s, %s)' % (self.default_factory,
                                        dict.__repr__(self))

def recursively_default_dict():
    return defaultdict(recursively_default_dict)

if __name__ == '__main__':
    dic = recursively_default_dict()
    dic['a']['b']['c'] = 3
    dic['a']['b']['d'] = 4

    print "dic['a']['b']['d']", dic['a']['b']['c']
    print "dic['a']['b']['d']", dic['a']['b']['d']

After a long time… I’m back!

Now, I going to show you how use python to add borders to an image.


import Image
import ImageOps

if __name__ == '__main__':
    image_name="terminator.jpg"
    new_image_name="terminator_with_border.jpg"
    image_file = Image.open(image_name)
    new_image_file = ImageOps.expand(image_file, border=10, fill='red')
    new_image_file.save(new_image_name)

Input image

Input image

Output image

Output image

That’s all folks!

Esse período foi bastante corrido, mau postei devido a falta de tempo. Foi projeto de Banco de Dados, de Organização de Computadores, Circuitos Digitais Sequenciais, Redes de Computadores entre outros. Ah também tive meu primeiro artigo aceito – A Novel Restoration Algorithm Based on Optical Signal to Noise Ratio for Transparent Optical Network, SBrT 2011.

Abaixo seguem algumas imagens que disso tudo…

 

Plugin desenvolvido para Google Chrome

Justiça seja feita. Tenho que agradecer ao meu grupo por todos esses projetos, Anderson, Sergio, Rodrigo Morais, e Jamersson. Valeu!  Que venha Arquitetura o 7º Período!

Depois que conheci o bot do Google Talk Guru, fiquei curioso em saber como eram feitos esses bots. A princípio pensei que fosse alguma API do Google, até porque o google tem api para tudo, mas acabei descobrindo o IMified.

O IMified, como o próprio site explica, é uma plataforma escalável para criação e hospedagem de bots para IM, através de sua API é possível criar bots para Twitter, Google Talk, AIM, MSN e outros IMs. Bem, por enquanto vou parar por aqui mas nos próximos posts vou fazer um passo a passo para criar um bot para o Gtalk utilizando Python, Google App Engine e o IMified.

It’s working!

Há vários blogs e sites na web que mascaram a URL de algum download com o intuito de lhe vender ou fazer cadastrar em alguma promoção “imperdível”. No inicio isso dava para ser ignorado já que a própia URL da promoção/cadastro contia o destino desejado. Algo como:

http://www.promocaoimperdivel.com.br/?url=http://www.megaupload.com.br/uasdD

Bastava copiar e colar.

Bem, o problema é que a galera hoje em dia está se usando tática de guerra. A URL do destino não está  tão fácil como era antigamente.

Hoje:

http://www.promocaoimperdivel.com.br/?url=Ddsau/rb.moc.daolpuagem.www//:ptth

Qualquer pessoa consegue notar que o destino foi invertido,  reinverter – ou desinverter – a url é necessário. Eu mesmo sempre fazia esses passos

  1. Buscava no google “inverter, desinverter url” – mais rápido que print url[::-1].
  2. Entrava nesse site.
  3. Colava a url invertida.
  4. Clicava lá em “Inverter URL” e pronto.

Bem para mim era algo simples mas chato. Então resolvi hoje colocar a mão na massa e usar o Google App Engine para fazer o meu próprio reinvertedor. O que muda nele é que algumas dessas etapas foram retiradas. Vamos dizer que a época do ctrl+c e ctrl+v na URL voltou.

O funcionamento é  bem simples.

Por exemplo se fulano quisesse reinverter esse caminho /tp/lisarb/gro.ecaepneerg.www//:ptth

Basta digitar no browser o site da aplicação e colocar a url

http://reinverta.appspot.com/?url=/tp/lisarb/gro.ecaepneerg.www//:ptth

Ou seja, fazer uma requisição ao site, passando no argumento url o site a ser reinvertida. Logo após isso, o que vai acontecer é que fulano já seria redirecionado para a URL sem ter que fazer mais nada.

O código é muito simples, basicamente tudo acontece entra as linhas 6 e 8.

from google.appengine.ext import webapp
from google.appengine.ext.webapp.util import run_wsgi_app

class MainPage(webapp.RequestHandler):
	def get(self):
		url = self.request.get('url')
		if url:
			self.redirect(url[::-1])
		else:
			pass # Mostrar pagina estatica

application = webapp.WSGIApplication([('/',MainPage)],debug=False)

def main():
	run_wsgi_app(application)

if __name__ == "__main__":
	main()

Fica ai a dica.

http://reinverta.appspot.com/?url=COLOCAR-URL-A-SER-INVERTIDA

Ahh, por enquanto não está criada a página estática que permitiria reinverter da forma tradicional mas em breve isso vai está funcionando.

Depois que comecei a participar do CIRG, Computational Intelligence Research Group, assisti várias palestras onde a técnica do PSO e sua variações eram utilizadas.Para quem não conhece o PSO (Particle Swarm Optimization) é uma técnica de computação inteligente criado pelos pesquisadores Kennedy e Eberhart em 1995. Sua descoberta foi feita a partir dos estudos do comportamento dos pássaros em um bando em vôo. Enfim, não vou me ater muito a explicar o PSO porque esse não é o foco mas para quem não conhece, recomedo a leitura do artigo que o propôs.

Num desses momentos de loucura eu tive a seguinte ideia:

“Se eu usasse o PSO e a API do Google Elevation para tentar encontrar o Everest?”

Dai para frente foi só implementar o PSO com a ajuda do @serginhfr e ver o que ia acontecer. Alguns detalhes sobre a implementação:

  • O espaço de busca era a Terra ou seja duas dimensões. Latitude: -90° a 90° e Longitude -180° a 180°.
  • Se por acaso a particula saisse do espaço de busca, seria como se ela tivesse dadouma volta na terra. Ex.: Logitude: -200° se tornaria 20°.
  • Foi usado a topologia de comunicação global (Gbest).
  • A função de fitness da particula é calculada fazendo uma requisição a API do Elevation passando o local em que a partícula se encontra no espaço de busca.
import simplejson
from urllib import urlopen
ELEVATION = "http://maps.google.com/maps/api/elevation/json?locations=%f,%f&sensor=false"

class Particle(object):
...
def _fitness(self,position):
   site = ELEVATION %(position.latitude,position.longitude)
   dicionario = simplejson.load(urlopen(site))
   if dicionario['status'] == 'OK':
      fit = dicionario['results'][0]['elevation']
   else:
      raise Exception # Criar uma exception digna.
   return fit

O retorno da requisição a o Elevation é um arquivo json – poderia ser um xml – como esse aqui . É utilizado o metodo load do modulo simplejson para transformar as informações contidas no json em um Dicionário (dict) que é um tipo padrão de Python.

  • A forma de atualizar a velocidade foi a seguinte:
from random import random
class Particle(object):
   ...
   def update_velocity(self,i,gbest):
       w = (0.9-(0.5*(i/self.iteracoes)))
       self.velocity.x = w * self.velocity.x + random()*2.05*(self.pbest.longitude - self.position.longitude) + random()*2.05*(gbest.position.longitude -self.position.longitude)
       self.velocity.y = w * self.velocity.y + random()*2.05*(self.pbest.latitude - self.position.latitude) + random()*2.05*(gbest.position.latitude -self.position.latitude)

Resultados!
Adianto logo que o mais próximo que ele chegou do Everest, foi um ponto na China. Basicamente a melhor partícula sempre se encontra na Antártida. O que me leva a crer que essa minha implementação foi baseada no comportamento dos pinguins  😀

A minha explicação:

  • Realmente a Antártida possui pontos elevados, o 6º ponto mais alto é o Vinson Massif na Antártica com 4.892 m.
  • O formato de topologia de comunicação GBest tem maior probabilidade de deixar o exame presas em pontos de minimo, como o Visson Massif.

Por enquanto ainda não achei o Everest mas quando fizer novos testes mudando o formato de comunicação espero ter melhores resultados.

Visão dos 8 pontos mais altos do mundo