Programação Funcional em Python - Paradigmas de Programação Funcional

Paradigmas de Programação
Ronaldo F. Ramos
Instituto Federal do Ceará
28 de outubro de 2023

PARTE 3 - PARADIGMA FUNCIONAL
PROGRAMAÇÃO FUNCIONAL EM PYTHON
AULA 1/1
Ronaldo F. Ramos Instituto Federal do Ceará

Roteiro
• Programação Funcional em Python

Definição
Em ciência da computação, programação funcional é um paradigma de programação
que trata a computação como uma avaliação de funções matemáticas e que evita
estados ou dados mutáveis. Ela enfatiza a aplicação de funções, em contraste da
programação imperativa, que enfatiza mudanças no estado do programa 1 2
1
Fonte: Wikipedia
2
Paul Hudak (setembro de 1989). "Conception, evolution, and application of functional
programming languages"(pdf) . ACM Computing Surveys.

Foco da Programação Funcional
• Manutenibilidade
• Testabilidade

Um Programa Simples Não Funcional em Python
1 from datetime import datetime
2 class SaudacaoEntrada :
3 def __init__(self):
4 hora_atual = datetime.now()
5 if hora_atual.hour < 12:
6 self. SaudacaoEntrada = "Bom Dia"
7 elif 12 <= hora_atual.hour < 18:
8 self. SaudacaoEntrada = "Boa Tarde"
9 else:
10 self. SaudacaoEntrada = "Boa Noite"
11 def sauda(self, nome):
12 print(f"{self. SaudacaoEntrada }, {nome}.")

Continuação do Programa
1 def main ():
2 name = input("Digite o seu nome ")
3 Saudacao = SaudacaoEntrada ()
4 Saudacao.sauda(name)
5
6 if __name__ == "__main__":
7 main ()

Efeitos Colaterais - Side Effects
Problemas do ponto de vista da programação funcional(efeitos colaterais)
• A função construtora modifica variáveis fora do seu escopo
• As funções internas (não main) executam operações de entrada e saída
A existência de efeitos colaterais nos programas dificulta a compreensibilidade do
programa e sua manutenibilidade. Além disso o fato das variáveis serem mutáveis
também contribui para dificultar a rastreabilidade do mesmo.

Testabilidade
Procedimentos com efeitos colaterais, por não serem isolados, dificultam o processo de
testes.

Exemplos de Efeitos Colaterais
• Imprimir alguma coisa
• Ler um arquivo
• Escrever em um arquivo
• Interagir com uma base de dados

Reduzindo os efeitos colaterais
2 class Saudacoes:
3 # a classe será autocontida e não realiza operações de E/S
4 def __init__(self, saudacao):
5 self. saudacaoIntrodutoria = saudacao
6
7 # a função retorna a string ao invés de imprimí-la
8 def sauda(self, nome):
9 return f"{self. saudacaoIntrodutoria }, {nome}."

As opereções de E/S são transferidas para a main()
1 def main ():
2 # criacao do objeto fora do escopo da classe Saudacoes
5 saudacao_inicial = "Bom dia"
7 saudacao_inicial = "Boa Tarde"
8 else:
9 saudacao_inicial = "Boa Noite"
10
11 nome = input("Entre com o seu nome:")
12 saudacao = Saudacoes( saudacao_inicial )
13 print(saudacao.sauda(nome))

Sem Classes e Objetos
Programas não necessariamente precisam de classes e objetos. Classes e Objetos
podem tornar programas mais complexos e até mais lentos.

Somente com funções
Ao separar as responsabilidades em funções teremos:
2
3 def sauda(nome, saudacao_inicial ):
4 return f"{ saudacao_inicial }"
5
6 def definir_saudacao ():
9 return "Bom dia"
11 return "Boa tarde"
12 else:
13 return "Boa noite"

Função main
Temos um programa completamente funcional sem uso de maiores recursos.
1 def ler_nome ():
2 return input("Digite o seu nome: ")
3
4 def main ():
5 print(sauda(ler_nome (), definir_saudacao ()))
6
7 if __name__ == "__main__":
8 main ()

