python函数与方法装饰器

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

a_stand_alone_function_decorated

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

functools.wraps

functools

functools.wraps()

# 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

为什么装饰器那么有用