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

2. 格式：

3. def f(x):
       return x*x
   print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

4. map()函数不改变原有的 list，而是返回一个新的 list。

5. map() 不仅仅可以处理只包含数值的 list，事实上它可以处理包含任意类型的 list，只要传入的函数f可以处理这种数据类型。

p1,p2,p3存储的是地址，即"Bart","Adam","Lisa"的地址为别对应 [<__main__.Person object at 0x1e964450>, <__main__.Person object at 0x1e97e7d0>, <__main__.Person object at 0x1e97ea10>] 因此如果直接使用sorted(L1),那么则是对地址进行大小排序，所以对各项的name的输出的结果则是"Bart","Adam","Lisa"，乍看一眼会觉得代码并没有错，但是不知道结果为什么是错的，原因就在于排序的对象搞错了。 所以为了对名字大小进行排序，需要在sorted内添加内建的cmp函数，即sorted(L1,lambda x,y:cmp(x.name,y.name))

pass作用 1、空语句 2、保证格式完整 3、保证语义完整

带参数的log函数首先返回一个decorator函数，再让这个decorator函数接收my_func并返回新函数

def format_name(s):

    return s[0].upper()+s[1:].lower()

print map(format_name, ['adam', 'LISA', 'barT'])

return s[0].upper()+s[1:].lower()返回首字母s[0]大写, 剩下的字母s[1:]小写

从这里可以看出字符串可以按照list来处理

functools.partial就是帮助我们创建一个偏函数的，把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值， 新函数名 = functools.partial(函数名, 指定少的参数的默认值)比如：int2 = functools.partial(int, base=2)

对于decorator的使用的总结：

1. 作用：decorator，就跟它的名称一样：修饰，包装。简单说就是给原来的函数添加一些新功能。这种可以是批量级的处理，能减少我们的工作量。

2. 无参数的decorator：在里面封装一个函数即可；

   如def performance(): 内部定义一个，一个，一个函数就可以了

3. 有参数的decorator()：在里面封装两个函数！！

4. import time  

5. 
   

6. def performance(unit): #用来接收装饰函数的参数 unit

7.     def performance_decorator(f): #接收需要装饰的函数 f

8.         def wrapper(*args, **kw): #接收实际函数所需要的参数 (*args, **kw)

9.             t1 = time.time()  

10.             f(*args, **kw) #运行实际的函数 f

11. decorator返回的新函数函数名已经不是'f2'，而是@log内部定义的'wrapper'。这对于那些依赖函数名的代码就会失效

12. 要让调用者看不出一个函数经过了@decorator的“改造”，就需要把原函数的一些属性复制到新函数中  Python内置的functools可以用来自动化完成这个“复制”的任务 3. >>> import functools import functools def log(f):    @functools.wraps(f)              

13. #这行代码本身也是一个装饰器，它表示了将原函数原始参数信息复制到wrapper中去    def wrapper(*args, **kw):        print 'call...'        return f(*args, **kw)    return wrapper
    

14. 
    

带参数的decorator需要三层嵌套，是因为： 最里一层，必然是一个参数列表为(*args,**kw)的wrapper，执行自身逻辑与运行目标函数，返回的是目标函数的执行结果； 倒数第二层，必然是一个参数列表为(f)的函数，用来接受目标函数，以供wrapper调用（闭包），并返回wrapper； 如果是无参数decorator，这时已经够了，python解释器会自动把@decorator转换成 f=decorator(f)； 但如果是有参数decorator，还需要最后一层，因为还有一个decorator自身的参数要传递以供内部闭包使用。因此，最外一层就是decorator，参数列表为decorator自身需要的参数列表，返回的其实还是内部的wrapper。（因为外两层只为传递参数，并没有自身逻辑实现）

关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。

使用匿名函数，可以不必定义函数名，直接创建一个函数对象。

 map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])

sorted(s,reverse = True)进行倒序（从大到小）

print (sorted(['bob', 'about', 'Zoo','Credit'], key=lambda x:x.lower()))

key就是进行比较的依据

lambda表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。

add = lambda x, y : x+y
add(1,2)  # 结果为3

filter等同于for & if，根据判断结果（函数返回的布尔数）自动过滤掉不符合条件的元素（False），返回由符合条件(True)元素组成的新list。

reduce()对list的每个元素反复调用函数f，并返回最终结果值。接收两个参数值，其中一个可以为上次的计算结果，因此可以合计和乘积

capitalize()将字符串的第一个字母变成大写,其他字母变小写。

return s[0].upper() + s[1:].lower()

Python3 中需要将map的结果放入list()

print (list(map(format_name, ['adam', 'LISA', 'barT'])))

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

所以，functools.partial可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值，这样，新函数调用的难度就降低了。

任务

在第7节中，我们在sorted这个高阶函数中传入自定义排序函数就可以实现忽略大小写排序。请用functools.partial把这个复杂调用变成一个简单的函数：

sorted_ignore_case(iterable)

• ?不会了怎么办

• 要固定sorted()的cmp参数，需要传入一个排序函数作为cmp的默认值。

  参考代码:

  import functools
  sorted_ignore_case = functools.partial(sorted, cmp=lambda s1, s2: cmp(s1.upper(), s2.upper()))
  print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])

python中编写无参数decorator

Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。

使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码。

考察一个@log的定义：

def log(f):     def fn(x):         print 'call ' + f.__name__ + '()...'         return f(x)     return fn

对于阶乘函数，@log工作得很好：

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

结果：

call factorial()... 3628800

但是，对于参数不是一个的函数，调用将报错：

@log def add(x, y):     return x + y print add(1, 2)

结果：

Traceback (most recent call last):   File "test.py", line 15, in <module>     print add(1,2) TypeError: fn() takes exactly 1 argument (2 given)

因为 add() 函数需要传入两个参数，但是 @log 写死了只含一个参数的返回函数。

要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用：

def log(f):     def fn(*args, **kw):         print 'call ' + f.__name__ + '()...'         return f(*args, **kw)     return fn

现在，对于任意函数，@log 都能正常工作。

任务

请编写一个@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)