Programação Funcional em Python - Rudá Moura <ruda@haxent.com.br>BR Dezembro de 2003.

Resumo:

O objetivo desse artigo é explicar de maneira rápida e de fácil entendimento as características funcionais da Linguagem Python (lambda, map, filter e zip). Entende-se aqui como funcional o paradigma de programação utilizado em linguagens como Lisp e Scheme. O leitor não deve se assustar pois não será necessário contar parênteses para tirar proveito dessas características em Python, (((isto foi uma piada))).

O aspecto funcional de Python permite escrever código compacto e eventualmente mais rápido, por outro lado corre-se o risco de deixar o código obscuro e de manutenção mais complicada. Tenha bom senso e cuidado com o seu uso.

TableOfContents

Primeiras Palavras

Uma das vantagens da linguagem Python está no seu rico conjunto de estruturas de dados disponíveis ao programador. Entre essas estruturas destaca-se a lista. A lista é um tipo de dado dinâmico (pode aumentar ou diminuir de tamanho) e mutável (seus elementos individuais podem ser alterados) utilizado para armazenar outros tipos de dados, inclusive outras listas.

O Python provê um conjunto de funções que podem ser aplicados a listas. Pode-se inserir ou remover elementos, classificar, tratar a lista como se fosse uma pilha entre outros. É comum também "caminhar" entre os seus elementos, como no exemplo a seguir.

   1 lista = [0, 1, 2, 3, 4, 5]
   2 soma = 0
   3 for elem in lista:
   4     soma = soma + elem

Uma tupla é semelhante a uma lista mas esta é estática (não possui métodos para inserir ou remover elementos) e imutável (os elementos individuais não podem ser alterados). Uma string, que também é um tipo estático e imutável, pode ter um tratamento análogo ao de uma lista. Define-se então o termo seqüência para indicar uma tupla, uma string ou uma lista.

   1 # Seqüências
   2 tupla = (0, 1, 2)
   3 lista = [0, 1, 2]
   4 string = 'doesnotcompute'

A Expressão Lambda

Uma expressão lambda permite escrever funções anônimas ou sem-nome usando apenas uma linha de código.

Sintaxe:

lambda [ var1, var2, ..., varN ]: expr -> expr_ret

Onde var1, var2, ..., varN são variáveis que representam o argumento da função e expr é qualquer expressão válida em Python envolvendo essas variáveis. O resultado é uma nova expressão expr_ret.

Um exemplo prático de lambda é uma função que recebe dois valores (x e y) e retorna a soma desses elementos.

Exemplos:

>>> lambda x, y: x+y
<function <lambda> at 0x81a8d84>

Como posso obter algo útil, por exemplo 1+2?

>>> (lambda x, y: x+y)(1,2)
3

Uma maneira de "lembrar" uma expressão lambda é guardá-la em uma variável.

>>> soma = lambda x, y: x+y
>>> soma
<function <lambda> at 0x81a8e2c>
>>> soma(1, 2)
3

Aparentemente lambda sozinho não tem muita graça ou utilidade, mas nas seções que se seguem faremos melhor uso dela.

As Funções Embutidas Map, Reduce, Filter e Zip

Map

A forma mais simples de se usar o map é aplicando uma função func a uma seqüência seq, o resultado é sempre uma lista cujo os elementos são obtidos aplicando-se individualmente cada elemento de seq a função func. Ao mapear-se uma lista com None retorna-se os elementos originais da seqüência.

Sintaxe:

map(func ou None, seq) -> lista

Exemplos:

>>> map(None, [1, 3, 5])
[1, 3, 5]

>>> map(abs, [-1, -2, -3])
[1, 2, 3]

>>> map(str, [2, 4, 6])
['2', '4', '6']

>>> map(hex, (10, 11, 12))
['0xa', '0xb', '0xc']

Um exemplo mais interessante com uso da expressão lambda.

>>> map(lambda x: x*x*x, [1, 2, 3, 4])
[1, 8, 27, 64]

Em resumo, se oferecermos uma função ao map, teremos que:

lista[0] = func(seq[0])
lista[1] = func(seq[1])
...
lista[M-1] = func(seq[M-1])

Onde M é o tamanho de seq.

Map Completo

A forma completa de map admite uma função func (ou None) e um conjunto de seqüencias (seq1, seq2, ..., seqN) como parâmetros.

Sintaxe:

map(func ou None, seq1, seq2, ..., seqN) -> lista

Atribuindo-se None ao map este retorna sempre uma tupla de N elementos que são os elementos cuja ordem deles é a ordem das seqüencias até o tamanho da maior lista, índices maiores que as seqüências são retornados como None.

Exemplos:

>>> map(None, [1, 3, 5], [2, 4, 6])
[(1, 2), (3, 4), (5, 6)]

>>> map(None, [1, 3, 5], [2, 4, 6, 8, 10])
[(1, 2), (3, 4), (5, 6), (None, 8), (None, 10)]

>>> map(None, (1, 3, 5), (2, 4, 6), (2, 4, 8, 16, 32))
[(1, 2, 2), (3, 4, 4), (5, 6, 8), (None, None, 16), (None, None, 32)]

Se atribuirmos uma função para map, teremos sempre que:

