Programação Funcional em Python Rudá Moura <ruda@haxent.com.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.
1. 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.
lista = [0, 1, 2, 3, 4, 5] soma = 0 for elem in lista:
- 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üencia para indicar uma tupla, uma string ou uma lista.
# Seqüências tupla = (0, 1, 2) lista = [0, 1, 2] string = 'doesnotcompute'
2. 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.
3. As Funções Embutidas Map, Reduce, Filter e Zip.
3.1. 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.
3.1.1. 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.
3.2. Reduce
A função reduce aplica acumuladamente os ítens de uma seqüência de entrada (da esquerda para a direita) a uma função 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
3.3. Filter
A função filter retorna uma seqüência cujos os valores são os elementos da seqüência de entrada 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 esteja presente o valor de retorno da função é utilizado como valor verdade e apenas os elementos verdadeiros vão fazer parte da seqüência de retorno.
Sintaxe:
filter(func ou None, seq) -> seq_ret
A seqüencia 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] 3.4. Zip A função zip retorna uma seqüência cujos os elementos são tuplas resultantes de cada um dos elementos, de uma ou mais seqüencias de entrada. 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]) Onde 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)] 4. Conclusão Retirado do "Programming FAQ" em python.org, seção 2.12: # Primes < 1000 print filter(None,map(lambda y:y*reduce(lambda x,y:x*y!=0, map(lambda x,y=y:y%x,range(2,int(pow(y,0.5)+1))),1),range(2,1000))) # First 10 Fibonacci numbers print map(lambda x,f=lambda x,f:(x<=1) or (f(x-1,f)+f(x-2,f)): f(x,f), range(10)) # Mandelbrot set print (lambda Ru,Ro,Iu,Io,IM,Sx,Sy:reduce(lambda x,y:x+y,map(lambda y, Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,Sy=Sy,L=lambda yc,Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,i=IM, Sx=Sx,Sy=Sy:reduce(lambda x,y:x+y,map(lambda x,xc=Ru,yc=yc,Ru=Ru,Ro=Ro, 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 >=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( 64+F(Ru+x*(Ro-Ru)/Sx,yc,0,0,i)),range(Sx))):L(Iu+y*(Io-Iu)/Sy),range(Sy ))))(-2.1, 0.7, -1.2, 1.2, 30, 80, 24) # \_ _ \_ _ | | | lines on screen # V V | | columns on screen # | | | maximum of "iterations" # | |_ range on y axis # | range on x axis Magia negra? Concordo!
