8809
Comentário:
|
8890
|
Deleções são marcadas assim. | Adições são marcadas assim. |
Linha 17: | Linha 17: |
[[TableOfContents]] | |
Linha 254: | Linha 255: |
>>> filter(lambda s: s > 'a', 'python r0cks!') 'pythonrcks' |
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.
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.
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.
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 os 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ü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] >>> filter(lambda s: s > 'a', 'python r0cks!') 'pythonrcks'
Zip
A função zip retorna uma seqüência seq_ret cujos os elementos são tuplas resultantes de cada um dos elementos de uma ou mais seqüencias 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!