print 'open the fridge'
print 'put elephant into the fridge'
print 'close the fridge' 

class Fridge:
    def open(self):
        print 'open the fridge'

    def put(self, something):
        print 'put %s into the fridge' % something

    def close(self):
        print 'close the fridge'

fridge = Fridge()
fridge.open()
fridge.put('elephant')
fridge.close() 

b^n = b * b * b ... * b (b occurs n times)

def exp(b, n):
    result = 1
    for _ in range(n):
        result *= b
    return result

b^n = b * b^(n - 1)b^0 = 1

• track state by function arguments
• reduce length of call stack and improve efficiency
  (not supported in python yet)

• The well known build in functions
  
• map(), filter(), reduce()

• sorted()
  

• A tiny example:
  

__report_indent = [0]

def trace(fn):
    def wrap(*params,**kwargs):
        call = wrap.callcount = wrap.callcount + 1

        indent = ' ' * __report_indent[0]
        fc = "%s(%s)" % (fn.__name__, ', '.join(
            [a.__repr__() for a in params] +
            ["%s = %s" % (a, repr(b)) for a,b in kwargs.items()]
        ))

        print "%s%s called [#%s]"\
            % (indent, fc, call)
        __report_indent[0] += 1
        ret = fn(*params,**kwargs)
        __report_indent[0] -= 1
        print "%s%s returned %s [#%s]"\
            % (indent, fc, repr(ret), call)

        return ret
    wrap.callcount = 0
    return wrap 

fib = memorize(fib) 

@memorize
def fib(n):
    ... 

• A closure, like an object instance, is a way of carrying around a bundle of data and functionality, wrapped up together.
  

• Lexical scope is a nature way to implement closure. 
  

def addx(x):
    def func(y):
        return x + y
    return func
foo = addx(5)
x = 3
>>>foo(10) 
15 # in lexical scope, 5 is bind to x in foo

def counter():
    count = 0
    def func():
        count += 1
        return count
    return func
>>> count = counter()
>>> count()
Traceback (most recent call last):
  File "", line 1, in 
    count()
  File "C:/Users/JC/Desktop/a.py", line 152, in func
    count += 1
UnboundLocalError: local variable 'count' referenced before assignment

def counter():
    count = [0]
    def func():
        count[0] += 1
        return count[0]
    return func
>>> count = counter()
>>> count()
1
>>> count()
2 

get_cursors_if(source, satisfy_func, transform_func)
get_cursor_names_if = partial(get_cursors_if,    transform_func = lambda c: c.displayname)
get_class_cursor = partial(get_cursors_if,    satisfy_func = lambda c: c.kind == CursorKind.CXX_CLASS,    transform_func = lambda c: c)

>>> Ackermann(0, 4)
8                      #hyper 2  multipication 2 * 4
>>> Ackermann(1, 4)
16                     #hyper 3 exponentiation 2 ^ 4>>> Ackermann(2, 3)
16                     #hyper 4 tetration  2 ^^ 3
>>> Ackermann(2, 4)
65536                  # 2 ^^ 4

• Convenience
• Bind data with function to build more specific function
• Encapsulation and detail hidding

def func(a, b, c):
    return a + b + c

def curried_func(a):
    return lambda b: lambda c: a + b + c

>>> print func('a', 'b', 'c')
abc
>>> print curried_func('a')('b')('c')
abc 

• Currying is close related to partial application
  
• Currying can transfer multiple argument function to a chain of single argument function which is very useful in old days when functions can only take in one argument.
• Nowadays, currying is generally considered as language support for partial application. It can be replaced by partial application, thus it is seldom used in languages that doesn't support currying.
• A Haskell example. Haskell has language syntax that support currying 

computation a b c d = (a + b^2+ c^3 + d^4)

fillOne   = computation 1 
fillTwo   = fillOne 2     
fillThree = fillTwo 3     
answer    = fillThree 5   
-- Result: answer == 657 

#a ? b : c
(a and b) or c 

#a ? b : c
my_if(a, b, c) 

def my_if(a, b, c):
    if a:
        return b()
    else:
        return c() 

my_if(a, lambda : b, lambda : c) 

def fib():
    def stream(a, b):
        return (a, lambda : stream(a + b, a))
    return stream(1, 0) 

def isprime(n):
    for x in xrange(2, int(n**0.5)+1):
        if n % x == 0:
            return False
    return True

def prime():
    def stream(n):
        if isprime(n):
            return (n, lambda : stream(n + 1))
        else:
            return stream(n + 1)
    return stream(2)  

def twin_prime():
    def stream(n):
        if isprime(n) and isprime(n + 2):
            return ((n, n + 2), lambda : stream(n + 1))
        else:
            return stream(n + 1)
    return stream(2)

>>> for i in range(1, 5):
. . . 	print get_nth(twin_prime, i)

(3, 5)
(5, 7)
(11, 13)
(17, 19)

def gen_prime():
    n = 2
    def gen(n):
        if isprime(n):
            return n
        else:
            return gen(n + 1)
    while True:
        n = gen(n)
        yield n
        n += 1 

class Zoo:
    def open(self):
        ...
    def put(self, object):
        ...
    def close(self):
        ... 

def open(something):
    if something == 'fridge':
        ...
    elif something == 'zoo':
        ...

def put
    if... 
def close    if... 

class Fridge:
    ...
    def clean(self):
        print 'clean the fridge'

class Zoo:
    ...
    def clean(self):
        print 'clean the zoo'