def fib_direct(n):

    assert n > 0, 'invalid n'

    if n < 3:

        return n

    else:

        return fib_direct(n - 1) + fib_direct(n - 2)

#! /usr/bin/env python

def shout(word='yes'):

	return word.capitalize() + '!'

print shout()

#outputs:Yes!

'''

As an object, you can assign the function to a variable like any other object.

Notece we don't use parentheses: we are not calling the function,

we are putting the function 'shout' into the variable 'scream'.

'''

scream = shout

print scream()

#outputs:Yes!

'''

More than that, it meams you can remove the old name 'shout',

and the function will still be accessible from 'scream'.

'''

del shout

try:

	print shout()

except NameError, e:

	print e

#outputs:name 'shout' is not defined

print scream()

#outputs:Yes!

#! /usr/bin/env python

def talk():

	# You can define a function on the fly in 'talk'

	def whisper(word = 'yes'):

		return word.lower() + '...'

	print whisper()

'''

You call 'talk', that define 'whisper', every time you call it,

then 'whisper' is called in 'talk'

'''

talk()

#outputs: yes...

#But 'whisper' does not exist outside 'talk'

try:

	print whisper()

except NameError, e:

	print e

#outputs: name 'whisper' is not defined

#! /usr/bin/env python

def get_talk(kind = 'shout'):

	def whisper(word = 'yes'):

		return word.lower() + '...'

	def shout(word = 'yes'):

		return word.capitalize() + '!'

	return whisper if kind == 'whisper' else shout

# Get the function and assign it to a variable

talk = get_talk()

# You can see that 'talk' is here a function object:

print talk

# outputs:<function shout at 0x107ae9578>

print talk()

# outputs: Yes!

# And you can even use it directly if you feek wild:

print get_talk('whisper')()

# outputs: yes...

#! /usr/bin/env python

def whisper(word = 'yes'):

	return word.lower() + '...'

def do_something_before(func):

	print 'I do something before.'

	print 'Now the function you gave me:\n', func()

do_something_before(whisper)

'''

outputs:

I do something before.

Now the function you gave me:

yes...

'''

#! /usr/bin/env python

def my_tiny_new_decorator(a_function_to_decorate):

	'''

	Indise, the decorator defines a function on the fly: the wrapper.

	This function is going to be wrappered arounded the original function

	so it can execute code before and after it.

	'''

	def the_wrapper_around_the_original_function():

		'''

		Put here the code you want to be execute before the original function is called

		'''

		print 'Before the function runs'

		#Call the function here(using parentheses)

		a_function_to_decorate()

		'''

		Put here the code you want to be executed after the original function is called

		'''

		print 'After the function runs'

	'''

	At this point, 'a_function_to_decorate' has never been executed.

	We return the wrapper function we have just created.

	The wrapper contains the function and the code to execute before

	and after. It's readu to use!

	'''

	return the_wrapper_around_the_original_function

# Now imagine you create a function which you don't want to ever touch or modify again.

def a_stand_alone_function():

	print 'I am a stand alone function, do not you dare modify me'

# Call the function a_stand_alone_function directly

a_stand_alone_function()

# outputs: I am a stand alone function, do not you dare modify me

'''

Well, you can decorate it to extend its behavior.

Just pass it to the decorator, it will wrap it dynamically in any code

you want and return you a new function ready to be used:

'''

a_stand_alone_function_decorated = my_tiny_new_decorator(a_stand_alone_function)

a_stand_alone_function_decorated()

'''outputs:

Before the function runs

I am a stand alone function, do not you dare modify me

After the function runs

'''

a_stand_alone_function = my_tiny_new_decorator(a_stand_alone_function)

@my_tiny_new_decorator

def another_stand_alone_function():

    print "Leave me alone"

another_stand_alone_function()

"""outputs:

Before the function runs

Leave me alone

After the function runs

"""

#! /usr/bin/env python

def bread(func):

	def wrapper():

		print '</""""\>'

		func()

		print '<\____/>'

	return wrapper

def ingredients(func):

	def wrapper():

		print '#tomatoes#'

		func()

		print '~salad~'

	return wrapper

def sandwich(food = '--ham--'):

	print food

sandwich()

#outputs: --ham--

sandwich = bread(ingredients(sandwich))

sandwich()

'''outputs:

</"""\>

#tomatoes#

--ham--

~salad~

<\___/>

'''

@bread

@ingredients

def sandwich_2(food="--ham_2--"):

    print food

sandwich_2()

@ingredients

@bread

def strange_sandwich(food="--ham--"):

    print food

strange_sandwich()

"""outputs:

#tomatoes#

</''''''\>

 --ham--

<\______/>

 ~salad~

"""

#! /usr/bin/env python

def a_decorator_passing_arguments(function_to_decorate):

	def a_wrapper_accepting_arguments(arg1, arg2):

		print 'I got args! Look:', arg1, arg2

		function_to_decorate(arg1, arg2)

	return a_wrapper_accepting_arguments

'''

Since when you are calling the function returned by the decorator,

you are calling the wrapper, so passing arguments to the wra  will

let it pass them to the decorated function

'''

@a_decorator_passing_arguments

def print_full_name(first_name, last_name):

	print 'My name is ', first_name, last_name

print_full_name('Peter', 'Venkman')

'''outputs:

I got args! Look: Peter Venkman

My name is Peter Venkman

'''

'''

Since when you are calling the function returned by the decorator,

you are calling the wrapper, so passing arguments to the wra  will

let it pass them to the decorated function

'''

def print_full_name(first_name, last_name):

	print 'My name is ', first_name, last_name

print_full_name = a_decorator_passing_arguments(print_full_name)

print_full_name('Peter', 'Venkman')

'''outputs:

I got args! Look: Peter Venkman

My name is Peter Venkman

'''

#! /usr/bin/env python

def method_friendly_decorator(method_to_decorate):

	def wrapper(self, lie):

		return method_to_decorate(self,lie)

	return wrapper

class Lucy(object):

	def __init__(self):

		self.age = 32

	@method_friendly_decorator

	def sayYourAge(self, lie):

		print 'I am %s, what do you think?' % (self.age + lie)

person = Lucy()

person.sayYourAge(-3)

#outputs: I am 29, what did you think?

#! /usr/bin/env python

def a_decorator_passing_arbitrary_arguments(function_to_decorate):

	#The wrapper accepts any arguments

	def a_wrapper_accepting_arbitrary_arguments(*args, **kwargs):

		print 'Do I have args?:'

		print args

		print kwargs

		#Then you unpack the arguments, here *args, **kwargs

		function_to_decorate(*args, **kwargs)

	return a_wrapper_accepting_arbitrary_arguments

# For debugging, the stacktrace prints you the function __name__

def foo():

    print "foo"

print foo.__name__

# outputs: foo

def bar(func):

    def wrapper():

        print "bar"

        return func()

    return wrapper

@bar

def foo():

    print "foo"

print foo.__name__

# outputs: wrapper

#! /usr/bin/env python

import functools

def bar(func):

	@functools.wraps(func)

	def wrapper():

		print 'bar'

		return func()

	return wrapper

@bar

def  foo():

	print 'foo'

print foo.__name__

# outputs: foo