Share
Embed
Sem __mágica__: métodos especiais em Python
Como usar os métodos especiais da linguagem Python para emular coleções, sobrecarregar operadores e gerenciar contextos
Luciano Ramalho
October 03, 2013
Transcript
60 slides
-
O baralho polimór!co O baralho polimór!co da palestra “OO em
Python sem sotaque” -
Fazendo maço >>> baralho = Baralho() >>> len(baralho) 52 >>>
baralho[0] Carta(valor='2', naipe='paus') >>> baralho[-1] >>> from random import choice >>> choice(baralho) Carta(valor='4', naipe='paus') >>> choice(baralho) Carta(valor='A', naipe='espadas') acesso por índice sorteio -
Fazendo maço >>> baralho[:5] [Carta(valor='2', naipe='paus'), Carta(valor='3', naipe='paus'), Carta(valor='4', naipe='paus'),
Carta(valor='5', naipe='paus'), Carta(valor='6', naipe='paus')] >>> baralho[-3:] [Carta(valor='Q', naipe='espadas'), Carta(valor='K', naipe='espadas'), Carta(valor='A', naipe='espadas')] >>> fatiamento! -
Fazendo maço (2) >>> for carta in baralho: ... print(carta)
... Carta(valor='2', naipe='paus') Carta(valor='3', naipe='paus') Carta(valor='4', naipe='paus') ... Carta(valor='Q', naipe='espadas') Carta(valor='K', naipe='espadas') Carta(valor='A', naipe='espadas') >>> iteração!! -
Fazendo maço (3) >>> for carta in reversed(baralho): ... print(carta)
... Carta(valor='A', naipe='espadas') Carta(valor='K', naipe='espadas') Carta(valor='Q', naipe='espadas') ... Carta(valor='4', naipe='paus') Carta(valor='3', naipe='paus') Carta(valor='2', naipe='paus') >>> iteração reversa!!! -
Fazendo maço (4) >>> for n, carta in enumerate(baralho, 1):
... print(format(n, '2'), card) ... 1 Carta(valor='2', naipe='paus') 2 Carta(valor='3', naipe='paus') 3 Carta(valor='4', naipe='paus') ... 50 Carta(valor='Q', naipe='espadas') 51 Carta(valor='K', naipe='espadas') 52 Carta(valor='A', naipe='espadas') >>> enumeração!!!! -
Tudo isso, quanto custa? import collections Carta = collections.namedtuple('Carta', ['valor',
'naipe']) class Baralho: valores = [str(n) for n in range(2,11)] + list('JQKA') naipes = 'paus ouros copas espadas'.split() def __init__(self): self.cartas = [Carta(v, n) for n in self.naipes for v in self.valores] def __len__(self): return len(self.cartas) def __getitem__(self, posicao): return self.cartas[posicao] 11 linhas! note: Baralho herda de object -
Protocolo de sequência • Protocolo é uma interface de!nida por
convenção, e não formalmente veri!cada pelo compilador • Pode ser implementada parcialmente • Em Python, o protocolo de sequência tem apenas dois métodos: • s.__getitem__(chave) 㲗 s[chave] • s.__len__() 㲗 len(s) -
Documentação o!cial • Language Reference > Data model • http://docs.python.org/dev/reference/
datamodel.html • Seção 3.2 - The standard type hierarchy • Seção 3.3 - Special method names -
3.3. Special method names [...] When implementing a class that
emulates any built-in type, it is important that the emulation only be implemented to the degree that it makes sense for the object being modelled. For example, some sequences may work well with retrieval of individual elements, but extracting a slice may not make sense. -
3.3. Nomes de métodos especiais [...] Ao implementar uma classe
que emula qualquer tipo embutido (built-in), é importante que a emulação seja feita apenas na medida em que faz sentido para o objeto que está sendo modelado. Por exemplo, algumas sequências podem funcionar bem com a recuperação de elementos individuais, mas extrair uma fatia pode não fazer sentido. -
Interfaces × protocolos × ABC • Interfaces veri!cadas pelo compilador:
não temos • Protocolos: de!nidos pela documentação, não declarados e muito menos veri!cados • Duck typing: o que interessa é o comportamento, não o DNA do bicho • ABC: Abstract Base Classes • Permitem especi!car interfaces e declarar classes que as implementam -
collections.abc.Sequence • ABC (Abstract Base Class) • classes abstratas •
desde Python 2.6 • torna explícita a interface de sequências (e outras coleções) -
• Basta implementar dois métodos na sua classe: __len__ e
__getitem__ • Você ganha mais 5: __contains__, __iter__, __reversed__, index e count métodos concretos métodos abstratos collections.abc.Sequence -
Baralho2: herdando de abc.Sequence import collections Carta = collections.namedtuple('Carta', ['valor',
'naipe']) class Baralho2(collections.abc.Sequence): valores = [str(n) for n in range(2,11)] + list('JQKA') naipes = 'paus ouros copas espadas'.split() def __init__(self): self.cartas = [Carta(v, n) for n in self.naipes for v in self.valores] def __len__(self): return len(self.cartas) def __getitem__(self, posicao): return self.cartas[posicao] collections.abc.Sequence -
Baralho2 em ação >>> baralho = Baralho2() >>> zape =
Carta(valor='4', naipe='paus') >>> zape in baralho True >>> baralho.count(zape) 1 >>> baralho.index(zape) 2 >>> baralho[:3] [Carta(valor='2', naipe='paus'), Carta(valor='3', naipe='paus'), Carta(valor='4', naipe='paus')] __contains__ index count -
Veri!cação da implementação • Python só permite que você crie
instâncias de classes concretas (que implementam todos os métodos abstratos) >>> baralho = BaralhoX() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: Can't instantiate abstract class BaralhoX with abstract methods __len__ -
Veri!cação da implementação • Quando você herda de uma classe
abstrata, Python não veri!ca se a sua classe derivada implementa todos os métodos abstratos, pois sua classe pode ser abstrata também • Por isso a veri!cação é feita somente no momento da instanciação -
Embaralhar com random • Python vem com as pilhas incluídas!
>>> from random import shuffle >>> l = list(range(10)) >>> l [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> shuffle(l) >>> l [1, 0, 8, 9, 5, 4, 7, 2, 3, 6] >>> -
Embaralhar com random? • Mas a função shu"e não funciona
com um baralho... >>> shuffle(b) Traceback (most recent call last): File "<stdin>", line 1, in <module> File ".../python3.3/random.py", line 265, in shuffle x[i], x[j] = x[j], x[i] TypeError: 'Baralho' object does not support item assignment >>> ‘Baralho’ não suporta atribuição a item -
>>> def enfiar(baralho, pos, carta): ... baralho.cartas[pos] = carta ...
>>> Baralho.__setitem__ = enfiar >>> shuffle(b) >>> b[:5] [Carta(valor='K', naipe='espadas'), Carta(valor='2', naipe='espadas'), Carta(valor='3', naipe='copas'), Carta(valor='9', naipe='paus'), Carta(valor='Q', naipe='copas')] >>> monkey patch Embaralhar com random! agora funciona! -
Baralho mutável import collections Carta = collections.namedtuple('Carta', ['valor', 'naipe']) class
Baralho: valores = [str(n) for n in range(2,11)] + list('JQKA') naipes = 'paus ouros copas espadas'.split() def __init__(self): self.cartas = [Carta(v, n) for n in self.naipes for v in self.valores] def __len__(self): return len(self.cartas) def __getitem__(self, posicao): return self.cartas[posicao] def __setitem__(self, posicao, carta): self.cartas[posicao] = carta __setitem__ -
.abc.MutableSequence • Aplicações simples do protocolo implementam só __setitem__ •
Uma subclasse concreta tem que implementar __setitem__, __delitem__ e insert • A classe abstrata implementa outros 6 métodos concretos -
Sintaxe e semântica • Nomes no formato __dunder__ • De!nem
os protocolos fundamentais da linguagem, com suporte sintático • mecanismos básicos: iteração, inicialização de objetos, acesso a atributos, formatação, invocação, hash, contextos (with) • operadores aritméticos e lógicos • tipos numéricos, emulação de coleções -
Como usar • Normalmente não é o seu código que
chama os métodos especiais, e sim o interpretador Python • Quase sempre a chamada é implícita • ex: laço for i in x → iter(x) → x.__iter__() • Se precisar usar estes serviços, evite invocar diretamente o método especial • Use iter(x) em vez de x.__iter__() -
Exemplo: Vetor 2d • Campos: x, y • Métodos: •
distancia • abs (distância até 0,0) • + (__add__) • * (__mul__) escalar Vetor(2, 1) Vetor(2, 4) Vetor(4, 5) x y -
Vetor from math import sqrt class Vetor: def __init__(self, x=0,
y=0): self.x = x self.y = y def __repr__(self): return 'Vetor(%s, %s)' % (self.x, self.y) def distancia(self, v2): dx = self.x - v2.x dy = self.y - v2.y return sqrt(dx*dx + dy*dy) def __abs__(self): return self.distancia(Vetor(0,0)) def __add__(self, v2): x = self.x + v2.x y = self.y + v2.y return Vetor(x, y) def __mul__(self, n): return Vetor(self.x*n, self.y*n) >>> from vetor import Vetor >>> v = Vetor(3, 4) >>> abs(v) 5.0 >>> v1 = Vetor(2, 4) >>> v2 = Vetor(2, 1) >>> v1 + v2 Vetor(4, 5) >>> v1 * 3 Vetor(6, 12) -
from math import sqrt class Vetor: def __init__(self, x=0, y=0):
self.x = x self.y = y def __repr__(self): return 'Vetor(%s, %s)' % (self.x, self.y) def distancia(self, v2): dx = self.x - v2.x dy = self.y - v2.y return sqrt(dx*dx + dy*dy) def __abs__(self): return self.distancia(Vetor(0,0)) def __add__(self, v2): x = self.x + v2.x y = self.y + v2.y return Vetor(x, y) def __mul__(self, n): return Vetor(self.x*n, self.y*n) >>> vel = Vetor(3, 4) >>> vel * 3 Vetor(9, 12) >>> 3 * vel Traceback (most recent call last): ... TypeError: unsupported operand type(s) for *: 'int' and 'Vetor' Um problema Isso viola a propriedade comutativa da multiplicação! -
Como funciona x * y • O interpretador invoca x.__mul__(y)
• Se x.__mul__ não existe ou retorna o valor especial NotImplemented: • O interpretador invoca y.__rmul__(x) • Se y.__rmul__ não existe ou retorna o valor NotImplemented, o interpretador levanta a exceção TypeError Esse padrão chama-se double-dispatch. Fonte: http://bit.ly/st-double-dispatch -
from math import sqrt class Vetor: def __init__(self, x=0, y=0):
self.x = x self.y = y def __repr__(self): return 'Vetor(%s, %s)' % (self.x, self.y) def distancia(self, v2): dx = self.x - v2.x dy = self.y - v2.y return sqrt(dx*dx + dy*dy) def __abs__(self): return self.distancia(Vetor(0,0)) def __add__(self, v2): x = self.x + v2.x y = self.y + v2.y return Vetor(x, y) def __mul__(self, n): return Vetor(self.x*n, self.y*n) def __rmul__(self, n): return self * n >>> vel = Vetor(3, 4) >>> vel * 3 Vetor(9, 12) >>> 3 * vel Vetor(9, 12) >>> Solução operador reverso -
from math import sqrt class Vetor: def __init__(self, x=0, y=0):
self.x = x self.y = y def __repr__(self): return 'Vetor(%s, %s)' % (self.x, self.y) def distancia(self, v2): dx = self.x - v2.x dy = self.y - v2.y return sqrt(dx*dx + dy*dy) def __abs__(self): return self.distancia(Vetor(0,0)) def __add__(self, v2): x = self.x + v2.x y = self.y + v2.y return Vetor(x, y) def __mul__(self, n): return Vetor(self.x*n, self.y*n) def __rmul__(self, n): return self * n Outro problema >>> Vetor(1, 2) * Vetor(3, 4) Vetor(Vetor(3, 4), Vetor(6, 8)) resultado sem sentido! -
Solução 2 from math import sqrt from numbers import Real
class Vetor: def __init__(self, x=0, y=0): self.x = x self.y = y def __repr__(self): return 'Vetor(%s, %s)' % (self.x, self.y) def distancia(self, v2): dx = self.x - v2.x dy = self.y - v2.y return sqrt(dx*dx + dy*dy) def __abs__(self): return self.distancia(Vetor(0,0)) def __add__(self, v2): x = self.x + v2.x y = self.y + v2.y return Vetor(x, y) def __mul__(self, n): if isinstance(n, Real): return Vetor(self.x*n, self.y*n) else: return NotImplemented def __rmul__(self, n): return self * n >>> Vetor(1, 2) * Vetor(3, 4) Traceback (most recent call last): ... TypeError: unsupported operand type(s) for *: 'Vetor' and 'Vetor' >>> se não, delega para o interpretador verifica se é escalar -
Atribuição aumentada • Operadores: • Para tipos imutáveis, a +=
b 㲗 a = a + b • Portanto um novo objeto (a+b) é criado • Para tipos mutáveis, a implementação de métodos como __iadd__ permite a modi!cação do objeto alvo da atribuição += -= *= /= //= **= %= &= ^= |= <<= >>= -
Sem __imul__ from math import sqrt from numbers import Real
class Vetor: def __init__(self, x=0, y=0): self.x = x self.y = y def __repr__(self): return 'Vetor(%s, %s)' % (self.x, self.y) def distancia(self, v2): dx = self.x - v2.x dy = self.y - v2.y return sqrt(dx*dx + dy*dy) def __abs__(self): return self.distancia(Vetor(0,0)) def __add__(self, v2): x = self.x + v2.x y = self.y + v2.y return Vetor(x, y) def __mul__(self, n): if isinstance(n, Real): return Vetor(self.x*n, self.y*n) else: return NotImplemented def __rmul__(self, n): return self * n >>> vel = Vetor(3, 4) >>> id(vel) 4313270928 >>> id_vel = id(vel) >>> vel *= 5 >>> vel Vetor(15, 20) >>> id(vel) == id_vel False *= cria um novo objeto porque Vetor não tem __imul__ -
Com __imul__ from math import sqrt from numbers import Real
class Vetor: def __init__(self, x=0, y=0): self.x = x self.y = y def __repr__(self): def __abs__(self): return self.distancia(Vetor(0,0)) def __add__(self, v2): x = self.x + v2.x y = self.y + v2.y return Vetor(x, y) def __mul__(self, n): if isinstance(n, Real): return Vetor(self.x*n, self.y*n) else: return NotImplemented def __rmul__(self, n): return self * n def __imul__(self, n): self.x *= n self.y *= n return self modifica e devolve self >>> vel = Vetor(3, 4) >>> id(vel) 4313270928 >>> id_vel = id(vel) >>> vel *= 5 >>> vel Vetor(15, 20) >>> id(vel) == id_vel True ainda o mesmo vetor -
Blocos with • Suporte sintático a gerenciadores de contexto: objetos
que implementam __enter__ e __exit__ with open('exemplo.txt', encoding='utf-8') as arq: for linha in arq: linha = linha.rstrip() if linha: print(linha) o objeto-arquivo devolvido por open é o gerenciador de contexto -
Métodos do gerenciador de contexto • object.__enter__(self): invocado no início
do bloco, devolve um objeto que é atribuído à variável alvo do with/as with open('exemplo.txt', encoding='utf-8') as arq: for linha in arq: linha = linha.rstrip() if linha: print(linha) o __enter__ de file devolve self -
Métodos do gerenciador de contexto • object.__exit__(self, exc_type, exc_value, traceback):
invocado no !m do bloco, recebe informações sobre exceções ou None, None, None; se devolver True, suprime a exceção levantada with open('exemplo.txt', encoding='utf-8') as arq: for linha in arq: linha = linha.rstrip() if linha: print(linha) o __exit__ de file invoca self.close() -
Controle de atributos: métodos básicos • Acionado quando obj não
possui atributo a: • obj.a 㲗 obj.__getattr__(‘a’) • Acionados sempre: • bj.a = x 㲗 obj.__setattr__(‘a’, x) • del obj.a 㲗 obj.__delattr__(‘a’) o mais útil e mais fácil de implementar -
Proxy: demonstração >>> t = Treco(5, 'azul', 80) >>> t.cor
'azul' >>> t._valor 80.0 >>> t.preciosidade() 16.0 >>> pr = Proxy(t) >>> pr.cor 'azul' >>> pr.preciosidade() 16.0 >>> pr._valor Traceback (most recent call last): ... AttributeError: Atributo inexistente ou protegido: '_valor' >>> -
>>> t = Treco(5, 'azul', 80) >>> t.cor 'azul' >>>
t._valor 80.0 >>> t.preciosidade() 16.0 >>> pr = Proxy(t) >>> pr.cor 'azul' >>> pr.preciosidade() 16.0 >>> pr._valor Traceback (most recent call last): ... AttributeError: Atributo inexistente ou protegido: '_valor' >>> Proxy class Treco: def __init__(self, peso, cor, valor): self.peso = peso self.cor = cor self._valor = float(valor) def preciosidade(self): return self._valor / self.peso class Proxy: def __init__(self, embrulhado): self._embrulhado = embrulhado def __getattr__(self, nome_atr): if nome_atr.startswith('_'): msg = 'Atributo inexistente ou protegido: %r' raise AttributeError(msg % nome_atr) else: return getattr(self._embrulhado, nome_atr) -
Controle de atributos: métodos avançados • Acionado sempre: • obj.a
㲗 obj.__getattribute__(‘a’) • Para de!nição de descritores: • __get__ • __set__ • __delete__ poderoso e difícil de implementar corretamente não temos tempo mas... -
Python para pro!ssionais • Próximos lançamentos: • 1ª turma de
Python para quem estudou Java • 5ª turma de Objetos Pythonicos • 6ª turma de Python para quem sabe Python Para saber mais sobre estes cursos ONLINE ao VIVO visite: http://python.pro.br siga: @pythonprobr