import time, functools

def performance(unit):
    def fnn(f):
        @functools.wraps(f)
        def fn(*argv,**kw):
            print "call....",f.__name__,f.__doc__
            time1=time.time()
            result=f(*argv,**kw)
            time2=time.time()
            print time2-time1
            t=(time2-time1) if unit=="s" else (time2-time1)*1000
            print "call factorial...",t
            return result
        return fn
    return fnn

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial.__name__
factorial(10)

import time

def performance(unit):
    def fnn(f):
        def fn(*args,**kw):
            d1=time.time()
            print"call factorial()"
            result=f(*args,**kw)
            d2=time.time()
            if unit=="s":
                print ' %s()...' % ( f.__name__),d2-d1,'s'
            else:
                print ' %s()...' % ( f.__name__),(d2-d1)*1000,'ms'
            return result
        return fn
    return fnn
            
            
        
@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

print filter(lambda s: s and len(s.strip())>0,['test', None, '', 'str', '  ', 'END'])

..................................................无语，

我只是print filter(lambda x: x and len(x.strip())>0,['test', None, '', 'str', '  ', 'END'])然后一致提示运行成功输出错误。。。。。把x修改为s可以了。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。感觉到我的无语了吗

计算平方根可以用函数：

>>> math.sqrt(2)
1.4142...

abs   绝对值函数

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

变量 可以指向函数；函数名和普通的变量名没有什么区别，只是指向函数对象，可以接受函数作为参数的函数称为高阶函数

import math

def is_sqr(x):
    return int(str(math.sqrt(x)).split('.')[1])==0

print filter(is_sqr, range(1,101))

import math
def is_sqr(x):
    r = int(math.sqrt(x))
    return r*r==x
print filter(is_sqr, range(1, 101))

在Python中，函数其实是一个对象

一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()

__slots__是指一个类允许的属性列表

__slots__的目的是限制当前类所能拥有的属性，如果不需要添加任意动态的属性，使用__slots__也能节省内存

因为Python支持高阶函数，在函数式编程中我们介绍了装饰器函数，可以用装饰器函数把 get/set 方法“装饰”成属性调用

类型转换

int(12.34)

12

float(12)

12.0

要让函数正常工作，只需实现特殊方法

要表示有理数，可以用一个Rational类来表示

如果要让Rational进行+运算，需要正确实现__add__:

class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __add__(self, r):
        return Rational(self.p * r.q + self.q * r.p, self.q * r.q)
    def __str__(self):
        return '%s/%s' % (self.p, self.q)
    __repr__ = __str__

请思考带参数的@decorator，@functools.wraps应该放置在哪：

import time, functools
def performance(unit):
    def perf_decorator(f):
        @functools.wraps(f)
        def wrapper(*args, **kw):
            t1 = time.time()
            r = f(*args, **kw)
            t2 = time.time()
            t = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)
            print 'call %s() in %f %s' % (f.__name__, t, unit)
            return r
        return wrapper
    return perf_decorator

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial.__name__

上一节的@performance只能打印秒，请给 @performace 增加一个参数，允许传入's'或'ms'：

要实现带参数的@performance，就需要实现：

my_func = performance('ms')(my_func)

需要3层嵌套的decorator来实现。

import time
def performance(unit):
    def perf_decorator(f):
        def wrapper(*args, **kw):
            t1 = time.time()
            r = f(*args, **kw)
            t2 = time.time()
            t = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)
            print 'call %s() in %f %s' % (f.__name__, t, unit)
            return r
        return wrapper
    return perf_decorator

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

请编写一个@performance，它可以打印出函数调用的时间。

计算函数调用的时间可以记录调用前后的当前时间戳，然后计算两个时间戳的差。

import time
def performance(f):
    def fn(*args, **kw):
        t1 = time.time()
        r = f(*args, **kw)
        t2 = time.time()
        print 'call %s() in %fs' % (f.__name__, (t2 - t1))
        return r
    return fn

@performance
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)