Aula 18 – Python – Programação funcional
Aula 18 – Python – Programação funcional
Python – Programação funcional
Que fazer esse curso com certificação?
Acesse:
https://workover.com.br/python-codigo-fluente
Voltar para página principal do blog
Todas as aulas desse curso
Strength training, injury prevention, explosiveness: 4 tips to follow to progress without injuring yourself beachbody supplements myfitnesspro free weight training.
Aula 17 Aula 19
Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook
Esse é o link do código fluente no Pinterest
Meus links de afiliados:
Hostinger
Digital Ocean
One.com
Automatize tarefas do dia a dia com python:
Curso Python Bot
Seguindo 😉
Programação funcional em python
De acordo com o wikipedia, programação funcional é um paradigma de programação, ou seja, um estilo de construção da estrutura e dos elementos de programas de computador, que trata a computação como a avaliação de funções matemáticas e evita a mudança de estado e dados mutáveis.
Essas funções são chamadas de pure function, ou função pura.
Ela é uma função onde o resultado é apenas determinado pelos seus parâmetros de entrada, sem depender de fatores externos (APIs, sistema de arquivos, qualquer dependência que possa alterar o resultado de uma função).
Dessa forma, uma função pura retornará sempre o mesmo resultado para os mesmos parâmetros de entrada.
Essas funções podem ser aplicadas em sequências de dados (geralmente listas).
Imagine uma lista de preços em que você precisa adicionar 10% em todos os produtos da lista.
Em uma abordagem tradicional, poderíamos pensar em algo assim:
prices = [50, 60, 70]
newPrices = []
for price in prices:
newPrice = price * 1.1
newPrices.append(newPrice)
# Saída
# [55.00000000000001, 66.0, 77.0]
Utilizando o método map(), teríamos esse resultado:
prices = [50, 60, 70]
list(map(lambda price: price * 1.1 , prices))
# Saída
# [55.00000000000001, 66.0, 77.0]
Vantagens:
- Melhor legibilidade e manutenibilidade do código
- Código simples e conciso
- Imutabilidade. O resultado da nova lista nunca irá alterar os valores da lista original.
A lista abaixo mostra algumas linguagens de programação funcional:
- LISP
- Scheme
- Haskell ( influenciou diretamente o Python )
O python não é uma linguagem funcional, mas dá suporte a múltiplos paradigmas de programação, inclusive o funcional.
As operações básicas do paradigma funcional são implementadas no Python pelas funções internas map() e filter().
Lambda
Funções lambda são muito usadas em programação funcional.
No Python, a função anônima é uma função que é definida sem um nome.
As funções normais são definidas usando a palavra-chave def, já as anônimas são definidas usando a palavra-chave lambda.
As funções lambda podem ter apenas uma linha, e podem ser atribuídas a uma variável.
As funções lambda podem ter qualquer número de argumentos, mas, apenas uma expressão.
A expressão é avaliada e retornada.
Usamos funções lambda quando precisamos de uma função sem nome por um curto período de tempo.
Sintaxe:
lambda arguments: expression
# Uso básico de funções lambda
dobro = lambda x: x * 2
# Saída: 10
print(dobro(5))
No programa acima, lambda x: x * 2 é a função lambda.
Onde x é o argumento e x * 2 é a expressão que é avaliada e retornada.
Esta função não tem nome.
Ele retorna um objeto de função que é atribuído ao identificador dobro.
Podemos agora chamá-lo como uma função normal.
A declaração:
double = lambda x: x * 2
É quase a mesma coisa que:
def double(x):
return x * 2
As funções Lambda são usadas junto com funções como filter(), map(), reduce() etc.
Exemplo de uso com filter()
A função filter() no Python recebe uma função e uma lista como argumentos.
A função é chamada com todos os itens da lista e uma nova lista é retornada, contendo itens que a função avalia como True.
Aqui está um exemplo de uso da função filter() para filtrar apenas números pares de uma lista.
# Programa para filtrar apenas os itens pares de uma lista
lst = [1, 5, 4, 6, 8, 11, 3, 12]
new_lst = list(filter(lambda x: (x % 2 == 0) , lst))
# Saída: [4, 6, 8, 12]
print(new_lst)
Exemplo de uso com map()
A função map() no Python recebe uma função e uma lista.
A função é chamada com todos os itens da lista e uma nova lista é retornada, contendo itens retornados por essa função para cada item.
Aqui está um exemplo de uso da função map() para duplicar todos os itens em uma lista.
# Programa para dobrar cada item em uma lista usando map()
lst = [1, 5, 4, 6, 8, 11, 3, 12]
new_lst = list(map(lambda x: x * 2 , lst))
# Saída: [2, 10, 8, 12, 16, 22, 6, 24]
print(new_lst)
Exemplo de uso com reduce()
# reduce() não é mais builtin no python 3, por isso o import abaixo
from functools import reduce
def soma(x1, x2):
return x1 + x2
# Saída: 10
print(reduce(soma, [1, 2, 3, 4]))
Outro exemplo do reduce()
from functools import reduce
# Calcula o fatorial de n
def fat(n):
return reduce(lambda x, y: x * y, range(1, n))
# Saída: 720
print(fat(7))
Exemplo do zip()
Esta função retorna uma lista de tuplas, onde a i-ésima tupla contém o i-ésimo elemento de cada um dos argumentos.
x = [1, 2, 3]
y = [4, 5, 6]
for t in zip(x, y):
print(t)
#Saída:
#(1, 4)
#(2, 5)
#(3, 6)
A função zip() retorna uma sequência de tuplas.
Lista com tamanhos diferentes serão emparelhadas e a diferença entre elas será desconsiderada.
lst_a = [6, 7, 8, 9]
lst_b = [1, 2, 3, 4, 5]
for x in zip(lst_a, lst_b):
print(x)
"""
(6, 1)
(7, 2)
(8, 3)
(9, 4)
"""
A função zip() aponta para o objeto instanciado:
x = [1, 2, 3]
y = [4, 5, 6]
zip(x, y)
<zip object at 0x7faded7b3608>
Para vermos a lista precisamos passá-la para a função interna list().
x = [1, 2, 3]
y = [4, 5, 6]
list(zip(x, y))
#Saída
[(1, 4), (2, 5), (3, 6)]Veja a diferença entre um mesmo código na forma imperativa e na funcional:
Imperativo
# Gera uma lista da string de forma imperativa
string = 'Python'
lst = [] # estado inicial
for l in string:
lst.append(l) # cada iteração gera um novo estado
print(lst) # ['P', 'y', 't', 'h', 'o', 'n']
Funcional
# Gera uma lista da string de forma funcional
string = lambda x: x
lst = list(map(str, string('Python'))) # atribuição a um novo objeto
print(lst) # ['P', 'y', 't', 'h', 'o', 'n']
List Comprehension
Em computação, List Comprehension é uma construção que equivale a notação matemática do tipo:
S = {x^2 ∀ x em ℕ, x>=20}
Ou seja, S é o conjunto formado por x ao quadrado para todo x no conjunto dos naturais, se x for maior ou igual a 20.
Sintaxe:
lista = [ <expressão> for <referência> in <sequência> if <condição> ]
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
# Eleve os ímpares ao quadrado
print([ x**2 for x in nums if x % 2 ])
# Saída
#[1, 9, 25, 49, 81, 121]
List Comprehension é mais eficiente do que usar as funções map() e filter() em relação a processamento e consumo de memória.
Generator Expressions
Gerador é um iterável criado usando uma função com uma declaração yield.
A principal característica de um gerador é avaliar os elementos sob demanda.
Quando você chama uma função normal com uma instrução de retorno, a função é finalizada sempre que encontrar uma instrução de retorno.
Em uma função com uma instrução yield, o estado da função é “salvo” da última chamada e pode ser selecionado na próxima vez que você chamar uma função geradora.
Generator Expression usa menos recursos do que o List Comprehension, pois os itens são gerados um de cada vez, apenas quando necessário, economizando principalmente memória.
A sintaxe e o conceito são semelhantes aos de uma List Comprehension.
Em termos de sintaxe, a única diferença é que você usa parênteses em vez de colchetes.
O tipo de dado retornado por List Comprehension e Generator Expression é diferente.
gen_exp = (x ** 2 for x in range(10) if x % 2 == 0)
list(gen_exp)
# Saída
# [0, 4, 16, 36, 64]
