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(fn, l)
onde
fn
é uma função que recebe um argumento apenasl
é uma lista
No caso de map
, como o próprio nome sugere, a função map
eia 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 tipoB
; - Uma lista de
A
s.
Analogamente, você tem, como saída, uma lista de B
s.
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
def square(n):
return n * n
il = range(1,6)
ol = map(square, il)
print ol
# => [1, 4, 9, 16, 25]
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)]
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]))
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(fn, l)
onde
fn
é uma função predicadol
é 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]
def filter(fn, l):
if fn is None:
fn = bool
ol = []
for item in l:
if fn(item):
ol.append(item)
return ol
def even(n):
return n % 2 == 0
il = range(10)
ol = filter(even, il)
print ol
# => [0, 2, 4, 6, 8]
reduce(fn, l[, i])
onde
fn
é uma função binárial
é uma listai
é 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
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
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
Thx my dear friendo, still trying to learn till this day.