Object Orientation vs Functional Programming in Python

5,381 views

Published on

1 Comment
5 Likes
Statistics
Notes
No Downloads
Views
Total views
5,381
On SlideShare
0
From Embeds
0
Number of Embeds
961
Actions
Shares
0
Downloads
58
Comments
1
Likes
5
Embeds 0
No embeds

No notes for slide
  • - Software Engineer at DemonWare - Online Services for some of the worlds most popular games, as well game online experiences like COD Elite - Python is one of our core technologies. - We're hiring!
  • The sub-title of this talk is writing modular python programs. What do I mean by modularity and why do we want it? I don't want to make too much of a song and dance about it, because I think it is an obvious goal and programming languages have always been trying to help us achieve it. Never the less I think it is useful to at least loosely define it. We want the code we write to be individual components that do one job. That allows us to recombine those bits in different ways to solve new problems. We can build new stuff, making use of what we built before repeating ourselves as little as possible. To achieve this there are some properties our code needs to have. If there is an idea/concern we dealing with we would like that be expressed in as few places as possible ideally one. Conversely if we have a single module/class/method it would be better if it dealt with one concern rather than being cluttered with many different concerns. The diagrams on the screen try to illustrate this point. If each colour represents a particular concern we see that is scattered all over the place, if you were assigned the task of modifying the functionality represented by the yellow bits that would be a pretty annoying, grep helps but we would rather not be in that position in the first place. It is similarly problematic to have modules like we have on the left, in which lots of concerns are tangled together. One has to be aware of all the concerns in the module to change just one of them, or run the risk of inadvertently breaking other stuff that just happens to be near by. If you have ever had to say but I only changed the comments you know what I am talking about. Instead what we want is what we have on the right. Modules that related but separate, with each module dealing with a particular concern. If we can achieve that we can better reuse, re-purpose and extend our code to solve new problems. This is the open-closed principle ( should be open for extension, but closed for modification ). We should only modify a component when it's intrinsic behaviour changes, all other extension ideally should be made from the outside.   I think most modern programming languages provide features that help us achieve that goal. They succeed to varying degrees, we are going to look at some of the ways Python helps us do this.
  • - I am not a classical rhetorician, but I aspire to play one on TV. The structure of classical rhetorical argument requires us to present the thesis, then explore the antithesis, and finally present the synthesis   - We are going take an example based approach, taking a look at a few Python OO and FP features that exemplify the point I am trying to make.   - Some of the examples themselves are taken mostly taken from the Python standard library, not so much the internals buy how we are supposed to use it. This is useful because the standard library (or any library for that matter) necessarily needs to extensible and reusable from the outside without modifying the library itself.
  • Python OO, it is class oriented like most OO languages there are so exceptions that are prototype based a notable one being javascript, but are some others like self. - So OO is packaging state and behaviour generally to achive 3 things: 1. delegation which explicitly or implicitly passing on the responsibility of performing an action to somewhere else. implicit when you lookup an attribute: instance -> class class -> base classes explicit: delegating to another object that we have a reference to or even explicit delegation delegation to the object itself 2. Polymorphism allowing objects to act like other objects depending on the context. 3. Instantiation that is essentially having one blueprint that can be used to create many instances. - That is really all I am going to say about OO in general, I am kind of assuming we are all familiar with the basics of OO in Python.
  • - base class offers "organizing method" which calls "hook methods" - in base class, most hook methods stay abstract - concrete subclasses implement the hooks - client code calls organizing method - A couple of things to note the Chess class does not specialise the winner printing; Data overriding something we cad do in python but not in many other languages   Mention how this structure would be hard to recreate with functions only, the obviousness of what is required is great.
  • The methods on a dict do not necessarily call the methods you would expect. The reason for this is that python needs to protect the internal invariants of collections to prevent crashes. So the internal calling patterns are not obvious. ABC declare these constraints in an obvious way. This is really a variant of the template method design pattern with the sort of checks you would normally get in a staticly typed language. This still of course happens at runtime, but the failure is early, obvious and descriptive. Better still using an abc allows your code to move with the language. Because abc define the minimum set of the methods for each type. All other methods can be implemented in terms of these. You can override more methods to do things more efficiently, but if you don't things will still work.   The abc's really provide structured modularity and extendibility. We can extend them in ways that are sure to be consistent with intention of the base class.
  • This can be thought of a form of the template method design pattern. Except the organising methods come from one or more base classes.   Inheriting from a mixin is not a form of specialization but is rather a means of collecting functionality. A class may inherit most or all of its functionality from one or more mixins through multiple inheritance .   Diamond problem: Python creates a list of a classes using the C3 linearization algorithm. That algorithm enforces two constraints: children precede their parents and if a class inherits from multiple classes, they are kept in the order specified in the tuple of base classes. Thus, the method resolution order is: D, B, C, A
  • No discussion of multiple inheritance is complete without mentioning the "Diamon Problem"   The diamond problem such as it is, is In object-oriented programming languages with multiple inheritance and knowledge organization , the diamond problem is an ambiguity that arises when two classes B and C inherit from A, and class D inherits from both B and C. If a method in D calls a method defined in A (and does not override the method), and B and C have overridden that method differently, then from which class does it inherit: B, or C? A well designed language needs to have a deterministic resolution to this ambiguity. Python creates a list of a classes using the C3 linearization algorithm. That algorithm enforces two constraints: children precede their parents and if a class inherits from multiple classes, they are kept in the order specified in the tuple of base classes. Thus, the method resolution order is: D, B, C, A   Personally I think it is a mistake to rely on this order even it is deterministic. This situation can avoided in most cases just by taking care what you inherit from. Since the main reason for mixins is to get functionality defined in another class if inheritance is causing problems it may be time to consider composition instead.
  • The design patterns literature. talks about preferring composition over inheritance. There is a good reason for this, for one thing inheritance always  expands the interface of the subclass with all of the parents attributes this may not always be what you want, especially if the base class is just a service that you may want to swap out in the in end. Inheritance cannot restrict it can only expand. This is a general mechanism but specific things you may be trying to achieve is to adapt or proxy some object. In all these cases though the general mechanism is the same. It is useful to distinguish between them (as is done in design patterns literature) to help in deciding when to apply the technique. However at the level of abstraction we are working today
  • The design patterns literature. talks about preferring composition over inheritance. There is a good reason for this, for one thing inheritance always  expands the interface of the subclass with all of the parents attributes this may not always be what you want, especially if the base class is just a service that you may want to swap out in the in end. Inheritance cannot restrict it can only expand. This is a general mechanism but specific things you may be trying to achieve is to adapt or proxy some object. In this example say had a lot of code that knows how to deal with file like objects (perhaps it uses context lib closing()This is a way to reuse code in a context that it would not otherwise be usable, by creating a very thin wrapper.
  • python def __getattr__(self, n) magic really make life easy for us, how does this help modularity well we only need to specify what we care about and the whole world making this a lot easier to change
  • python def __getattr__(self, n) magic really make life easy for us, how does this help modularity well we only need to specify what we care about and the whole world making this a lot easier to change
  • - I am not a classical rhetorician, but I aspire to play one on TV. The structure of classical rhetorical argument requires us to present the thesis, then explore the antithesis, and finally present the synthesis   - We are going take an example based approach, taking a look at a few Python OO and FP features that exemplify the point I am trying to make.   - The examples themselves are taken mostly taken from the Python standard library, not so much the internals buy how we are supposed to use it. This is useful because the standard library (or any library for that matter) necessarily needs to extensible and reusable from the outside without modifying the library itself.
  • - In functional programming Functions are the primary means of abstraction. Programs are decomposed into a set of functions, that take some input and produce some output.   - Ideally a function should compute outputs from its inputs and do nothing else. That is takes values and produces new values. No mutable shareable state should be modified as the result of calling a function. Pure functional languages are strict about side effect freeness. (The type systems in such languages are used to control the limited amount of necessary side effects).   - This purity is what gives functional languages some of advantages you sometime here mentioned like provable program correctness. Also since side effects are limited or none existent, functional languages are very useful for concurrent programming.   - Python is not a pure functional language, because the language does permit side effects. Assignment of values to names which is not possible in pure functional languages is commonplace in Python program.    - Rather It is a language the supports functional style programming. The main thing that makes this possible is the fact that the language supports higher order functions. That is functions are first class objects. So we can functions that accept other functions as inputs and even return functions as outputs.   - Never the less we can get pretty for with the less draconian functional support we have in python.
  • One of the first examples most people encounter is programming python in a function style is callbacks. Before we take a look at some examples to make it more concrete let briefly discuss the concept of a callback. for: customization (flexibility)    "event-driven" architectures ("actual" events such as in GUI or network programming OR "pseudo" events for structuring of control-flow, a common example being a SAX XML parser.   This style of programming really begs for first class callables. The same effect can be achieved in other languages using interfaces, or functor objects or anonymous classes and so on, just to get around the lack of higher order functions.
  • Mention how simple this is to achieve because we are not encumbered by unnecessary OO infrastructure.   Imagine create a subclass of list with different sorting, or subclasses of the objects you are comparing to implement __eq__ and __lt__, this would result in a combinatorial explosion of different subclasses to do sort by different combinations of fields.
  • The sorted function is a higher order function, it accepts a function as its key argument and uses that key to customise how it does the sorting, that is rather than using the natural order of the class as defined by lt and eq.   Notice how much more flexible this is you can easily switch between sorting mechanisms. More importantly the users of the person class can easily sort this object in ways not envisaged by the creator of the class without having to modify or subclass the class itself. Remember our modularity goals, see how that fits in here? Some creates a class we can customise it behaviour from the outside.
  • why write your own functions when all of pythons operators are available to you as functions itemgetter and attrgetter are examples of higher order functions, they return functions (or callables) as their results.   sorted requires a function that it can call we wrote a simple one for ourselves but this code was basically boilerplate that would have to be repeated. The operators in python can really be viewed as functions, they take operands (arguments) and produce results. There are many operators in Python which would be valuable viewed in this way.    The operator module does just that. The . operator is no execption and we can use it in our previous example. This is a higher order function its result is a function the extracts the field of the specified name from any object passed in. These and many more are available, they really come into their own in combination with what we are going to discuss in the next section.
  • A powerful feature of functional programs is the ability to declare that we would like to do something to a set of objects, what is that something? Well we can pass that as an argument. This simple idea can lead to profound insights. Google MapReduce is inspired by this functional view of the world allow operations to be parallelzed then the result collated later. Since the operations on each object a separate this can be done transparently to the user. The process of iteration itself can be further customised through the use of filter. This may seem like a lot of trouble to go to just to iterate over a bunch of objects, but this pattern comes up so often that it is more than worth it.
  • The idea of looping over a collection of objects and doing a customisable something to them is so fundamental to functional programming in python that there is whole module dedicated to that cause. It contains many useful variations on that theme. cycle() - infinitely cycle through an iterable repeat() - repeats an element a specified number of times chain()    - chains iterators together so they be iterated over as one sequnce groupby() - returns sub-iterators grouped by value of keyfunc(v) tee() - splits one iterator into n product() - cartesian product, equivalent to a nested for-loop
  • Syntactic sugar for higher order functions. No real difference but the way the clearly indicate the intentions make it much much nicer to use higher order functions. I think it is fair to say that most peoples use of higher order functions in python is via decorators. Decorators really cause an explosion of this sort of higher order functions in the wild and of course the standard library has many useful decorators built in. Do not write code like this it is no only a bad caching decorator (that contains a memory leak), it is unnecessary since python 2.7 it is in the standard library.
  • Allows you to define functions in terms of existing ones by freezing some of the arguments and keyword arguments. This avoids repetition of those parameters all over the code. This is another of the problems we discussed at the beginning, scattering the knowledge about a particular concern all over the code. This infact a rather more subtle version, it is not obvious in the heat of to see how having many function call for which a subset of the arguments must always be the same is modularity and maintenance problem. But thinking about it for a moment you can see that it really is.  functools partial allows you to avoid this without having to write trivial wrapper functions which people tend not to do anyway.   You may also here it referred to as currying , but if I call it currying people who really know about functional programming will come and beat me up because apparently currying is something different.
  • - I am not a classical rhetorician, but I aspire to play one on TV. The structure of classical rhetorical argument requires us to present the thesis, then explore the antithesis, and finally present the synthesis   - We are going take an example based approach, taking a look at a few Python OO and FP features that exemplify the point I am trying to make.   - The examples themselves are taken mostly taken from the Python standard library, not so much the internals buy how we are supposed to use it. This is useful because the standard library (or any library for that matter) necessarily needs to extensible and reusable from the outside without modifying the library itself.
  • We have seen how python's oo features allow us to express well the structural relationships between object and better communicate the constraints we want to impose as in the abc example. We have also seen how the functional approach makes it easy to express performing different operations over a given set of objects and how higher order functions allow us to easily customise those operations.   I could end the talk right here and legitimately claim that I have shown what I set to. However the story only gets better from here the OO and functional aspects of python are not separate worlds that are not intended to meet. Quite the contrary in Python the two approaches complement each other nicely. We are now approaching our foreshadowed conclusion that the design of Python takes both the OO and functional view into account. This section contains a selection of examples that demonstrate this multi-paradigm  approach to programming that Python supports and how it allows for really clean solutions.
  • The functional style of programming relies heavily on passing functions around, than applying them to objects later (using itertools or some of the other callback we talked about previously. Functions are descriptors Override binding behaviour Override differently for A.x and a.x Unbound methods know their class but not their instance Ideal for use in functional scenarios where the target object is specified directly.
  • Using the property higher order function to bring new functionality in an OO context. Avoids the unnecessary getter setter desease in Java other languages. C# does infact have properties because it is designed by Anders so has influence from Delphi The decorators are just sugar for the property higher order function.
  • property and inheritance there is an unintentional pun there.   Property results in early binding. The property has a handle to the specific function object passed into it when it was created. It cannot know about the methods in the derived class. We talked about python helping smooth the impedance mismatch between OO and FP well this is a case where the abstraction leaks a bit. Luckily the fix is not that complicated. A layer of indirection solved every problem in computer science. I do not think that is quite true it solves many problems though and this is one of them.
  • Do not scatter dependencies on specific classed throughout your  code this makes it harder to change implementations down the line    I know what you thinking I can use grep,    but if you now need to do some checking and perhaps initialise the object a little differently based on some previously on unforeseen factors this is now going to be much more of a pain. Invert the dependency, use a factory instead. Of course we all do this every time we are instantiating a class right. Modularity again we want to be able to change things in future without too much pain.
  • What I really mean is that python classes are callables. Python classes are callables, like functions and methods Indistinguishable from other callables to the caller, for the most part of course via introspection you can tell the difference but in typical cases they are the same Allow us to postpone the creation of a factory until it actually needed. this is similar to how property
  • One of the reasons python is so suitable for programming in a functional style is that there are several different types of callables, which are mostly inter changeable. Notice how the documentation for what I have been calling higher order functions, in the operator module such as itemgetter attrgetter and method caller say they return callables not functions. If they are not functions what else could they be? Class based callables can be handy if you want a callable that has internal state that is uses when called.
  • - I am not a classical rhetorician, but I aspire to play one on TV. The structure of classical rhetorical argument requires us to present the thesis, then explore the antithesis, and finally present the synthesis   - We are going take an example based approach, taking a look at a few Python OO and FP features that exemplify the point I am trying to make.   - The examples themselves are taken mostly taken from the Python standard library, not so much the internals buy how we are supposed to use it. This is useful because the standard library (or any library for that matter) necessarily needs to extensible and reusable from the outside without modifying the library itself.
  • Object Orientation vs Functional Programming in Python

    1. 1. Object Orientation vs. Functional Programming Writing Modular Python ProgramsTwitter: @insmallportionswww.insmallportions.com
    2. 2. About Me
    3. 3. Modularity
    4. 4. RoadmapThesis AntithesisObject Orientation is a proven Functional Programming is away of creating models in long standing approach tosoftware that represent the defining processes in terms ofproblem domain in a useful others at different levels ofmanner. There are many abstraction. Higher orderpatterns that show how to functions make the idiomaticachieve the modularity goal in ways to perform certain tasksdifferent contexts. fall out naturally. SynthesisPython has good support for both styles of programming andfor good reason. Depending on the situation one or the othermaybe more appropriate. Moreover in Python these tools donot only exist but they complement each other.
    5. 5. Object Orientation● Class Oriented● The Three Pillars of OO are:1. Delegation2. Polymorphism3. Instantiation
    6. 6. Template Methodclass Game(object): class Monopoly(Game): PLAYERS = 2 PLAYERS = 4 def initialize_game(self): def initialize_game(self): raise NotImplementedError() pass # Monopoly code here def make_play(self, player): def make_play(self, player): raise NotImplementedError() pass # Monopoly code here def end_of_game(self): def end_of_game(self): raise NotImplementedError() pass # Monopoly code here def print_winner(self): def print_winner(self): print self.current pass # Monopoly code here def play_game(self, players=PLAYERS): class Chess(Game): self.initialize_game() def initialize_game(self): self.current = 0 pass # Chess code here while not self.end_of_game(): def make_play(self, player): self.make_play(self.current) pass # Chess code here self.current = (self.current + 1) def end_of_game(self): % players pass # Chess code here self.print_winner()
    7. 7. Abstract Base Classes>>> class MyDict(dict): >>> from collections import Mapping... def __getitem__(self, key): >>> class >>> from collections import... return 101 Mapping... >>> class MyMapping(Mapping):>>> d = MyDict() ... def __getitem__(self, key):>>> d[x] ... return 101101 ...>>> d.get(x, 202) >>> m = MyMapping()202 Traceback (most recent call last):>>> File "<stdin>", line 1, in <module> TypeError: Cant instantiate abstract class MyMapping with abstract methods __iter__, __len__
    8. 8. Mixinsclass XMPPClient(object): class OnlineChess def connect(self): (Game, XMPPClient): pass # XMPP code def initialize_game(self): def disconnect(self): pass # Chess code here pass # XMPP code def send(self, player): ... pass # XMPP code def end_of_game(self): def terminate(self, player): pass # Chess code here raise NotImplementedError() def terminate(self, player): def mainain_presence(self): return self.end_of_game() self.connect() while not self.terminate(): yield self.disconnect()
    9. 9. Mixins (Multiple Inheritance)class A(object): passclass B(A): def method1(self): passclass C(A): def method1(self): passclass D(B, C): pass
    10. 10. Wrapping/Composition● Prefer Composition over Inheritance● Use a classs functionality but not its API● Expose only limited part of an object● Typical uses: ○ Adapt ○ Proxy ○ Decorate
    11. 11. Wrapping/Compositionclass Eprom(object): class SafeEprom(object): def read(self): def __init__(self, eprom): pass # Eprom code self._eprom = eprom def write(self, data): def read(self): pass # Eprom code return self._eprom. def complete(self): read() pass # Eprom code def write(self, data): if data.safe():class FileLikeEprom(object): self._eprom.write def __init__(self, eprom): (data) self._eprom = eprom def close(self): def read(self): self._eprom.complete() return self._eprom.read() def write(self, data): self._eprom.write(data) def close(self): self._eprom.complete()
    12. 12. Wrapping/Composition (Tricks)● Dont Repeat Yourself class FileLikeEprom(object): def __init__(self, eprom):● Avoid boilerplate self._eprom = eprom● Use __getattr__ to def __getattr__(self, a): return computed if a == close: attributes return self.close else: return getattr(self._eprom, a) def close(self): self._eprom.complete()
    13. 13. Mixins Againclass SafeAndFileLike(FileLikeEprom, SafeEprom): def __init__(self, *args, **kwargs): return super(SafeAndFileLike, self).__init__(*args,**kwargs)
    14. 14. RoadmapThesis AntithesisObject Orientation is a proven Functional Programming is away of creating models in long standing approach tosoftware that represent the defining processes in terms ofproblem domain in a useful others at different levels ofmanner. There are many abstraction. Higher orderpatterns that show how to functions make the idiomaticachieve the modularity goal in ways to perform certain tasksdifferent contexts. fall out naturally. SynthesisPython good support for both styles of programming and forgood reason. Depending on the situation one or the othermaybe more appropriate. Moreover in Python these tools donot only exist but they complement each other.
    15. 15. Functional Programming● Functions take input and produce output, without any side effects.● Pure functional languages are strict about side effect freeness.● Python is not a pure functional language.● Functions may be internally imperative, but appear purely functional in their behaviour.
    16. 16. Callbacks● The Hollywood principle● Role reversal, library code calls your code● Library code accepts a callable and invokes it when appropriate● The main uses: ○ Customisation ○ Event Handling
    17. 17. sorted() sans Callbacksclass Person(object): >>> people = [Person def __init__(self, f, s): (John, Smith), self.f = f ... Person(Mary, Doe), self.s = s ... Person(Lucy, Pearl),] def __str__(self): >>> for p in sorted(people): return %s %s % (self.f, self. ... print ps) ... def __eq__(self, other): Mary Doe return self.s == other.s Lucy Pearl def __lt__(self, other): John Smith return self.s < other.s >>>
    18. 18. sorted() with Callbacksclass Person(object): >>> for p in sorted(people, def __init__(self, f, s): key=first_name): self.f = f ... print p self.s = s ... def __str__(self): John Smith return %s %s % (self.f, self. Lucy Pearls) Mary Doe >>> for p in sorted(people,first_name = lambda p: p.f key=surname_name):surname = lambda p: p.s ... print p ... Mary Doe Lucy Pearl John Smith >>>
    19. 19. operator module from operator import attrgetter● attrgetter● itemgetter class Person(object):● add def __init__(self, f, s):● mul self.f = f self.s = s● pow def __str__(self): return %s %s % (self.f, self. s) first_name = attrgetter(f) surname = attrgetter(s)
    20. 20. Operations on collections of objects >>> def square(x):● sum ... return x ** 2● filter ...● map >>> l = [1, 2, 3, 4, 5]● reduce >>> sum(map(square, l)) 55 >>> def square(x): ... return x ** 2 ... >>> def odd(x): ... return x % 2 ... >>> l = [1, 2, 3, 4, 5] >>> sum(map(square, filter(odd, l))) 35
    21. 21. itertools module● cycle()● repeat()● chain()● tee()● product()● and many more...
    22. 22. Decoratorsdef cache(fn, c=None): def cache(fn, c=None): if c is None: c = {} if c is None: c = {} def cached(*args): def cached(*args): if args in c: if args in c: return c[args] return c[args] result = fn(*args) result = fn(*args) c[args] = result c[args] = result return result return result return cached return cacheddef adder(x, y): @cache return x + y def adder(x, y): return x + yadder = cache(adder)Do not write code like this, use: functools.lru_cache
    23. 23. Partial function evaluation>>> from functools import partial>>>>>> def power(base, exp=1):... return base ** exp...>>> square = partial(power, exp=2)>>> cube = partial(power, exp=3)>>>>>> l = [1, 2, 3, 4, 5]>>> sum(map(square, l))55>>> print sum(map(cube, l))225
    24. 24. RoadmapThesis AntithesisObject Orientation is a proven Functional Programming is away of creating models in long standing approach tosoftware that represent the defining processes in terms ofproblem domain in a useful others at different levels ofmanner. There are many abstraction. Higher orderpatterns that show how to functions make the idiomaticachieve the modularity goal in ways to perform certain tasksdifferent contexts. fall out naturally. SynthesisPython good support for both styles of programming and forgood reason. Depending on the situation one or the othermaybe more appropriate. Moreover in Python these tools donot only exist but they complement each other.
    25. 25. Best of Both Worlds
    26. 26. Unbound methods>>> food = [Spam, ham, ● Functions are descriptorsCheese, eggs] ● Override binding behaviour>>> sorted(food) ● Override differently for A.x[Cheese, Spam, eggs, ham] and a.x>>> sorted(food, key=str.lower) ● Unbound methods know[Cheese, eggs, ham, Spam] their class but not their>>> instance ● Ideal for use in a functional style>>> sorted(food, key=ham.lower)Traceback (most recent call last): File "<stdin>", line 1, in<module>TypeError: lower() takes no
    27. 27. Computed fields (property) class Person(object):class Person(object): def __init__(self, f, s): def __init__(self, f, s): self.f = f self.f = f self._s = s self.s = s @property @property def s(self): def fullname(self): return self._s.upper() return %s %s % (self.f, @s.setter self.s) def s(self, value): self._s = value>>> p = Person(John, Smith)>>> p.fullname >>> p = Person(Jane,John Smith Doe) >>> p.s DOE property([fget[, fset[, fdel[, doc]]]])
    28. 28. property and inheritanceclass Person(object): class Person(object): def __init__(self, t, f, s): def __init__(self, t, f, s): ... ... def full(self): def full(self): return %s %s % (self.f, return %s %s % (self.f, self.s) self.s) fullname = property(full) def _full(self): return self.full()class Customer(Person): fullname = property(_full) def full(self): return %s. %s %s class Customer(Person):% (self.t, self.f, def full(self):self.s) return %s. %s %s % (self.t, self.f, >>> c = Customer(Mr, self.s)John, Smith)>>> c.fullname >>> c.fullname
    29. 29. Dependency Inversionclass Employee(object): def employee_fact(f, s): def __init__(self, f, s): return Employee(f, s) self.f = f self.s = s def register(emps, fact): def register(self): for f, s in emps: pass # Register me emp = fact(f, s) emp.register()def register(emps): for f, s in emps: >>> emps = [(John, emp = Employee(f, s) Smith), (Mary, Doe)] emp.register() >>>register(emps, employee_fact)>>> emps = [(John,Smith), (Mary, Doe)]>>>register(emps)
    30. 30. Python classes are factoriesclass Employee(object): ● Python classes are callables def __init__(self, f, s): ● Indistinguishable from other self.f = f callables to the caller self.s = s ● Allow us to postpone the def register(self): creation of a factory until it pass # Register me actually neededdef register(emps, fact): for f, s in emps: emp = fact(f, s) emp.register()>>> emps = [(John, Smith),(Mary, Doe)]>>>register(emps,Employee)
    31. 31. Many types of callables class Callable(object): ● Functions def __init__(self, m): ● Unbound methods self.message = m def __call__(self): ● Bound methods print self.message ● Classes class NotCallable(object): ● Any object that has a def call(self): __call__ method is a print "You Rang?" callable ● Testable using the >>> c = Callable(You Rang) >>> c() callable built-in function You Rang >>> n = NotCallable()>>> callable(str) >>> n()True Traceback (most recent call last):>>> callable(Spam) File "<stdin>", line 1, in <module>False TypeError: NotCallable object is not>>> callable
    32. 32. RoadmapThesis AntithesisObject Orientation is a proven Functional Programming is away of creating models in long standing approach tosoftware that represent the defining processes in terms ofproblem domain in a useful others at different levels ofmanner. There are many abstraction. Higher orderpatterns that show how to functions make the idiomaticachieve the modularity goal in ways to perform certain tasksdifferent contexts. fall out naturally. SynthesisPython good support for both styles of programming and forgood reason. Depending on the situation one or the othermaybe more appropriate. Moreover in Python these tools do notonly exist but they complement each other nicely.
    33. 33. We hire superheroes!● www.demonware.net/jobs/● Development & Operations Positions● Come talk to me any time or meet me at the hiring event

    ×