Um aparte

Não usem o blogger para blogs técnicos onde querem meter código. Ainda não consegui arranjar uma forma fácil de garantir que a formatação e identação se mantém intacta. Enfim... agora é tarde e, como tal, peço alguma paciência para com os problemas de formatação deste blog.
Obrigado

Métodos estáticos e Decorators

No último post sobre programação orientada a objectos esequeci-me de referir como declarar métodos static.
Para declarar métodos static, deve-se usar a função built-in staticmethod e deve ser usado da seguinte forma:
class AClass(object):
  def someStaticMethod():
     print 'i am static'
  someStaticMethod = staticmethod(someStaticMethod)

Na realidade, a única diferença entre um método static e um "normal" é que o static não recebe como primeiro argumento o valor do self. Como noutras linguagens, o método static pode ser chamado sobre uma instância dessa classe ou sobre a sua classe.

No entanto, esta forma de definir métodos não é muito simpática. Para resolver isso, o Python suporta um mecanismo adicional, decorators, que irei descrever de seguida.
Um decorator é algo que deve ser posto imediatamente antes da definição do método e tem a forma @nomeDoDecorator
de uma forma geral, @expressao avalia a expressao (que tem de ser um nome, ou uma chamada a funcao), associa esse valor a uma variável temporária (chamemos-lhe __aux) e logo a seguir à avaliação do def

que tem de aparecer a seguir ao decorator, a expressão f = __aux(f) é executada, onde f é o nome posto no def.
Este mecanismo permite uma forma muito simples de contornar a verbosidade da definição de métodos estáticos. Assim:
class AClass(object):
  @staticmethod

  def someStaticMethod():
     print 'i am static'
  
No entanto, este mecanismo pode ser usado em qualquer função, seja ela um método de uma classe ou não. É inclusivé possível criar novos decorators (que são simplesmente funções de ordem superior).
Veja-se um exemplo onde se cria um decorator que faz com que a docstring associda a uma função seja impressa no momento da sua definição. (Exemplo de Python in a Nutshell - Alex Martelli)
def showdoc(f):
  if f.__doc__:
    print '%s: %s' % (f.__name__, f.__doc__)
  else
    print '%s: No docstring!' % f.__name__
  return f




@showdoc
def f1: "a docstring"


@docstring

def f2(): pass

 Quando f1 é definido, a string "f1: a docstring" é impressa. Quando f2 é definido "f2: No docstring!" é impresso.

list comprehensions e generator expressions

Como se viu na criação de listas e dicionários, Python tem formas muito sucintas de criar objectos complexos.
Qualquer programador sabe que é muito comum criar listas cujos elementos são computados no momento. Normalmente usa-se uma qualquer forma de iteração, onde o elemento é primeiro calculado e depois posto dentro da lista. Python suporta esta funcionalidade de uma forma muito simpática, chamada de list comprehensions.

list comprehensions
Uma list comprehension é uma expressão e tem a seguinte sintaxe:


[expression for target in iterable lc-clauses ]

target e expressao têm a mesma semântica que no for.
lc-clauses consiste numa sequência de 0 ou + clausulas, cada uma com a seguinte sintaxe:
for target in iterable
OU
if expression

Exemplos[1] (a lista resultante será posta numa variável para maior claridade):
result = [x+1 for x in someSequence]
significa exactamente o mesmo que:
result = []
for x in someSequence:
  result.append(x+1)

i.e. Para cada elemento de someSequence, este elemento é associado a target,(neste caso x), e expression é avaliada (neste caso x+1) e o seu resultado posto numa lista nova.

Penso que as list comprehensions são uma forma muito expressiva de executar idiomas muito comuns. Vejamos mais exemplos:


result = [x+1 for x in someSequence if x>23]
aqui, depois de x ser associado ao valor vindo de someSequence, a expressão dentro do if é avaliada e se for True então o resultado da avaliação de expression é posto na lista.


Um último exemplo, neste caso usando uma lc-clause na forma de for:
result = [x+y for x in someSequence for y in another]
o que é equivalente a:
result = []
for x in someSequence:
  for y in another:
    result.append(x+y)


[1] - Exemplos retirados de Python in a nutshell - Alex Martelli