DP это Design
Patterns, хорошо известные любому толковому
программеру.
Давайте поглядим
на DP применительно к Python.
Delegate pattern
the delegation
pattern is a design pattern in object-oriented programming where an
object, instead of performing one of its stated tasks, delegates that
task to an associated helper object. There is an Inversion of
Responsibility in which a helper object, known as a delegate, is
given the responsibility to execute a task for the delegator.
Понятно, что
применение этого шаблона может привести
к утомительной работе: прописыванию в
делегирующем классе всех свойств
реализуемого интерфейса.
Но может и нет.
Это Python, Карл!
Джейкоб
Циммерман показывает как
class DelegatedAttribute:
def __init__(self, delegate_name, attr_name):
self.attr_name = attr_name
self.delegate_name = delegate_name
def __get__(self, instance, owner):
if instance is None:
return self
else:
# return instance.delegate.attr
return getattr(self.delegate(instance), self.attr_name)
def __set__(self, instance, value):
# instance.delegate.attr = value
setattr(self.delegate(instance), self.attr_name, value)
def __delete__(self, instance):
delattr(self.delegate(instance), self.attr_name)
def delegate(self, instance):
return getattr(instance, self.delegate_name)
def __str__(self):
return "<delegated attribute, '" + self.attr_name + "' at " + str(id(self)) + '>'
|
Это будет
обертка вокруг свойств делегата.
class Foo:
def __init__(self):
self.bar = 'bar in foo'
def baz(self):
return 'baz in foo'
class Baz:
def __init__(self):
self.foo = Foo()
bar = DelegatedAttribute('foo', 'bar')
baz = DelegatedAttribute('foo', 'baz')
x = Baz()
print(x.bar) # prints 'bar in foo'
print(x.baz()) # prints 'baz in foo'
|
Это демонстрация
того, как оно работает.
А теперь самое
вкусное, декоратор, выполняющий всю
нудную работу по прописыванию делегируемых
свойств в словарь делегатора
def delegate_as(delegate_cls):
# gather the attributes of the delegate class to add to the decorated class
attributes = set(delegate_cls.__dict__.keys())
def inner(cls):
# create property for storing the delegate
setattr(cls, 'delegate', SimpleProperty())
# don't bother adding attributes that the class already has
attrs = attributes - set(cls.__dict__.keys())
# set all the attributes
for attr in attrs:
setattr(cls, attr, DelegatedAttribute('delegate', attr))
return cls
return inner
|
Остальное
найдете тут
https://programmingideaswithjake.wordpress.com/2015/05/23/python-decorator-for-simplifying-delegate-pattern/
Часть вторая,
Borg versus Singleton
Статья Алекса
Мартелли, многим известного по книгам
http://www.oreilly.com/pub/au/918
Начав с
реверансов, что DP это хорошо и правильно,
Алекс продолжает так:
Python's forte is
simplicity. Again and again, problems that are difficult in other
languages scale down to "pretty easy" in the light of
Python's bright Sun. The amount and caliber of intellectual weaponry
that it makes sense to bring to bear on a problem depends on the
problem's difficulty level. For a simpler problem, an informal
approach may make more sense, while a harder problem might profit
from more structured and formalized procedures. One plus of making
problems simpler is that, the simpler a problem, the more simplicity
you can deploy in solving it. Of course, one always aims (or should)
at making each solution as simple as it can possibly be (but,
admittedly, no simpler than that:-). Maybe you can get away with an
idiom (language specific usage), or even just "good common
practice", where another language would require you to unearth
and apply a full-fledged design pattern. At times, it's a reasonably
big win, in terms of simplicity, even just to avoid forcing an aspect
of the solution into the object oriented mold (so pervasive, and
indeed so often appropriate, in software development Design
Patterns). One aspect of Python's simplicity is, indeed, that you
only do OO when you want to!
И далее
показывает, что всеми любимый DP Singleton
легким движением превращается в шорты
четыре строчки на Python
class Borg:
_shared_state = {}
def __init__(self):
self.__dict__ = self._shared_state
Статья
http://www.aleax.it/5ep.html
хоть и содержит
многабукав, крайне рекомендована к
изучению.
Часть третья,
релаксационная
заключительная. Тоже
про шаблоны, шаблоны самодисциплины в
разработке.
9 Anti-Patterns
Every Programmer Should Be Aware Of
A healthy dose of
self-criticism is fundamental to professional and personal growth
1 Premature
Optimization
2 Bikeshedding
3 Analysis
Paralysis
4 God Class
5 Fear of
Adding Classes
6
Inner-platform Effect
7 Magic
Numbers and Strings
8 Management
by Numbers
9 Useless
(Poltergeist) Classes
Понятно без
пояснений, правда?
original post http://vasnake.blogspot.com/2015/05/patterns.html
Комментариев нет:
Отправить комментарий