Les design patterns

Les design patterns ne sont pas indépendants du langage. Ils dépendent de l’implémentation.

Le duck typing

En python, le duck typing est une forme extreme de programmation par interface. Ne pas hériter dans des directions fausse

exemple : une voiture ne peut hériter d’un moteur, parce que un moteur n’est pas une voiture.

hold or wrap ?

hold:

O.S.method()

Cela induit un couplage fort (cf la loi de Demeter)

Important

law of Demeter : never more than one dot.

wrap : a hold by private name, with a:

self.S.method()

Ou bien une méthode getattr:

__getattr__()

Gets coupling right.

wrapper can restrict, inheritance cannot restrict

class RestrictingWrapper(object):

  def __init__(self, w, block):
    self._w = w
    self._block = block

  def __getattr__(self, n):
    if n in self._block:
      raise AttributeError, n
    return getattr(self._w, n)

Pattern de création : singleton

# utiliser un module au lieu d’une classe

in toto.py:

class Toto()
toto = Toto()

in another module:

from toto import toto

la factory

def load(pkg, obj):
    m = __import__(pkg, {}, {}, [obj])
    return getattr(m, obj)

cls = load('p1.p2.p3', 'c4')

template method (self delegation)

# Abstract base class:

def OrganiseMethod()
  def org_method():
     def do_this()
     def do_that()

def Concrete(OrganiseMethod)
    def do_this(): ...
    def do_that(): ...

il est préférable de lever une NotImplementedError, ce qui revient à faire une classe abstraite.