highlight highlight-source-python notranslate position-relative overflow-auto" dir="auto" data-snippet-clipboard-copy-content="pipe([1, 2, 3, 4], lambda x: x+2) # TypeError: can only concatenate list (not "int") to list">

pipe([1, 2, 3, 4], lambda x: x+2) # TypeError: can only concatenate list (not "int") to list

Jaber diz: Estou totalmente perdido, não estou entendo mais nada.

Calma amiguinho, estamos chegando lá.

A função pipe funciona em um único valor:

pipe(4, lambda x: x + 2) # 6

Tá, mas ainda assim ela não acrescenta em nada. Vamos tentar complicar um pouco as coisas:

soma_2 = lambda x: x + 2
soma_4 = lambda x: x + 4

pipe(4, soma_2, soma_4) # 10

Bom, isso também é meio babaca, poderia ser feito com soma_4(soma_2(4)). Mas espera. Somos todos hackers, será que não podemos hackear uma função?

Jaber diz: Aqui é Mr. Robot RAPAZ

Em um outro momento, vamos explicar isso com muita calma, mas agora só o gostinho pra você entender:

from functools import partial

soma_2 = partial(map, lambda x: x + 2)

list(pipe([1, 2, 3, 4], soma_2)) # [3, 4, 5, 6]

Tá, ok. Isso é um map mais complicado, você não acha?

Jaber diz: Achei muito ofensivo, deleta.

A função functools.partial() aplica uma função parcialmente. Mas isso é assunto pra outra hora. Vamos tentar outra vez e eu juro que será a ultima:

from functools import partial

soma_2 = partial(map, lambda x: x + 2)
soma_4 = partial(map, lambda x: x + 4)

list(pipe([1, 2, 3, 4], soma_2)) # [3, 4, 5, 6]
list(pipe([1, 2, 3, 4], soma_4)) # [5, 6, 7, 8]

# O pulo do gato

list(pipe([1, 2, 3, 4], soma_2, soma_4)) # [7, 8, 9, 10]

A função aplicou soma_2() em toda a sequência e no resultado dessa sequência aplicou soma_4(). Se tivéssemos 10 funções como argumentos ele executaria as 10 funções uma no resultado da outra. Tá, mas é complicado implementar isso? Não:

def pipe(seq, *funcs):
    """
    O * nessa função faz com que tudo que for passado após a sequência
      faça parte da lista funcs

    Ele vai iterando na lista de funções e vai jogando o resultado na próxima
      função
    """
    for func in funcs:
        seq = func(seq)
    return seq

Ufa, achei que não íamos acabar nunca essa função, mas no fim deu tudo certo, somos hackers de sequências e somos muito inteligentes.

`twice()`

Nesse momento eu presumo que você lembre que no tópico passado hackeamos a função aplicando parcialmente outra função. Porque agora vamos usar o que aprendemos, mesmo que ainda tenhamos muito pra aprender em um tópico específico sobre aplicações parciais, para hackear a função por definição.

twice() é uma função bem bacana, ela só executa duas vezes a mesma operação em uma sequência. Não é nenhum bicho de sete cabeças e eu espero que você lembre disso.

mul_2 = lambda x: x * 2
twice(10, mul_2) # 40

Vamos pensar, temos uma função que multiplica o valor passado por 2, mul_2(). Passamos 10 e ela devolve 20. Lembra do pipe? Então, o resultado da primeira rodada foi aplicado a segunda.

((10 * 2) * 2) ou seja 40. Outra vez temos uma função que só trabalha com um único valor. Porém, twice() tem um truque na manga. Não só um pois twice() evita aquela chamada chata mul_2(mul_2(10)) o que já é uma coisa muito legal. Mas o que é mais emblemático nessa função nós vamos ver agora:

twice([1, 2, 3], mul_2) # [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

Jaber: Nossa, o que é isso? MEU DEUS, SENHOR JESUS, ARREDA DAQUI SATANÁS

Calma, Jaber. As listas em python implementam um método chamado __mul__, o que faz uma multiplicação ser um pouco diferente. Vamos aplicar a só a multiplicação primeiro:

[1, 2, 3] * 2 # [1, 2, 3, 1, 2, 3]

Isso nada mais é do que repetir a sequência. É 1, 2, 3 duas vezes. O resultado de twice() parece uma coisa maluca porque fez isso duas vezes. O que fez a multiplicação parecer coisa de outro mundo. Só que a função twice() tem uma carta na manga. Um parâmetro opcional chamado _iter:

twice([1, 2, 3], mul_2, True) # <map at ...>

Jaber: É, parei de entender a muito tempo. Tava bom, mas tava ruim também. Agora parece que piorou.

Calma amiguinho, vamos pedir uma lista disso:

list(twice([1, 2, 3], mul_2, True)) # [4, 8, 12]

Jaber: Cada vez mais misterioso está ficando esse curso, tô fora.

Você lembra do pipe hackeado? Esse True ativa o hack. Vamos ver o código:

def twice(val, func, _iter=False):
    from functools import partial
    if not _iter:
        return func(func(val)) # O retorno normal
    else:
        map_part = partial(map, func)
        return map_part(map_part(val)) # O retorno com hack

A função pipe() precisava de uma ajuda para aplicar a função parcial, o que fazia seu estado original sempre trabalhar com um único valor e com auxílio do functools.partial() iterar em uma sequência. Já a função twice() traz isso por definição. Vamos dizer que trabalha com a iteração por definição e pode ser ativada com o parâmetro _iter. Tirando isso a função twice() não tem nada de especial, ela só executa a mesma função duas vezes ao mesmo elemento e caso _iter seja True ela executa a função a uma sequência. Um ponto especial de atenção é que a função retorna o mesmo tipo de dado de entrada, caso _iter não esteja "ativado" a resposta é um iterável do tipo lazy pois o retorno é saída de uma função map().

Conclusões

Com isso acabamos todo nosso discurso sobre funções de ordem superior (HOFs). Se você quiser parar agora, você pode, mas eu juro que a parte mais legal vai começar a rolar agora. Vamos falar de closures, decoradores e algumas substituições modernas para map e filter.

(Roteiro) Nossa primeira biblioteca de funções #20

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions