Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Sem __mágica__: métodos especiais em Python

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
Tweet

More Decks by Luciano Ramalho

Other Decks in Technology

Transcript

  1. 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
  2. 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!
  3. 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!!
  4. 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!!!
  5. 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!!!!
  6. 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
  7. 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)
  8. 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
  9. 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.
  10. 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.
  11. 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
  12. 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)
  13. • 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
  14. 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
  15. 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
  16. 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__
  17. 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
  18. 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] >>>
  19. 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
  20. >>> 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!
  21. 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__
  22. .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
  23. 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
  24. 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__()
  25. 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
  26. 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)
  27. 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!
  28. 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
  29. 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
  30. 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!
  31. 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
  32. 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 += -= *= /= //= **= %= &= ^= |= <<= >>=
  33. 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__
  34. 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
  35. 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
  36. 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
  37. 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()
  38. 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
  39. 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' >>>
  40. >>> 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)
  41. 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...
  42. 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