Patterns in Python

3,622 views
3,442 views

Published on

KiwiPyCon2011, Wellington, Sunday, Track 1, Patterns in Python by Glenn Ramsay

Published in: Technology
0 Comments
15 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
3,622
On SlideShare
0
From Embeds
0
Number of Embeds
6
Actions
Shares
0
Downloads
117
Comments
0
Likes
15
Embeds 0
No embeds

No notes for slide
  • Personal: needed an observer implementation in Python like Boost.Signal, initially couldn't find one. My engineering background lead me to search for generic design principles in software.
  • Polymorphism
  • Creational patterns: patterns that can be used to create objects. Structural patterns: patterns that can be used to combine objects and classes in order to build structured objects. Behavioral patterns: patterns that can be used to build a computation and to control data flows. Norvig: 16 of 23 patterns are either invisible or simpler, due to: First-class types (6): Abstract-Factory, Flyweight, Factory-Method, State, Proxy, Chain-Of-Responsibility First-class functions (4): Command, Strategy, Template-Method, Visitor Macros (2): Interpreter, Iterator Method Combination (2): Mediator, Observer Multimethods (1): Builder Modules (1): Facade
  • Patterns in Python

    1. 1. Design patterns in Python <ul>Glenn Ramsey Kiwi Pycon 2011 </ul>
    2. 2. Who I am <ul><li>Glenn Ramsey
    3. 3. ME (1993, U of Auckland) mechanical engineering – control systems
    4. 4. Freelance developer (mainly C++, now Python)
    5. 5. Based at Hikutaia
    6. 6. Row Pro (digitalrowing.com) since 2001
    7. 7. Interest in software is primarily for modelling and simulation
    8. 8. PhD candidate at U of A (FEA horse's hoof, FORTRAN, Perl) thesis submitted </li></ul>Hikutaia
    9. 9. Outline <ul><li>Motivation
    10. 10. General software design / pattern concepts (brief)
    11. 11. Specific examples of “Gang of Four” patterns in Python </li></ul>
    12. 12. Motivation “ 16 of 23 [GoF] patterns have a qualitatively simpler implementation in Lisp or Dylan than in C++, for at least some uses of each pattern” Peter Norvig (http://norvig.com/design-patterns/) “ Patterns are not needed in Python because design patterns are a sign of a deficiency of a language” … ... for the purpose that the design pattern addresses. How is observer implemented in Python? (equivalent to Boost.Signals, Qt Slot/Signals, .NET events) Coming from C++ or Java, if you already know the GoF patterns then it would be informative to see how they are implemented in Python. This talk documents part of my journey from C++ to Ptyhon.
    13. 13. Software vs Engineering design Physical construction – E.g. building a house Software construction The code is the design! “ Software may be cheap to build, but it is incredibly expensive to design” J W Reeves, What Is Software Design?, www.developerdotstar.com Design stage output
    14. 14. Software design How does one design software, compared to physical engineering design? Data + algorithms? - only a part of the solution Structure and Interpretation of Computer Programs. H Abelson, G Sussman, J Sussman. http://mitpress.mit.edu/sicp/full-text/book/book.html Software Design Concepts (wikipedia) Abstraction – categorize and group concepts Refinement – convert high level to program statements Modularity – isolate independent features Software architecture – overall structure of the software Control Hierarchy – program structure Structural partitioning – horizontal vs vertical ? Data structure – logical relationship among elements Software procedure – an operation within a module Information hiding - information contained within a module is inaccessible to others Not especially helpful - too abstract!
    15. 15. Object Oriented Design principles <ul><li>Open Close Principle </li><ul><li>Software entities like classes, modules and functions should be open for extension but closed for modifications.
    16. 16. Encapsulation – information hiding </li></ul><li>Dependency Inversion Principle </li><ul><li>High-level modules should not depend on low-level modules. Both should depend on abstractions.
    17. 17. Abstractions should not depend on details. Details should depend on abstractions.
    18. 18. Loose coupling </li></ul><li>Interface Segregation Principle </li><ul><li>Clients should not be forced to depend upon interfaces that they don't use. </li></ul><li>Single Responsibility Principle </li><ul><li>A class should have only one job. </li></ul><li>Liskov's Substitution Principle </li><ul><li>Derived types must be completely substitutable for their base types. </li></ul><li>Prefer composition over inheritance </li></ul>http://www.oodesign.com/design-principles.html
    19. 19. What is a design pattern? <ul><li>Wikipedia: In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into code.
    20. 20. Christopher Alexander - Architect
    21. 21. Patterns are discovered – not invented
    22. 22. Patterns are not independent from the programming language. Example: subroutines in assembler. </li></ul>Gamma, Helm, Johnson, Vlissades (1995): Design patterns: elements of reusable object oriented software. Addison Wesley.
    23. 23. Pattern classes Purpose Creational Structural Behavioural Scope Class Factory Method Adapter (class) Interpreter Template Method Object Abstract factory Builder Prototype Singleton Adapter (object) Bridge Composite Decorator Facade Flyweight Proxy Chain of responsibility Command Iterator Mediator Memento Observer State Strategy Visitor Gamma, Helm, Johnson, Vlissades (1995): Design patterns: elements of reusable object oriented software. Addison Wesley. Invisible or simplified in Python due to: first class types first class functions other Fixed at compile time Can change at runtime Object creation Compostion of classes or objects Class and object interactions
    24. 24. Why are they invisible/ simplified? <ul><li>Some patterns are work-arounds for static typing
    25. 25. Python has </li><ul><li>First class* types
    26. 26. First class* functions </li></ul></ul><ul><li>An object* is first-class when it: </li><ul><li>can be stored in variables and data structures
    27. 27. can be passed as a parameter to a subroutine
    28. 28. can be returned as the result of a subroutine
    29. 29. can be constructed at run-time
    30. 30. has intrinsic identity (independent of any given name) </li></ul><li>*The term &quot;object&quot; is used loosely here, not necessarily referring to objects in object-oriented programming. The simplest scalar data types, such as integer and floating-point numbers, are nearly always first-class. </li><ul><li>Source:wikipedia </li></ul></ul>
    31. 31. Why are they invisible/simplified? (2) <ul><li>Python has duck typing
    32. 32. Wikipedia: In computer programming with object-oriented programming languages, duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface. </li><ul><li>An object only has to have a method with the right name
    33. 33. This means that a base class is not always needed
    34. 34. Therefore a lot of infrastructure code can be avoided </li></ul></ul>
    35. 35. Why are they invisible/simplified? (3) <ul><li>Override special methods </li><ul><li>Automatic delegation </li><ul><li>Methods that a class does not know about can be passed on to a another class </li></ul></ul></ul>
    36. 36. When to use a class <ul><li>Use a class only: </li><ul><li>if you need to inherit from it
    37. 37. If you need to do something special. E.g. </li></ul></ul># Put in const.py...: class _const : class ConstError (TypeError): pass def __setattr__ ( self ,name,value): if self .__dict__.has_key(name): raise self .ConstError, &quot;Can't rebind const (%s)&quot; %name self .__dict__[name]=value import sys sys.modules[__name__]=_const() # that's all -- now any client-code can import const # and bind an attribute ONCE: const.magic = 23 # but NOT re-bind it: const.magic = 88 # raises const.ConstError # you may also want to add the obvious __delattr__ Alex Martelli http://code.activestate.com/recipes/65207-constants-in-python/
    38. 38. Iterator – built in <ul><li>Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation </li></ul>class Sequence : def __init__ ( self , size): self .list = [x for x in xrange(size)] self .index = 0 def __iter__ ( self ): return self def next ( self ): if len( self .list) == self .index: raise StopIteration current = self .list[ self .index] self .index += 1 return current >>> a = Sequence( 3 ) >>> for x in a: print x 0 1 2 >>> http://www.dofactory.com/Patterns/PatternIterator.aspx
    39. 39. Command <ul><li>Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.
    40. 40. Known uses: undo/redo.
    41. 41. OO replacement for callbacks.
    42. 42. Specify, queue and execute requests at different times. </li></ul>http://www.cs.mcgill.ca/~hv/classes/CS400/01.hchen/doc/command/command.html
    43. 43. Command – GoF style Rahul Verma, Chetan Giridhar. Design Patterns in Python. www.testingperspective.com class Command : &quot;&quot;&quot;The Command Abstract class&quot;&quot;&quot; def __init__ ( self ): pass #Make changes def execute ( self ): #OVERRIDE raise NotImplementedError class FlipUpCommand (Command): &quot;&quot;&quot;The Command class for turning on the light&quot;&quot;&quot; def __init__ ( self , light): self .__light = light def execute ( self ): self .__light.turnOn()
    44. 44. Command in Python def greet (who): print &quot;Hello %s&quot; % who greet_command = lambda : greet( &quot;World&quot; ) # pass the callable around, and invoke it later greet_command() class MoveFileCommand (object): def __init__ ( self , src, dest): self .src = src self .dest = dest self () def __call__ ( self ): os.rename( self .src, self .dest) def undo ( self ): os.rename( self .dest, self .src) undo_stack = [] undo_stack.append(MoveFileCommand( 'foo.txt' , 'bar.txt' )) undo_stack.append(MoveFileCommand( 'bar.txt' , 'baz.txt' )) # foo.txt is now renamed to baz.txt undo_stack.pop().undo() # Now it's bar.txt undo_stack.pop().undo() # and back to foo.txt http://stackoverflow.com/questions/1494442/general-command-pattern-and-command-dispatch-pattern-in-python (Ants Aasma) Simple case: Just use a callable More complex case: Use a command object but no need for a base class
    45. 45. Singleton <ul>Ensure a class has only one instance, and provide a global point of access to it. <ul><li>Excessive consumption may be harmful because: </li><ul><li>it overloads your liver
    46. 46. makes you seem stupid
    47. 47. it's global
    48. 48. creates very strong coupling with client classes </li></ul></ul></ul>http://en.csharp-online.net
    49. 49. Singleton GoF style http://code.activestate.com/recipes/52558-the-singleton-pattern-implemented-with-python/ class Singleton : class __impl : &quot;&quot;&quot; Implementation of the singleton interface &quot;&quot;&quot; def spam ( self ): &quot;&quot;&quot; Test method, return singleton id &quot;&quot;&quot; return id( self ) # storage for the instance reference __instance = None def __init__ ( self ): &quot;&quot;&quot; Create singleton instance &quot;&quot;&quot; # Check whether we already have an instance if Singleton.__instance is None : # Create and remember instance Singleton.__instance = Singleton.__impl() # Store instance reference as the only member in the handle self .__dict__[ '_Singleton__instance' ] = Singleton.__instance def __getattr__ ( self , attr): &quot;&quot;&quot; Delegate access to implementation &quot;&quot;&quot; return getattr( self .__instance, attr) def __setattr__ ( self , attr, value): return setattr( self .__instance, attr, value)
    50. 50. Singleton in Python <ul><li>Use a module (Alex Martelli - 99% of cases) </li><ul><li>Modules are objects too
    51. 51. Allows you to create Fake objects for testing </li></ul><li>Just create one instance (99% of the rest) </li><ul><li>You could assign that to a module variable </li></ul><li>If that doesn't work also see the Borg pattern </li><ul><li>Shares common state among objects </li></ul></ul>
    52. 52. Strategy <ul>Define a family of algorithms, encapsulate each one and make them interchangeable. Known uses: line breaking algorithms </ul>http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html
    53. 53. Strategy - statically typed class Bisection (FindMinima): def algorithm ( self ,line): Return ( 5.5 , 6.6 ) class ConjugateGradient (FindMinima): def algorithm ( self ,line): Return ( 3.3 , 4.4 ) class MinimaSolver : # context class strategy= '' def __init__ ( self ,strategy): self .strategy=strategy def minima ( self ,line): return self .strategy.algorithm(line) def changeAlgorithm ( self , newAlgorithm): self .strategy = newAlgorithm def test (): solver=MinimaSolver(ConjugateGradient()) print solver.minima(( 5.5 , 5.5 )) solver.changeAlgorithm(Bisection()) print solver.minima(( 5.5 , 5.5 )) From J Gregorio http://assets.en.oreilly.com/1/event/12/_The%20Lack%20of_%20Design%20Patterns%20in%20Python%20Presentation.pdf
    54. 54. Strategy in Python def bisection (line): Return 5.5 , 6.6 def conjugate_gradient (line): Return 3.3 , 4.4 def test (): solver = conjugate_gradient print solver(( 5.5 , 5.5 )) solver = bisection print solver(( 5.5 , 5.5 )) From J Gregorio http://assets.en.oreilly.com/1/event/12/_The%20Lack%20of_%20Design%20Patterns%20in%20Python%20Presentation.pdf Invisible because Python has first class functions
    55. 55. Observer <ul><li>Define a one to many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically
    56. 56. Known uses: model – view – controller, Qt Signals/Slots, Boost.Signals, most GUI toolkits </li></ul>http://en.wikipedia.org/wiki/File:Observer.svg
    57. 57. Observer – GoF style class Observer (): def update ( self ): raise NotImplementedError class ConcreteObserver (Observer): def __init__ ( self , subject): self .subject = subject def update ( self ): data = self .subject.data # do something with data class Subject (): def __init__ ( self ): self .observers = [] def attach ( self , observer): self .observers.append(observer) def detach ( self , observer): self .observers.remove(observer) def notify ( self ): for o in self .observers: o.update() class ConcreteSubject (Subject): def __init__ ( self , data): self .data = data def do_something ( self ): self .data += 1 self .notify() Issues <ul><li>Deleted observers
    58. 58. Detach during notify()
    59. 59. Pass parameters to the observer </li></ul>e.g. http://code.activestate.com/recipes/131499-observer-pattern/
    60. 60. Observer in Python <ul><li>Simplified - Observer base class is not required – use a callable </li><ul><li>E.g. PyDispatcher ( http://pydispatcher.sourceforge.net ) </li><ul><li>Use composition instead of inheritance </li></ul></ul></ul>from pydispatch import dispatcher # define the observer function def something_was_updated (data, signal, sender): print &quot;data:&quot; , data, &quot;signal:&quot; , signal, &quot;sender:&quot; ,sender class A_Model (): def __init__ ( self ): self .data = 100 # an object to identify the signal self .data_changed= &quot;data&quot; def do_something ( self ): self .data *= 1.34 # args are: signal, sender, args dispatcher.send( self .data_changed, self , self .data) # create an object to be an identifier for a signal sender = A_Model() # args are: receiver , signal, sender dispatcher.connect(something_was_updated, sender.data_changed, sender) sender.do_something()
    61. 61. Decorator <ul><li>Attach additional responsibilities or functions to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.
    62. 62. Not the same as Python decorators </li></ul>Objects enclose other objects that share similar interfaces. The decorating object appears to mask or modify or annotate the enclosed object. http://en.wikipedia.org/wiki/File:Decorator_UML_class_diagram.svg
    63. 63. Decorator GoF style class Writer (object): def write ( self , s): print s class WriterDecorator (object): def __init__ ( self , wrappee): self .wrappee = wrappee def write ( self , s): self .wrappee.write(s) class UpperWriter (WriterDecorator): def write ( self , s): self .wrappee.write(s.upper()) class ShoutWriter (WriterDecorator): def write ( self , s): self .wrappee.write( '!' .join( [t for t in s.split( ' ' ) if t]) + '!' ) Magnus Therning http://therning.org/magnus/archives/301 w = Writer() w.write( 'hello' ) uw = UpperWriter(w) uw.write( 'hello' ) wd = WriterDecorator(w) wd.write( 'hello' ) sw1 = ShoutWriter(w) sw1.write( 'hello again' ) sw2 = ShoutWriter(uw) sw2.write( 'hello again' ) >>> hello HELLO hello hello!again! HELLO!AGAIN!
    64. 64. Decorator using function decorators def uppercase (f): def wrapper (*args, **kwargs): orig = f(*args, **kwargs) return orig.upper() return wrapper def shout (f): def wrapper (*args, **kwargs): orig = f(*args, **kwargs) return '!' .join( [t for t in orig.split( ' ' ) if t] ) + '!' return wrapper @shout def s_writer (s): return s print s_writer( &quot;hello again&quot; ) @shout @uppercase def su_writer (s): return s print su_writer( &quot;hello again&quot; ) >>> HELLO AGAIN HELLO!AGAIN!
    65. 65. Decorator using delegation import string class UpSeq : def __init__ ( self , seqobj): self .seqobj = seqobj def __str__ ( self ): return string.upper( self .seqobj.seq) def __getattr__ ( self ,attr): return getattr( self .seqobj, attr) class DNA (): def __init__ ( self , name, seq): self .seq = seq self .name = name def __getitem__ ( self , item): return self .seq.__getitem__(item) def first ( self ): return self .seq[ 0 ] s=UpSeq(DNA(name= '1' , seq= ' atcgctgtc ' )) >>> print s ATCGCTGTC >>> print s[ 0 : 3 ] atc >>> print s.first() a Adapted from http://www.pasteur.fr/formation/infobio/python/ UpSeq delegates to DNA
    66. 66. State <ul><li>Allow an object to alter its behaviour when its internal state changes. The object will appear to change its class
    67. 67. Very common
    68. 68. Known uses: TCP, GUIs </li></ul>http://en.wikipedia.org/wiki/File:State_Design_Pattern_UML_Class_Diagram.svg
    69. 69. State GoF style class State(object): &quot;&quot;&quot;Base state. This is to share functionality&quot;&quot;&quot; def scan( self ): &quot;&quot;&quot;Scan the dial to the next station&quot;&quot;&quot; self .pos += 1 if self .pos == len( self .stations): self .pos = 0 print &quot;Scanning… Station is&quot; , self .stations[ self .pos], self .name class AmState(State): def __init__( self , radio): self .radio = radio self .stations = [ &quot;1250&quot; , &quot;1380&quot; , &quot;1510&quot; ] self .pos = 0 self .name = &quot;AM&quot; def toggle_amfm( self ): print &quot;Switching to FM&quot; self .radio.state = self .radio.fmstate class FmState(State): def __init__( self , radio): self .radio = radio self .stations = [ &quot;81.3&quot; , &quot;89.1&quot; , &quot;103.9&quot; ] self .pos = 0 self .name = &quot;FM&quot; def toggle_amfm( self ): print &quot;Switching to AM&quot; self .radio.state = self .radio.amstate class Radio(object): &quot;&quot;&quot;A radio. It has a scan button, and an AM/FM toggle switch.&quot;&quot;&quot; def __init__( self ): &quot;&quot;&quot;We have an AM state and an FM state&quot;&quot;&quot; self .amstate = AmState( self ) self .fmstate = FmState( self ) self .state = self .amstate def toggle_amfm( self ): self .state.toggle_amfm() def scan( self ): self .state.scan() # Test radio = Radio() actions = [radio.scan] * 2 + [radio.toggle_amfm] + [radio.scan] * 2 actions = actions * 2 for action in actions: action() Jeff ? http://ginstrom.com/scribbles/2007/10/08/design-patterns-python-style/ Scanning... Station is 1380 AM Scanning... Station is 1510 AM Switching to FM Scanning... Station is 89.1 FM Scanning... Station is 103.9 FM Scanning... Station is 81.3 FM Scanning... Station is 89.1 FM Switching to AM Scanning... Station is 1250 AM Scanning... Station is 1380 AM Note lack of state methods “Abstract” state Context Concrete states
    70. 70. State in Python <ul><li>Switch classes or methods </li></ul>From: Alex Martelli http://www.aleax.it/goo_pydp.pdf class RingBuffer (object): def __init__ ( self ): self .d = list() def tolist ( self ): return list( self .d) def append ( self , item): self .d.append(item) if len( self .d) == MAX: self .c = 0 self .__class__ = _FullBuffer class _FullBuffer (object): def append ( self , item): self .d[ self .c] = item self .c = ( 1 + self .c) % MAX def tolist ( self ): return ( self .d[ self .c:] + self .d[: self .c] ) class RingBuffer (object): def __init__ ( self ): self .d = list() def append ( self , item): self .d.append(item) if len( self .d) == MAX: self .c = 0 self .append = self .append_full def append_full ( self , item): self .d.append(item) self .d.pop( 0 ) def tolist ( self ): return list( self .d) Irreversible state change Initial state. Use this until the buffer gets full. Method change implementation state change
    71. 71. State in Python (method) class Sequencer(): def __init__( self ): self ._action_impl = self .action1 self .count = 1 def action( self ): self ._action_impl() def next( self ): self .count += 1 if self .count > 3 : self .count = 1 self ._action_impl = getattr( self , &quot;action&quot; +str( self .count)) def action1( self ): print &quot;1&quot; def action2( self ): print &quot;2&quot; def action3( self ): print &quot;3&quot; s = Sequencer() actions = [s.action] + [s.next] actions = actions * 3 for f in actions: f() >>> 1 2 3 >>> Switch methods output Use Bridge so that the binding of Sequencer.action doesn't change
    72. 72. State in Python (class) >>> First 1 Second 2 Third 3 First 4 First 1 Second 2 Second 3 class Base (): def __init__ ( self ): self .state = 0 def action ( self ): self .state += 1 print self .__class__.__name__, self .state def change_state ( self , next_class): self .__class__ = next_class class Third (Base): def transition ( self ): self .change_state( First ) class Second (Base): def transition ( self ): self .change_state( Third ) class First (Base): def transition ( self ): self .change_state( Second ) state = First() state.action() state.transition() state.action() state.transition() state.action() state.transition() state.action() state = First() actions = [state.action] + [state.transition] actions = actions * 3 for action in actions: action() output This doesn't work because state is always First
    73. 73. Bridge <ul>Decouple an abstraction from its implementation so that the two can vary independently <ul><li>Similar to strategy but isn't simplified in the same way
    74. 74. Strategy is behavioural – interchange algorithms
    75. 75. Bridge is structural – implementation varies independently from abstraction
    76. 76. C++ pimpl </li></ul></ul>http://atlas.kennesaw.edu/~dbraun/csis4650/A&D/GoF_Patterns
    77. 77. Factory method <ul><li>Define an interface for creating an object, but let subclasses decide which class to instantiate. This method lets a class defer instantiation to subclasses </li></ul>http://en.wikipedia.org/wiki/File:FactoryMethod.svg
    78. 78. Factory Method GOF style class Person : def __init__ ( self ): self .name = None self .gender = None def getName ( self ): return self .name def getGender ( self ): return self .gender class Male (Person): def __init__ ( self , name): print &quot;Hello Mr.&quot; + name class Female (Person): def __init__ ( self , name): print &quot;Hello Miss.&quot; + name class Factory : def getPerson ( self , name, gender): if gender == 'M' : return Male(name) if gender == 'F' : return Female(name) From: dpip.testingperspective.com factory = Factory() person = factory.getPerson( &quot; Chetan &quot; , &quot;M&quot; ) person = factory.getPerson( &quot; Money &quot; , &quot;F&quot; ) >>> Hello Mr.Chetan Hello Miss.Money
    79. 79. Factory method in Python class Male (object): def __init__ ( self , name): print &quot;Hello Mr.&quot; + name class Female (object): def __init__ ( self , name): print &quot;Hello Ms.&quot; + name factory = dict(F=Female, M=Male) if __name__ == '__main__' : person = factory[ &quot;F&quot; ]( &quot;Money&quot; ) person = factory[ &quot;M&quot; ]( &quot; Powers &quot; ) >>> Hello Ms.Money Hello Mr.Powers Adapted from: http://www.rmi.net/~lutz/talk.html # variable length arg lists def factory (aClass, *args, **kwargs): return aClass(*args, **kwargs) class Spam : def __init__ ( self ): print self .__class__.__name__ def doit ( self , message): print message class Person : def __init__ ( self , name, job): self .name = name self .job = job print self .__class__.__name__, name, job object1 = factory(Spam) object2 = factory(Person, &quot; Guido &quot; , &quot;guru&quot; ) >>> Spam Person Guido guru
    80. 80. Abstract factory <ul>Provide an interface for creating families of related or dependent objects without specifying their concrete classes </ul>http://en.wikipedia.org/wiki/File:Abstract_factory.svg
    81. 81. Abstract Factory GoF style class PetShop : def __init__ ( self , animal_factory= None ): &quot;&quot;&quot;pet_factory is our abstract factory. We can set it at will.&quot;&quot;&quot; self .pet_factory = animal_factory def show_pet ( self ): &quot;&quot;&quot;Creates and shows a pet using the abstract factory&quot;&quot;&quot; pet = self .pet_factory.get_pet() print &quot;This is a lovely&quot; , pet print &quot;It says&quot; , pet.speak() print &quot;It eats&quot; , self .pet_factory.get_food() class Dog : def speak ( self ): return &quot;woof&quot; def __str__ ( self ): return &quot;Dog&quot; class Cat : def speak ( self ): return &quot; meow &quot; def __str__ ( self ): return &quot;Cat&quot; http://ginstrom.com/scribbles/2007/10/08/design-patterns-python-style/ class DogFactory : def get_pet ( self ): return Dog() def get_food ( self ): return &quot;dog food&quot; class CatFactory : def get_pet ( self ): return Cat() def get_food ( self ): return &quot;cat food&quot; # Create the proper family def get_factory (): return random.choice([DogFactory, CatFactory])() # Show pets with various factories shop = PetShop() for i in range( 3 ): shop.pet_factory = get_factory() shop.show_pet() print &quot;=&quot; * 10 >>> This is a lovely Dog It says woof It eats dog food ========== This is a lovely Cat It says meow It eats cat food ========== This is a lovely Dog It says woof It eats dog food ==========
    82. 82. Abstract factory in Python <ul><li>Use a module – for example similar to the os module </li></ul># cat.py class Animal (): def __init__ ( self ): print &quot;Cat&quot; def speak (): return &quot; meow &quot; class Food : def acquire ( self ): print &quot;go hunting&quot; def serve ( self ): print &quot;eat your catch, leave &quot; &quot;the entrails on the doorstep&quot; #dog.py class Animal (): def __init__ ( self ): print &quot;Dog&quot; def speak (): return &quot;woof&quot; class Food : def acquire ( self ): print &quot;wait for cat to catch&quot; def serve ( self ): print &quot;eat what the cat left&quot; import dog as factory_1 import cat as factory_2 make_animal(factory_1) identify(factory_1) feed(factory_1) make_animal(factory_2) identify(factory_2) feed(factory_2) def make_animal (factory): return factory.Animal() def identify (factory): print factory.speak() def feed (factory): food = factory.Food() food.acquire() food.serve() If inheritance is not needed
    83. 83. Flyweight <ul>Use sharing to support large numbers of fine grained objects efficiently </ul>http://www.lepus.org.uk/ref/companion/Flyweight.xml
    84. 84. Flyweight in Python http://codesnipers.com/?q=python-flyweights import weakref class Card (object): _CardPool = weakref.WeakValueDictionary() def __new__ (cls, value, suit): obj = Card._CardPool.get(value + suit, None ) if not obj: obj = object.__new__(cls) Card._CardPool[value + suit] = obj obj.value, obj.suit = value, suit return obj c1 = Card( '9' , 'h' ) c2 = Card( '9' , 'h' ) c3 = Card( '2' , 's' ) print c1 == c2, c1 == c3, c2 == c3 print id(c1), id(c2), id(c3) >>> True False False 38958096 38958096 38958128
    85. 85. Visible Patterns <ul><li>Covered by Alex Martelli </li><ul><li>Facade
    86. 86. Template method
    87. 87. Adapter </li></ul><li>Others </li><ul><li>Mediator
    88. 88. Bridge
    89. 89. Composite
    90. 90. Memento </li></ul></ul>
    91. 91. Summary <ul><li>Patterns are simplified because Python has: </li><ul><li>First class objects and types
    92. 92. Duck typing – base classes may be optional
    93. 93. Ability to override special methods </li></ul></ul>
    94. 94. References <ul><li>Alex Martelli, Design Patterns in Python, Google TechTalks, March 14, 2007. (find them on youtube)
    95. 95. Joe Gregorio – The (lack of) design patterns in Python, Pycon 2009 </li><ul><li>( http://bitworking.org/news/428/the-lack-of-design-patterns-in-python-pycon-2009 ) </li></ul><li>Peter Norvig - Design Patterns in Dynamic Programming, Object World, 1996. </li><ul><li>http://norvig.com/design-patterns/ppframe.htm </li></ul></ul>Alan Shalloway, James Trott. Design Patterns Explained.
    96. 96. Thank you http://dl.dropbox.com/u/10287301/Ramsey-KiwiPycon-2011.pdf

    ×