Funções Puras ou Impuras
Definição
Uma função é considerada pura se é livre de efeitos colaterais, caso contrário é
chamada de impura.

Cidadãos de Primeira Classe
Em ambientes funcionais as funções podem (devem) ser passadas como argumentos
em outras funções

Funções como Argumentos
2 # a variavel leitor_saudacoes receberá uma função
3 def sauda(nome, leitor_saudacoes ): # :LeitorSaudacao
4 if nome == "ronaldo":
5 return "Grande Ron"
6 # a função recebida é chamada aqui
7 return f"{ leitor_saudacoes ()}, {nome}."
8 def ler_saudacao ():
11 return "Bom dia"
13 return "Boa Tarde"
14 else:
15 return "Boa Noite"

Funções como Argumentos - Continua
Observe que para que uma função seja passada como argumento em Python basta
remover os ()
1 def ler_nome ():
2 return input("Entre com o seu nome: ")
3
4 def main () -> None:
5 # chamada de função passando função como argumento
6 print(sauda(ler_nome (), ler_saudacao))
7
8 if __name__ == "__main__":
9 main ()

Partials
Com partials podemos fixar um certo número de argumentos com valores prefixados
2 from functools import partial
3 def sauda(nome, leitor_saudacao ):
4 if nome == "ronaldo":
5 return "Grande Ron"
6 return f"{ leitor_saudacao ()}, {nome}."
7 def ler_saudacoes ():
10 return "Bom dia"
12 return "Boa Tarde"
13 else:
14 return "Boa Noite"

Partials - main
1 def ler_nome ():
2 return input("Entre com seu nome: ")
3
4 def main ():
5 # seta o valor de leitor_saudacao da função original
6 funcao_sauda = partial(sauda, leitor_saudacao =ler_saudacoes)
7 print(funcao_sauda(ler_nome ()))
8
9 if __name__ == "__main__":
10 main ()

Imutabilidade
Em ambientes funcionais as variáveis são associadas a expressões e seus valores se
tornam imutáveis. Linguagens como python usam as duas possibilidades. Vejamos
alguns exemplos.
1 import random
2 def main () -> None:
3 lista_para_testar = [120, 68, -20, 0, 5, 67, 14, 99]
4 # Usando ordenamento com imutabilidade mantém a listas original
intacta
5 lista_ordenada = sorted( lista_para_testar )
6 print(f"Lista original: { lista_para_testar }")
7 print(f"Lista ordenada: { lista_ordenada}")
8 # ordenamento com modificação da lista original
9 lista_para_testar .sort ()
10 print(f"Lista original: { lista_para_testar }")

Imutabilidade - Continuação
1 # outros exemplos de operações mutáveis e imutáveis
2 cartas = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q",
"K", "A"]
3
4 cartas_embaralhadas = random.sample(cartas, k=len(cartas))
5 print(f"Cartas embaralhadas: { cartas_embaralhadas }")
6 print(f"Cartas originais: {cartas}")
7
8 random.shuffle(cartas) # embaralha cartas (mutável)
9 print(f"cartas: {cartas}")
10
11 if __name__ == "__main__":
12 main ()

Mutabilidade x Imutabilidade
Um objeto pode ser também mutável ou imutável se o seu estado pode ser modificado
após a criação. As linguagens híbridas como python podem ter elementos pertencentes
a uma ou outra categorias.

Objetcos x Variáveis em Python
Definições:
• Variáveis são referências para objetos.
• Objetos são elementos delimitados em um espaço de memória concreto.

Objetos em Python
Em Python tudo são objetos: números, strings, funções, classes, etc.
Os objetos possuem as seguintes caractarísticas:
• Valor
• Identidade
• Tipo

Verificando o valor do objeto
Os valores dos objetos são instâncias de tipos primitivos como int, float, etc ou ainda
definidos pelo programador. Podemos verificar estes valores e seus tipos através do
isinstance.
1 >>> isinstance (28,int)
2 True
3
4 >>> isinstance (3.14,float)
5 True

