Fawers/resumo_funcoes.md

## resumo_funcoes.md

      
    Raw
  

              resumo_funcoes.md
            
          
    Resumo: funções

map, zip, filter e reduce

Diferenças entre Python 2.x e Python 3.x

Em Python 2.x, essas funções devolvem listas enquanto que, em Python 3, devolvem
geradores. Para usar estes geradores como listas (assim como em Python 2.x),
apenas aplique list ao resultado.

Por exemplo:
resultado = map(funcao, lista)
resultado = list(resultado)
# ou simplesmente
resultado = list(map(funcao, lista))


Conteúdo


map


zip


filter


reduce


map

Sintaxe:

map(fn, l)

onde

fn é uma função que recebe um argumento apenas
l é uma lista

No caso de map, como o próprio nome sugere, a função mapeia valores de uma
lista usando uma função. Em termos matemáticos, map : (A → B) × [A] → [B].
Ou seja, os argumentos de entrada são:

Uma função que mapeia valores do tipo A para o tipo B;
Uma lista de As.

Analogamente, você tem, como saída, uma lista de Bs.
Implementação usando Python:

def map(fn, l):
    if fn is None:
        fn = lambda o: o
    ol = [] # output list
    for item in l:
        ol.append(fn(item))
    return ol
Exemplo:

def square(n):
    return n * n

il = range(1,6)
ol = map(square, il)
print ol

# => [1, 4, 9, 16, 25]

zip

Sintaxe:

zip(l1, l2, ..., ln)

onde

l1, l2, ..., ln são listas

O trabalho de zip é juntar elementos de variadas listas em apenas uma lista de
tuplas. Essencialmente, zip junta o primeiro elemento de todas as listas em
uma tupla, depois o segundo elemento em outra tupla, e assim por diante.

A saída de zip é uma lista de tuplas cujo comprimento é igual ao comprimento
da menor lista de entrada.

Assinatura: zip : [A] × [B] × ... × [Z] → [(A,B,...,Z)]
Implementação usando Python (com 2 listas):

def zip(l1, l2):
    ol      = [] # output list
    min_len = min(len(l1), len(l2))
    for i in range(min_len):
        ol.append((l1[i],l2[i]))
Exemplo:

a = [1,2,3,4,5,6]
b = 'ABCDEF'
c = zip(a, b)
print c

# => [(1,'A'),(2,'B'),(3,'C'),(4,'D'),(5,'E'),(6,'F')]

filter

Sintaxe:

filter(fn, l)

onde

fn é uma função predicado
l é uma lista

filter, como o próprio nome sugere, é uma função que filtra elementos de uma
lista dado um certo predicado. Uma função predicado é uma função que, passado
um argumento, devolve true ou false. Ou seja, T → Bool, sendo T um tipo.

filter aplica fn em cada elemento da lista e devolve uma nova lista apenas
com os elementos para os quais fn(elemento) resultou em true.

Assinatura: filter : (A → Bool) × [A] → [A]
Implementação em Python:

def filter(fn, l):
    if fn is None:
        fn = bool
    ol = []
    for item in l:
        if fn(item):
            ol.append(item)
    return ol
Exemplo:

def even(n):
    return n % 2 == 0

il = range(10)
ol = filter(even, il)
print ol

# => [0, 2, 4, 6, 8]

reduce

Sintaxe:

reduce(fn, l[, i])

onde

fn é uma função binária
l é uma lista
i é um valor inicial (opcional)

Algumas linguagens possuem a função reduce (também chamada de fold) para
ajudar a reduzir uma lista de valores a um valor apenas. reduce faz uso de
uma função binária, ou seja, uma função que tem 2 parâmetros de entrada para
ajudar na redução dos valores. O exemplo mais prático e fácil de reduce é o de
somar todos os números de uma lista. Supondo que add seja uma função que
adicione dois números, reduce(add, [1,2,3,4]) resultaria em 10.

Assinatura: reduce : (A × A → A) × [A] × A → A
Implementação em Python:

def reduce(fn, l, i=None):
    if not l:
        if i is None:
            raise TypeError("lista vazia e nenhum valor inicial")
        else:
            return i
    else:
        if i is None:
            o = l.pop(0)
        else:
            o = i
        for item in l:
            o = fn(o, item)
        return o
Exemplo:

def add(a, b):
    return a + b

l = range(1,11)
o = reduce(add, l)
print o
# => 55
o = reduce(add, [], 0)
print o
# => 0