Python_Functional Programming.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#### FUNCTIONAL CONCEPTS FOR PYTHON\n",
    "# Taken from:\n",
    "# Functional  Programming  in Python by David Mertz - O'Reilly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "### ENCAPSULATION\n",
    "\n",
    "# configure the data to start with \n",
    "collection = get_initial_state() \n",
    "state_var = None \n",
    "for datum in data_set:    \n",
    "    if condition(state_var):        \n",
    "        state_var = calculate_from(datum)        \n",
    "        new = modify(datum, state_var)        \n",
    "        collection.add_to(new)    \n",
    "    else:        \n",
    "        new = modify_differently(datum)\n",
    "        collection.add_to(new)\n",
    "# Now actually work with the data \n",
    "for thing in collection:    \n",
    "    process(thing) \n",
    "    \n",
    "#We might simply remove the “how” of the data construction from the current scope, \n",
    "#and tuck it away in a function that we can think about in isolation \n",
    "#(or not think about at all once it is sufficiently abstracted). \n",
    "#For example:\n",
    "# tuck away construction of data\n",
    "def make_collection(data_set):    \n",
    "    collection = get_initial_state()    \n",
    "    state_var = None    \n",
    "    for datum in data_set:\n",
    "        if condition(state_var):\n",
    "            state_var = calculate_from(datum, state_var)\n",
    "            new = modify(datum, state_var)\n",
    "            collection.add_to(new)\n",
    "        else:            \n",
    "            new = modify_differently(datum)\n",
    "            collection.add_to(new)    \n",
    "    return collection \n",
    "\n",
    "# Now actually work with the data \n",
    "for thing in make_collection(data_set):    \n",
    "    process(thing) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "### COMPREHENSIONS\n",
    "\n",
    "#if our original code was:\n",
    "collection = list() \n",
    "for datum in data_set:    \n",
    "    if condition(datum):        \n",
    "        collection.append(datum)    \n",
    "    else:        \n",
    "        new = modify(datum)        \n",
    "        collection.append(new) \n",
    "        \n",
    "#Somewhat more compactly we could write this as:\n",
    "collection = [d if condition(d) else modify(d) for d in data_set] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "### GENERATORS\n",
    "\n",
    "# they are also lazy. That is to say that they are merely a description of “how to get the data” that is \n",
    "# not realized until one explicitly asks for it, either by calling .next() \n",
    "\n",
    "log_lines = (line for line in read_line(huge_log_file) if complex_condition(line))\n",
    "\n",
    "# Obviously, this generator comprehension also has imperative versions, for example:\n",
    "def get_log_lines(log_file):\n",
    "    line = read_line(log_file)    \n",
    "    while True:         #  the behind-the-scenes “how” of a while loop over an iteratable (generator above)\n",
    "        try:            \n",
    "            if complex_condition(line):                \n",
    "                yield line   \n",
    "            line = read_line(log_file)        \n",
    "        except StopIteration:            \n",
    "            raise\n",
    "            \n",
    "log_lines = get_log_lines(huge_log_file) \n",
    "\n",
    "# We could do this with a class that had .__next__() and .__iter__() methods. For example:\n",
    "class GetLogLines(object):    \n",
    "    def __init__(self, log_file):        \n",
    "        self.log_file = log_file        \n",
    "        self.line = None    \n",
    "    def __iter__(self):        \n",
    "        return self    \n",
    "    def __next__(self):        \n",
    "        if self.line is None:\n",
    "            self.line = read_line(log_file)\n",
    "        while not complex_condition(self.line):\n",
    "            self.line = read_line(self.log_file)\n",
    "        return self.line\n",
    "        \n",
    "log_lines = GetLogLines(huge_log_file)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "### DICTS AND SETS\n",
    "\n",
    "# dictionaries and sets can be created “all at once” rather than by repeatedly calling .update() or .add() in a loop. For example:\n",
    "{i:chr(65+i) for i in range(6)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "{chr(65+i) for i in range(6)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "### RECURSION\n",
    "\n",
    "# Python lacks an internal feature called tail call elimination that makes deep recursion computationally efficient \n",
    "# in some languages. Let us find a trivial example where recursion is really just a kind of iteration:\n",
    "def running_sum(numbers, start=0):    \n",
    "    if len(numbers) == 0:        \n",
    "        print()        \n",
    "        return    \n",
    "    total = numbers[0] + start    \n",
    "    print(total, end=\" \")    \n",
    "    running_sum(numbers[1:], total)\n",
    "\n",
    "running_sum([5,6,7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# A slightly less trivial example, factorial in recursive and iterative style:\n",
    "def factorialR(N):    \n",
    "    \"Recursive factorial function\"    \n",
    "    assert isinstance(N, int) and N >= 1    \n",
    "    return 1 if N <= 1 else N * factorialR(N-1)\n",
    "\n",
    "print(factorialR(5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def factorialI(N):    \n",
    "    \"Iterative factorial function\"    \n",
    "    assert isinstance(N, int) and N >= 1    \n",
    "    product = 1    \n",
    "    while N >= 1:        \n",
    "        product *= N        \n",
    "        N -= 1    \n",
    "    return product\n",
    "\n",
    "print(factorialI(5))\n",
    "\n",
    "# It is not a good idea in Python—most of the time—to use recursion merely for “iteration by other means.”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "### ALTERNATIVES TO FOR LOOPs (when it is a good idea)\n",
    "\n",
    "## using map()\n",
    "\n",
    "# If we simply call a function inside a for loop, the built-in higherorder function map() comes to our aid:\n",
    "for e in it:    # statement-based loop    \n",
    "    func(e) \n",
    "    \n",
    "# The following code is entirely equivalent to the functional version, except there is no repeated rebinding of the variable e involved, and hence no state:\n",
    "map(func, it)   # map()-based \"loop\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## A similar technique is available for a functional approach to sequential program flow:\n",
    "# let f1, f2, f3 (etc) be functions that perform actions \n",
    "# an execution utility function \n",
    "do_it = lambda f, *args: f(*args) # map()-based action sequence \n",
    "map(do_it, [f1, f2, f3]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# We can combine the sequencing of function calls with passing arguments from iterables:\n",
    "hello = lambda first, last: print(\"Hello\", first, last) \n",
    "bye = lambda first, last: print(\"Bye\", first, last) \n",
    "_ = list(map(do_it, [hello, bye], ['David','Jane'], ['Mertz','Doe'])) \n",
    "\n",
    "do_all_funcs = lambda fns, *args: [list(map(fn, *args)) for fn in fns] \n",
    "_ = do_all_funcs([hello, bye], ['David','Jane'], ['Mertz','Doe']) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "### CALLABLES\n",
    "\n",
    "#  Python actually gives us several different ways to create functions, or at least something very function-like (i.e., that can be called). They are: \n",
    "# • Regular functions created with def and given a name at definition time \n",
    "# • Anonymous functions created with lambda \n",
    "# • Instances of classes that define a __call()__ method \n",
    "# • Closures returned by function factories \n",
    "# • Static methods of instances, either via the @staticmethod decorator or via the class __dict__ \n",
    "# • Generator functions \n",
    "\n",
    "## Lambdas and named functions\n",
    "def hello1(name): \n",
    "    print(\"Hello\", name) \n",
    "    \n",
    "hello2 = lambda name: print(\"Hello\", name) \n",
    "\n",
    "hello1('David')\n",
    "hello2('David')\n",
    "# The only real difference is in .__qualname__ attribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "### CLOSURES and CLASSES\n",
    "\n",
    "# Let us construct a toy example that shows this, something just past a “hello world” of the different styles:\n",
    "# A class that creates callable adder instances \n",
    "\n",
    "class Adder(object):    \n",
    "    def __init__(self, n):        \n",
    "        self.n = n    \n",
    "    def __call__(self, m):        \n",
    "        return self.n + m \n",
    "\n",
    "add5_i = Adder(5)       \n",
    "# \"instance\" or \"imperative\" We have constructed something callable that adds five to an argument passed in. Seems simple and mathematical enough. Let us also try it as a closure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def make_adder(n):    \n",
    "    def adder(m):        \n",
    "        return m + n    \n",
    "    return adder \n",
    "\n",
    "add5_f = make_adder(5)  \n",
    "# \"functional\" So far these seem to amount to pretty much the same thing, but the mutable state in the instance provides a attractive nuisance:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "add5_i(10) \n",
    "add5_f(10)          # only argument affects result 15 \n",
    "add5_i.n = 10       # state is readily changeable \n",
    "add5_i(10)          # result is dependent on prior flow 20 \n",
    "\n",
    "# once the object exists, the closure behaves in a pure functional way, while the class instance remains \n",
    "# state dependent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "### METHODS OF CLASSES\n",
    "\n",
    "# accessors are callables with a limited use (from a functional programming perspective) in that they take no \n",
    "# arguments as getters, and return no value as setters:\n",
    "class Car(object):    \n",
    "    def __init__(self):        \n",
    "        self._speed = 100\n",
    "    @property    \n",
    "    def speed(self):        \n",
    "        print(\"Speed is\", self._speed)        \n",
    "        return self._speed\n",
    "    @speed.setter    \n",
    "    def speed(self, value):        \n",
    "        print(\"Setting to\", value)        \n",
    "        self._speed = value\n",
    "\n",
    "# >> car = Car()  \n",
    "# >>> car.speed = 80  # Odd syntax to pass one argument \n",
    "# Setting to 80 \n",
    "# >>> x = car.speed \n",
    "# x is 80\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "### STATIC METHODS\n",
    "\n",
    "# One use of classes and their methods that is more closely aligned with a functional style of programming is to use \n",
    "# them simply as namespaces to hold a variety of related functions:\n",
    "\n",
    "import math \n",
    "class RightTriangle(object):    \n",
    "    \"Class used solely as namespace for related functions\"    \n",
    "    @staticmethod    \n",
    "    def hypotenuse(a, b):        \n",
    "        return math.sqrt(a**2 + b**2)\n",
    "    @staticmethod    \n",
    "    def sin(a, b):        \n",
    "        return a / RightTriangle.hypotenuse(a, b)\n",
    "    @staticmethod    \n",
    "    def cos(a, b):        \n",
    "        return b / RightTriangle.hypotenuse(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 5\n",
      "7 11 13 17 19 23 29 31 37 41 "
     ]
    }
   ],
   "source": [
    "### GENERATOR FUNCTIONS\n",
    "\n",
    "# A special sort of function in Python is one that contains a yield statement, which turns it into a generator. \n",
    "# What is returned from calling such a function is not a regular value, but rather an iterator that produces a \n",
    "# sequence of values as you call the next() function on it or loop over it.\n",
    "\n",
    "def get_primes(): \n",
    "    \"Simple lazy Sieve of Eratosthenes\" \n",
    "    candidate = 2 \n",
    "    found = [] \n",
    "    while True: \n",
    "        if all(candidate % prime != 0 for prime in found): \n",
    "            yield candidate \n",
    "            found.append(candidate) \n",
    "        candidate += 1\n",
    "\n",
    "primes = get_primes() \n",
    "print(next(primes), next(primes), next(primes))\n",
    "# (2, 3, 5) \n",
    "for _, prime in zip(range(10), primes): \n",
    "    print(prime, end=\" \") \n",
    "#    7 11 13 17 19 23 29 31 37 41 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Paper object at 0x0000000003944C18>\n"
     ]
    }
   ],
   "source": [
    "### MULTIPLE DISPATCHING\n",
    "\n",
    "# A very interesting approach to programming multiple paths of execution is a technique called “multiple dispatch” \n",
    "# or sometimes “multimethods.” The idea here is to declare multiple signatures for a single function and call the \n",
    "# actual computation that matches the types or properties of the calling arguments. \n",
    "# Note: used to avoid many if-else statements to test matching \n",
    "\n",
    "from multipledispatch import dispatch\n",
    "\n",
    "class Thing(object): pass \n",
    "class Rock(Thing): pass\n",
    "class Paper(Thing): pass \n",
    "class Scissors(Thing): pass\n",
    "\n",
    "@dispatch(Rock, Rock) \n",
    "def beats3(x, y): \n",
    "    return None\n",
    "\n",
    "@dispatch(Rock, Paper) \n",
    "def beats3(x, y): \n",
    "    return y\n",
    "\n",
    "@dispatch(Rock, Scissors) \n",
    "def beats3(x, y): \n",
    "    return x\n",
    "\n",
    "@dispatch(Paper, Rock) \n",
    "def beats3(x, y): \n",
    "    return x\n",
    "\n",
    "@dispatch(Paper, Paper) \n",
    "def beats3(x, y): \n",
    "    return None\n",
    "\n",
    "@dispatch(Paper, Scissors) \n",
    "def beats3(x, y): \n",
    "    return x\n",
    "\n",
    "@dispatch(Scissors, Rock) \n",
    "def beats3(x, y): \n",
    "    return y\n",
    "\n",
    "@dispatch(Scissors, Paper) \n",
    "def beats3(x, y): \n",
    "    return x\n",
    "\n",
    "@dispatch(Scissors, Scissors) \n",
    "def beats3(x, y): \n",
    "    return None\n",
    "\n",
    "@dispatch(object, object) \n",
    "def beats3(x, y):    \n",
    "    if not isinstance(x, (Rock, Paper, Scissors)):        \n",
    "        raise TypeError(\"Unknown first thing\")    \n",
    "    else:        \n",
    "        raise TypeError(\"Unknown second thing\")\n",
    "\n",
    "rock, paper = Rock(), Paper()        \n",
    "print(beats3(rock, paper))\n",
    "# <__main__.DuckPaper at 0x103b894a8> \n",
    "# >>> beats3(rock, 3) \n",
    "# TypeError: Unknown second thing\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#### LAZY EVALUATION\n",
    "\n",
    "## Custom sequence using \"abc\"\n",
    "# Given the get_primes() generator function discussed earlier, we might write our own container to simulate the same \n",
    "# thing, for example:\n",
    "from collections.abc import Sequence \n",
    "class ExpandingSequence(Sequence):    \n",
    "    def __init__(self, it):        \n",
    "        self.it = it        \n",
    "        self._cache = []    \n",
    "    def __getitem__(self, index):        \n",
    "        while len(self._cache) <= index:            \n",
    "            self._cache.append(next(self.it))        \n",
    "        return self._cache[index]    \n",
    "    def __len__(self):        \n",
    "        return len(self._cache) \n",
    "\n",
    "# This new container can be both lazy and also indexible:\n",
    "primes = ExpandingSequence(get_primes())\n",
    "for _, p in zip(range(10), primes):     \n",
    "    print(p, end=\" \") \n",
    "# 2 3 5 7 11 13 17 19 23 29 \n",
    "primes[10]  # 31 \n",
    "primes[5]   # 13 \n",
    "len(primes) # 11 \n",
    "primes[100] # 547 \n",
    "len(primes) # 101"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 2 3 5 8 13 21 34 55 "
     ]
    }
   ],
   "source": [
    "## Custom iterator\n",
    "\n",
    "# writing custom iterators as generator functions is most natural. However, we can also create custom classes that \n",
    "# obey the protocol; often these will have other behaviors (i.e., methods) as well, but most such behaviors \n",
    "# necessarily rely on statefulness and side effects to be meaningful\n",
    "\n",
    "from collections.abc import Iterable \n",
    "class Fibonacci(Iterable):    \n",
    "    def __init__(self):        \n",
    "        self.a, self.b = 0, 1        \n",
    "        self.total = 0    \n",
    "    def __iter__(self):        \n",
    "        return self    \n",
    "    def __next__(self):        \n",
    "        self.a, self.b = self.b, self.a + self.b        \n",
    "        self.total += self.a        \n",
    "        return self.a    \n",
    "    def running_sum(self):        \n",
    "        return self.total\n",
    "    \n",
    "fib = Fibonacci() \n",
    "# fib.running_sum() # 0 \n",
    "for _, i in zip(range(10), fib): \n",
    "    print(i, end=\" \") \n",
    "# >>> 1 1 2 3 5 8 13 21 34 55 \n",
    "# fib.running_sum() # 143 \n",
    "# next(fib) # 89 \n",
    "\n",
    "# Note:  a class that both implements the iterator protocol and also provides an additional method to return \n",
    "# something stateful about its instance. This approach can be usefull but not functional (because statefullness)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "True\n",
      "1 1\n",
      "1 2\n",
      "2 4\n",
      "3 7\n",
      "5 12\n",
      "8 20\n",
      "13 33\n"
     ]
    }
   ],
   "source": [
    "## Module: itertools \n",
    "# The module itertools is a collection of very powerful—and carefully designed—functions for performing iterator \n",
    "# algebra. That is, these allow you to combine iterators in sophisticated ways without having to concretely \n",
    "# instantiate anything more than is currently required\n",
    "# https://docs.python.org/3.5/library/itertools.html\n",
    "\n",
    "def fibonacci():     \n",
    "    a, b = 1, 1      \n",
    "    while True:          \n",
    "        yield a          \n",
    "        a, b = b, a+b\n",
    "\n",
    "print(type(fibonacci()))\n",
    "print('__iter__' in dir(fibonacci()) and '__next__' in dir(fibonacci()) )\n",
    "\n",
    "from itertools import tee, accumulate \n",
    "s, t = tee(fibonacci()) \n",
    "pairs = zip(t, accumulate(s)) \n",
    "for _, (fib, total) in zip(range(7), pairs):      \n",
    "    print(fib, total) \n",
    "\n",
    "# NOTE: zip(), map(), filter(), and range() (which is, in a sense, just a terminating itertools.count()) could well \n",
    "# live in itertools if they were not built-ins. That is, all of those functions lazily generate sequential items \n",
    "# (mostly based on existing iterables) without creating a concrete sequence\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#### Higher Order Functions\n",
    "\n",
    "#  a higher-order function is simply a function that takes one or more functions as arguments and/or produces a \n",
    "# function as a result. \n",
    "\n",
    "# Classic \"FP-style\" \n",
    "transformed = map(tranformation, iterator) \n",
    "# Comprehension \n",
    "transformed = (transformation(x) for x in iterator)\n",
    "# Classic \"FP-style\" \n",
    "filtered = filter(predicate, iterator) \n",
    "# Comprehension \n",
    "filtered = (x for x in iterator if predicate(x)) \n",
    "# The function functools.reduce() is very general, very powerful, and very subtle to use to its full power. It takes \n",
    "# successive items of an iterable, and combines them in some way. The most common use case for reduce() is probably \n",
    "# covered by the built-in sum(), which is a more compact spelling of:\n",
    "from functools import reduce \n",
    "total = reduce(operator.add, it, 0) \n",
    "# total = sum(it) \n",
    "# It may or may not be obvious that map() and filter() are also a special cases of reduce(). That is:\n",
    "add5 = lambda n: n+5 \n",
    "reduce(lambda l, x: l+[add5(x)], range(10), []) [5, 6, 7, 8, 9, 10, 11, 12, 13, 14] \n",
    "# simpler: map(add5, range(10)) \n",
    "isOdd = lambda n: n%2 \n",
    "reduce(lambda l, x: l+[x] if isOdd(x) else l, range(10), []) [1, 3, 5, 7, 9] \n",
    "# simpler: filter(isOdd, range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function strong_decorate.<locals>.func_wrapper at 0x000000000379AEA0>\n",
      "<strong><p>lorem ipsum, John dolor sit amet</p></strong>\n"
     ]
    }
   ],
   "source": [
    "## DECORATORS\n",
    "\n",
    "# probably the most common use of higher-order functions in Python is as decorators. Decorators in Python are possible \n",
    "# because:\n",
    "# - encapsulation: define a function inside a function, the contained function can access but not assign the container function\n",
    "# - functions can be passed as a parameter (functions are first-class objects)\n",
    "# - functions can return functions\n",
    "\n",
    "# Taken from: http://thecodeship.com\n",
    "\n",
    "def strong_decorate(func):\n",
    "    '''first decorator'''\n",
    "    def func_wrapper(name):\n",
    "        return \"<strong>{0}</strong>\".format(func(name))\n",
    "    return func_wrapper\n",
    "\n",
    "def p_decorate(func):\n",
    "    '''second decorator'''\n",
    "    def func_wrapper(name):\n",
    "        return \"<p>{0}</p>\".format(func(name))\n",
    "    return func_wrapper\n",
    "\n",
    "@strong_decorate\n",
    "@p_decorate\n",
    "def get_text(name):\n",
    "    '''sample function'''\n",
    "    return \"lorem ipsum, {0} dolor sit amet\".format(name)\n",
    "\n",
    "#my_get_text = p_decorate(get_text)\n",
    "print(get_text)\n",
    "print(get_text(\"John\"))\n",
    "\n",
    "# A function that takes another function as an argument, generates a new function, augmenting the work of the original \n",
    "# function, and returning the generated function so we can use it anywhere."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<p>John Doe</p>\n"
     ]
    }
   ],
   "source": [
    "## Using self and *args and **kargs\n",
    "\n",
    "def p_decorate(func):\n",
    "   def func_wrapper(*args, **kwargs):\n",
    "       return \"<p>{0}</p>\".format(func(*args, **kwargs))\n",
    "   return func_wrapper\n",
    "\n",
    "class Person(object):\n",
    "    def __init__(self):\n",
    "        self.name = \"John\"\n",
    "        self.family = \"Doe\"\n",
    "\n",
    "    @p_decorate\n",
    "    def get_fullname(self):\n",
    "        return self.name+\" \"+self.family\n",
    "\n",
    "my_person = Person()\n",
    "\n",
    "print(my_person.get_fullname())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<p><strong>Hello John</strong></p>\n",
      "func_wrapper\n"
     ]
    }
   ],
   "source": [
    "## Passing arguments to decorators\n",
    "\n",
    "# Looking back at the example before the one above, you can notice how redundant the decorators in the example are. \n",
    "# 2 decorators each with the same functionality but wrapping the string with different tags. We can definitely do much \n",
    "# better than that. Why not have a more general implementation for one that takes the tag to wrap with as a string? \n",
    "# Yes please!\n",
    "\n",
    "#from functools import wraps\n",
    "\n",
    "def tags(tag_name):\n",
    "    def tags_decorator(func):\n",
    "        #@wraps(func)\n",
    "        def func_wrapper(name):\n",
    "            return \"<{0}>{1}</{0}>\".format(tag_name, func(name))\n",
    "        return func_wrapper\n",
    "    return tags_decorator\n",
    "\n",
    "@tags(\"p\")\n",
    "@tags(\"strong\")\n",
    "def get_text(name):\n",
    "    return \"Hello \"+name\n",
    "\n",
    "print(get_text(\"John\"))\n",
    "\n",
    "print(get_text.__name__)\n",
    "\n",
    "# NOTE: try to uncomment the import and the \"wraps\" decorator and see how the function name is assigned properly \n",
    "# (good for debugging).\n",
    "\n",
    "# Links:\n",
    "# https://github.com/mjhea0/python-decorators\n",
    "# http://simeonfranklin.com/blog/2012/jul/1/python-decorators-in-12-steps/\n",
    "# https://wiki.python.org/moin/PythonDecorators#What_is_a_Decorator\n",
    "## A guide to develop with Decorators:\n",
    "# http://www.artima.com/weblogs/viewpost.jsp?thread=240808\n",
    "# http://www.artima.com/weblogs/viewpost.jsp?thread=240845\n",
    "# http://www.artima.com/weblogs/viewpost.jsp?thread=241209"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.3.5rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}