Verificando o ID do objeto
1 >>> id (12)
2 2182424887888
3 >>> x = 10
4 >>> id(x)
5 2182424887824
6 >>> id (10)
7 2182424887824
8 >>> y = 10
9 >>> id(y)
10 2182424887824

Testando a Imutabilidade dos Tipos Primitivos
1 >>> x = y = 13
2 >>> id(x)
3 2182424887920
4 >>> id(y)
5 2182424887920
6 >>> y += 1
7 >>> y
8 14
9 >>> id(y)
10 2182424887952
11 >>> id(x)
12 2182424887920

Tipos dos Objetos type e .__class__
1 >>> type (42)
2 <class ’int’>
3 >>> type(’Escambau do judas ’)
4 <class ’str’>
5 >>> type ([1,2,3,4])
6 <class ’list ’>
7 >>>
8 >>> (42).__class__
9 <class ’int’>
10 >>> ’Queima leao do pici ’.__class__
11 <class ’str’>

Tipos Primitivos Imutáveis
O tipos primitivos boolean, int float e complex são imutáveis.
Os tipos str, bytes e tuple também o são.

Tipos Mutáveis em Python - List
A lista em si é mutável, mas os elementos internos podem ou não ser dependendo do
tipo.
Ex.
1 >>> numeros = [1,5,8] # criando uma lista de números
2 >>> id(numeros)
3 2490398152384
4 >>> id(numeros [1]) # verificando o id do segundo elemento
5 2490392248688
6 >>> numeros [1] = 10 # mudando o segundo elemento
7 >>> id(numeros [1]) # verificando se o elemento mudou
8 2490392248848
9 >>>

Tipos Mutáveis em Python - Dicionários
Com dicionários você pode mudar o valor associado a uma chave e adicionar ou
remover novos pares de ’valor-chave’.
Ex.
1 >>> lista_compras = {’feijao ’:10, ’arroz ’:20, ’ovos ’:12,
’farinha ’:30, ’rapadura ’:15}
2 >>> lista_compras[’banana ’]=20 # adicionando dados
3 >>> del lista_compras[’arroz ’] # apagando dados
4 >>> lista_compras
5 {’feijao ’: 10, ’ovos ’: 12, ’farinha ’: 30, ’rapadura ’: 15,
’banana ’: 20}
6 >>> lista_compras[’rapadura ’]=30
7 >>> lista_compras
8 {’feijao ’: 10, ’ovos ’: 12, ’farinha ’: 30, ’rapadura ’: 30,
’banana ’: 20}

Tipos Mutáveis em Python - Sets (Conjuntos)
Com os conjuntos podemos inserir ou remover itens.
Ex.
1 >>> compras = {’feijao ’,’farinha ’,’rapadura ’}
2 >>> compras.add(’arroz ’)
3 >>> compras
4 {’arroz ’, ’rapadura ’, ’feijao ’, ’farinha ’}
5 >>> compras.discard(’arroz ’)
6 >>> compras
7 {’rapadura ’, ’feijao ’, ’farinha ’}

Resumo dos Dados de Mutabilidade no Python
Tipo Classe Mutável
Números int, float, complex Não
Strings str Não
Tuplas tuple Não
Bytes bytes Não
Booleano bool Não
conjuntos Fixos(Frozen Sets) frozenset Não
Listas list Sim
Dicionários dict Sim
Conjuntos (Sets) set Sim
Listas de Bytes(Byte Arrays) bytearray Sim

Atenção: Aliases com Mutabilidade
Uma mudança em um alias de um tipo imutável não afeta o original.
Ex.
1 >>> x = 2
2 >>> y = x
3 >>> x
4 2
5 >>> y
6 2
7 >>> y += 1
8 >>> x
9 2
10 >>> y
11 3
12 >>>

Atenção: Aliases com Mutabilidade
Uma mudança em um alias de um tipo mutável afeta o original.
Ex.
1 >>> compras = [’pera ’,’maca ’,’banana ’]
2 >>> lista = compras
3 >>> lista.append(’laranjas ’)
4 >>> compras
5 [’pera ’, ’maca ’, ’banana ’, ’laranjas ’]
6 >>> lista
7 [’pera ’, ’maca ’, ’banana ’, ’laranjas ’]