lista[0] = func(seq1[0], seq2[0], ..., seqN[0])
lista[1] = func(seq1[1], seq2[1], ..., seqN[1])
...
lista[M-1] = func(seq1[M-1], seq2[M-1], ..., seqN[M-1])

Onde M é o tamanho da maior lista entre seq1, seq2, ..., seqN.

Fica fácil entender que se oferecermos ao map três listas é necessário então que a função aceite três variáveis como parâmetro. As seqüencias menores que M são automaticamente preenchidas com o valor None e isso pode ser um inconveniente caso se tente aplicar a uma função que espera valores numéricos, pois None nunca é tratado como um valor numérico.

Exemplos:

>>> map(lambda x, y: x*y, [1, 3, 5], [2, 4, 6])
[2, 12, 30]

>>> map(lambda a, b, x: a*x+b, [1, 3, 5], [2, 4, 8], [0, 0, 0])
[2, 4, 8]

>>> map(pow, [2, 4, 6], [2, 2, 2, 2])
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: unsupported operand type(s) for ** or pow(): 'NoneType' and 'int'

Oops.

Reduce

A função reduce aplica acumuladamente os ítens de uma seqüência de entrada seq(da esquerda para a direita) a uma função func de dois parâmetros até reduzir esse cálculo a um único valor de resposta. Opcionalmente pode-se atribuir um valor inicial como parâmetro.

Sintaxe:

reduce(func, seq[, inicial]) -> valor

Exemplos:

>>> reduce(lambda x, y: x+y, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
55

>>> reduce(lambda x, y: x+y, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 100)
155

Filter

A função filter retorna uma seqüência seq_ret cujos valores são os elementos da seqüência de entrada seq que respeitam o seguinte critério: se a função for None os elementos que são verdadeiros são adicionados, caso uma função func esteja definida o valor de retorno da função é utilizado como valor verdade e apenas esses elementos vão fazer parte da seqüência de retorno.

Sintaxe:

filter(func ou None, seq) -> seq_ret

A seqüência seq_ret tem sempre o mesmo tipo de seq.

Exemplos:

>>> filter(None, [0, 1, 2, None, 2>1, '', 'ola'])
[1, 2, True, 'ola']

>>> filter(lambda x: x > 3, [0, 1, 2, 3, 4, 5])
[4, 5]

>>> filter(lambda s: s > 'a', 'python r0cks!')
'pythonrcks'

Zip

A função zip retorna uma seqüência seq_ret cujos elementos são tuplas resultantes de cada um dos elementos de uma ou mais seqüências de entrada seq1, seq2, ..., seqN. A seqüência resultante é sempre truncada ao tamanho da menor seqüência apresentada.

Sintaxe:

zip(seq1, seq2, ..., seqN) -> seq_ret

Onde seq_ret é obtida através do seguinte logicismo:

seq_ret[0] = (seq1[0], seq2[0], ..., seqN[0])
seq_ret[1] = (seq1[1], seq2[1], ..., seqN[1])
...
seq_ret[m-1] = (seq1[m-1], seq2[m-1], ..., seqN[m-1])

O valor de m é o comprimento da menor lista em seq.

Exemplos:

>>> zip([1, 3, 5], [2, 4, 6])
[(1, 2), (3, 4), (5, 6)]

>>> zip([1, 3, 5], [2, 4, 6, 8, 10])
[(1, 2), (3, 4), (5, 6)]

Conclusão

Retirado do "Programming FAQ" em python.org, seção 2.12:

   1 # Primes < 1000
   2 print filter(None,map(lambda y:y*reduce(lambda x,y:x*y!=0,
   3 map(lambda x,y=y:y%x,range(2,int(pow(y,0.5)+1))),1),range(2,1000)))
   4 
   5 # First 10 Fibonacci numbers
   6 print map(lambda x,f=lambda x,f:(x<=1) or (f(x-1,f)+f(x-2,f)): f(x,f),
   7 range(10))
   8 
   9 # Mandelbrot set
  10 print (lambda Ru,Ro,Iu,Io,IM,Sx,Sy:reduce(lambda x,y:x+y,map(lambda y,
  11 Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,Sy=Sy,L=lambda yc,Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,i=IM,
  12 Sx=Sx,Sy=Sy:reduce(lambda x,y:x+y,map(lambda x,xc=Ru,yc=yc,Ru=Ru,Ro=Ro,
  13 i=i,Sx=Sx,F=lambda xc,yc,x,y,k,f=lambda xc,yc,x,y,k,f:(k<=0)or (x*x+y*y
  14 >=4.0) or 1+f(xc,yc,x*x-y*y+xc,2.0*x*y+yc,k-1,f):f(xc,yc,x,y,k,f):chr(
  15 64+F(Ru+x*(Ro-Ru)/Sx,yc,0,0,i)),range(Sx))):L(Iu+y*(Io-Iu)/Sy),range(Sy
  16 ))))(-2.1, 0.7, -1.2, 1.2, 30, 80, 24)
  17 #    \___ ___  \___ ___  |   |   |__ lines on screen
  18 #        V          V      |   |______ columns on screen
  19 #        |          |      |__________ maximum of "iterations"
  20 #        |          |_________________ range on y axis
  21 #        |____________________________ range on x axis

Magia negra? Concordo!