Argumentos Mutáveis
Ao serem passados argumentos mutáveis para uma função a variável externa pode
sofrer as consequencias de mudanças realizadas dentro das funções.
Ex.
1 >>> def dobro(lista):
2 ... for i in range(len(lista)):
3 ... lista[i] = lista[i]**2
4 ... return lista
5 >>> x = [1,2,3,4]
6 >>> dobro(x)
7 [1, 4, 9, 16]
8 >>> x
9 [1, 4, 9, 16]

Argumentos Imutáveis
Isto não acontece se o argumento representar um dado imutável.
Ex.
1 >>> def dobro(y):
2 ... y *= 2
3 ... print(id(y))
4 ... return y
5 ...
6 >>> x = 10
7 >>> id(x)
8 2490392248848
9 >>> dobro(x)
10 2490392249168
11 20
12 >>> id(x)
13 2490392248848

Argumentos Default Não Sobrescrevem a Lista(Mutável)
Lista é preservada entre chamadas não ocorrendo o esperado.
Ex.
1 >>> def adicionar_item (item, lista = []):
2 ... lista.append(item)
3 ... return lista
4 ...
5 >>> adicionar_item (1)
6 [1]
8 [1, 2]
10 [1, 2, 3]

Solução
1 >>> def adiciona(item, lista=None):
2 ... if lista == None:
3 ... lista =[]
4 ... lista.append(item)
5 ... return lista
6 ...
7 >>> adiciona (1)
8 [1]
9 >>> adiciona (2)
10 [2]
11 >>> adiciona (3)
12 [3]

Atenção
Muitos aconselham a não usar argumentos default. De
qualquer forma, melhor sempre tomar cuidado.

Uma aplicação para esse caso
Essa propriedade das listas pode ser usada para calcular alguma coisa como a média
móvel.
Ex.
1 >>> def media_movel(x, amostra =[]):
2 ... amostra.append(x)
3 ... return sum(amostra)/len(amostra)
4 >>> media_movel (1)
5 1.0
7 2.0
9 3. 6666666666666665
11 4.0

Cópias Rasas - Shallow Copy
Cópia de uma lista obtida com slice [:], o método .copy ou o copy.copy(). Neste casos
cria-se uma nova lista porém os elementos da nova lista são aliases para os elementos
internos da lista anterior.

Cópia Profunda
Quando usada a função copy.deepcopy() a lista é copiada integralmente para uma
nova lista.
Experimente.....

Métodos Não Mutáveis
Strings são imutáveis o que significa que os métodos que as modificam criam cópias
das strings sem modificar as originais.
1 >>> original = "esta e uma string"
2 >>> original.upper () # isto apenas cria uma cópia
3 "ESTA E UMA STRING"
4 >>> original
5 "esta é uma string"

Aplicação desta característica
Esta propriedade pode permitir o encadeamento de métodos.
Ex.
1 >>> texto = "<html lan=’eng ’>"
2 >>> texto.removeprefix("<").removesuffix(">").upper ().center (20)
3 " HTML LAN=’ENG’ "
4 >>> texto
5 "<html lan=’eng ’>"
6 >>>

Tuplas contendo dados mutáveis
Tuplas são imutáveis, mas podem conter objetos mutáveis.
Ex.
1 >>> vermelho = ("RED",[255,0,0])
2 >>> vermelho [0] = "red"
3 Traceback (most recent call last):
4 File "<stdin >", line 1, in <module >
5 TypeError: ’tuple ’ object does not support item assignment
6 >>> vermelho [1] = [0,0,255]
9 TypeError: ’tuple ’ object does not support item assignment
10 >>> vermelho [1][0] = 0
11 >>> vermelho
12 (’RED’, [0, 0, 0])

Componentes Automáticos de Classes
Python já cria automaticamente alguns métodos em classes.
Ex.
1 >>> class Pessoa:
2 ... pass
3 ...
4 >>> dir(Pessoa)
5 [’__class__ ’, ’__delattr__ ’, ’__dict__ ’, ’__dir__ ’, ’__doc__ ’,
’__eq__ ’, ’__format__ ’, ’__ge__ ’, ’__getattribute__ ’,
’__gt__ ’, ’__hash__ ’, ’__init__ ’, ’__init_subclass__ ’,
’__le__ ’, ’__lt__ ’, ’__module__ ’, ’__ne__ ’, ’__new__ ’,
’__reduce__ ’, ’__reduce_ex__ ’, ’__repr__ ’, ’__setattr__ ’,
’__sizeof__ ’, ’__str__ ’, ’__subclasshook__ ’, ’__weakref__ ’]

Injeção de Atributos e Métodos
1 >>> Pessoa.emprego=’Programador ’
2 >>> def __init__(self, nome, emprego):
3 ... self.nome = nome
4 ... self.emprego = emprego
5 >>> Pessoa.__init__=__init__
6 >>> dir(Pessoa)
7 [’__class__ ’, ’__delattr__ ’, ’__dict__ ’, ’__dir__ ’,
’__doc__ ’, ’__eq__ ’, ’__format__ ’, ’__ge__ ’,
’__getattribute__ ’, ’__gt__ ’, ’__hash__ ’,
’__init__ ’, ’__init_subclass__ ’, ’__le__ ’,
’__lt__ ’, ... , ’__subclasshook__ ’, ’__weakref__ ’,
’emprego ’]

Dica sobre Injeção de Atributos e Métodos
A injeção de elementos em uma classe pode ser útil para a programação funcional em
Python

Impedindo a Adição de Atributos a Objetos
Podemos limitar a adição de atributos a objetos usando __slots__,...
Ex.
1 class Pessoa:
2 ... __slots__ = (’nome ’,’emprego ’)
3 ... def __init__(self,nome):
4 ... self.nome = nome
5 ...
6 >>> joao = Pessoa(’Joao ’)
7 >>> joao.emprego = ’Engenheiro ’
8 >>> joao.endereco = ’Rua X Numero Z’
11 AttributeError : ’Pessoa ’ object has no attribute ’endereco ’

Impedindo a Adição de Atributos a Objetos
... mas não a classes .
Ex.
1 >>>
2 >>> Pessoa.endereco = "Rua X número Z"
3 >>>
4 >>> dir(joao)
5 [’__class__ ’, ’__delattr__ ’, ’__dir__ ’, ’__doc__ ’, ’__eq__ ’,
’__format__ ’, ’__ge__ ’, ’__getattribute__ ’, ... ,
’__subclasshook__ ’, ’emprego ’, ’endereco ’, ’nome ’]

Funções __setattr__() and .__delattr__()
Estas funções controlam o acesso a atributos de forma a torná-los imutáveis se for o
caso.
EX.
1 >>> class Imutavel:
2 ... def __init__(self, valor):
3 ... super ().__setattr__("valor", valor)
4 ... def __setattr__(self, nome, attr_valor):
5 ... raise AttributeError(f"Não posso mudar o valor do
atributo ’{nome}’")
6 ... def __delattr__(self, nome):
7 ... raise AttributeError(f"Não posso apagar o atributo
’{nome}’")
8 ...

Funções __setattr__() and .__delattr__()
Cont..
1 >>> gravidade = Imutavel (9.78)
2 >>> gravidade.valor
3 9.78
4 >>> gravidade.valor = 9.8
7 File "<stdin >", line 5, in __setattr__
8 AttributeError : Não posso mudar o valor do atributo ’valor ’
9 >>> del gravidade.valor
12 File "<stdin >", line 7, in __delattr__
13 AttributeError : Não posso apagar o atributo ’valor ’

Properties
O uso de getters sem setters pode ocultar (fazer de conta que oculta) atributos que
queremos que sejam ’imutáveis’. EX.
1 >>> class Pontos:
2 ... def __init__(self, x):
3 ... self._x = x
4 ... @property
5 ... def x(self):
6 ... return self._x
7 >>> p = Pontos (2,3)
8 >>> p.x
9 2
10 >>> p.x = 3
13 AttributeError : can’t set attribute ’x’

Tuplas Nomeadas
Tuplas nomeadas podem ser uma boa opção para se trabalhar com dados imutáveis.
Ex.
1 >>> from collections import namedtuple
2 >>> Pontos = namedtuple(’Ponto ’,"x y")
3 >>> ponto = Pontos (21,43)
4 >>> ponto
5 Ponto(x=21, y=43)
6 >>> ponto.x
7 21
8 >>> ponto.x = 12
11 AttributeError : can’t set attribute

Classes de Dados
dataclass pode ser uma boa opção para trabalhar com classes que apenas representam
dados.
Ex.
1 >>> from dataclasses import dataclass
2 >>> @dataclass
3 ... class Color:
4 ... red: int
5 ... green: int
6 ... blue: int
7 >>> color = Color (255, 0, 0)
8 >>> color.green = 128
9 >>> color
10 Color(red =255, green =128, blue =0)

Criando Classes de Dados Imutáveis
1 >>> @dataclass(frozen=True)
2 ... class Cor:
3 ... vermelho :int
4 ... verde : int
5 ... azul: int
6 ...
7 >>> cor = Cor (255,0,0)
8 >>> cor.verde = 255
11 File "<string >", line 4, in __setattr__
12 dataclasses. FrozenInstanceError : cannot assign to field ’verde ’
13 >>> cor
14 Cor(vermelho =255, verde =0, azul =0)

Elementos de Programação Funcional em Python
• Compreensão de Listas, Iteradores e Geradores(list comprehensions, iterators e
generators)
• Funções Anônimas (Lambda)
• Mapas e Reduções (Map Reduce)
• Filtros (Filter)

List Comprehensions
List compreension é uma abordagem declarativa para criação de listas3. Ex.
1 >>> lista = [x for x in range (10) if x < 5]
2 >>> lista
3 [0, 1, 2, 3, 4]
4 >>>
3
Ver também iterators e generators

Funções Lambda
1 >>> x = lambda a, b, c : a + b + c # lambda simples
2 >>> x(5,6,7)
3 18
4 >>> def myfunc(n):
5 ... return lambda a : a * n # retorna uma lamba com n fixo
6 ...
7 >>> m = myfunc (3)
8 >>> m(4)
9 12

Maps
O Map é uma forma de aplicar funções a iteráveis (listas, tuplas, dicionários, etc) Ex.
1 >>> def square(number):
2 ... return number ** 2
3 ...
4 >>> numbers = [1, 2, 3, 4, 5]
5 >>> squared = map(square, numbers)
6 >>> list(squared)
7 [1, 4, 9, 16, 25]
8 >>>

Reduce
A função reduce encadeia uma chamada sequencialmente a um conjunto de dados.
Vejamos como calcular uma soma acumulada.
1 >>> def my_add(a, b):
2 ... return a + b
3 ...
4 >>> ns = [1,2,3,4,5,6,7,8,9,10]
5 >>> from functools import reduce
6 >>> reduce(my_add,ns)
7 55
Resultado: ((((((((((0 + 1) + 2) + 3) + 4) + 5) + 6) + 7) + 8) + 9) + 10)

Filter
Filtra elementos em iteráveis. Ex.
1 >>> import math
2 >>> def eh_par(x):
3 ... return x%2==0
4 >>> numeros = [1,2,4,5,3,6,7,8,9]
5 >>> pares = list(filter(eh_par,numeros))
6 >>> pares
7 [2, 4, 6, 8]

Seguindo
Agora que vimos os conceitos básicos associados a programação funcional podemos
estudar linguagens puramente funcional.

E N J O Y

Programação Funcional em Python - Paradigmas de Programação Funcional

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (16)

Semelhante a Programação Funcional em Python - Paradigmas de Programação Funcional

Semelhante a Programação Funcional em Python - Paradigmas de Programação Funcional (20)

Mais de ronaldo ramos

Mais de ronaldo ramos (20)

Último

Último (20)

Programação Funcional em Python - Paradigmas de Programação Funcional