python学习笔记2

高阶函数

通俗的来讲，python的高阶函数的形参变量可以接受函数，类似于c语言的函数指针

例如：

# 变量f可以传入一个函数
def add(a,b,f):
    return f(a)+f(b)

add(-5,5,abs)
#输出结果是10

python内置的高阶函数

map()

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

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

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

reduce()

reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值

def prod(x, y):
    return x*y

print reduce(prod, [2, 4,5])#输出：40
print reduce(prod, [2, 4,5],10)#输出 400，先计算[..],在把10传入

filter()函数

filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

import math

def is_sqr(x):
    return math.sqrt(x)%1==0 

print filter(is_sqr, range(1,101))
# 输出：
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

sorted()函数

但 sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

def cmp_ignore_case(s1, s2):
    if s1.lower() < s2.lower():
        return -1
    elif s1.lower() > s2.lower():
        return 1
    else:
        return 0

print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)
# 输出：
# ['about', 'bob', 'Credit', 'Zoo']

返回函数

Python的函数不但可以返回int、str、list、dict等数据类型，还可以返回函数

函数calc_prod(lst)，它接收一个list，返回一个函数，返回函数可以计算参数的乘积

def calc_prod(lst):
    def prod(x,y):
        return x*y
    def lazy_prod():
        return reduce(prod,lst)
    return lazy_prod

f = calc_prod([1, 2, 3, 4])
print f()
# 输出：24

闭包

内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。

# -*- coding: utf-8 -*-
def count():
    fs = []
    for i in range(1, 4):
        print '函数赋值给变量时执行'
        def f():
            print '接受函数的变量执行时调用'
            return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()
print f1()
print f2()
print f3()

输出：

函数赋值给变量时执行
函数赋值给变量时执行
函数赋值给变量时执行
接受函数的变量执行时调用
9
接受函数的变量执行时调用
9
接受函数的变量执行时调用
9

匿名函数

关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。

# 返回字符串，首字母大写，其他字母小写
>>> map(lambda s:s[:1].upper()+s[1:].lower(),['barT','lISA','maggie'])
['Bart', 'Lisa', 'Maggie']

# 返回列表大于0的数值
# lambda x: True if x>0 else False解释：
# 传入x，x>0返回True否则返回False
>>> print filter(lambda x: True if x>0 else False,[-1,1,-2,2,-3,3] )
[1, 2, 3]

python的装饰器

如果定义了一个函数，想要在运行时候动态增加功能，又不想改动函数本身代码

>>> def f_old(x):
...     return x*x
...
>>> def f_new(f):
...     def fn(x):
...         print 'fn()...'
...         return f(x)
...     return fn
...
# 第一种调用方法
>>> g = f_new(f_old)
>>> g(3)
fn()...
9
# 第二种调用方法，完全隐藏了f_old()函数
>>> f_old=f_new(f_old)
>>> f_old(3)
fn()...
9
# 第三种
>>> @f_new
... def f2(x):
...     return 2*x
...
>>> f2(3)
fn()...
6

不带参数的decorater

打印函数调用时间

import time

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

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

print factorial(10)
# 输出：
# call factorial() in 0.000696s
# 3628800

带参数的decorater

请给 @performace 增加一个参数，允许传入’s’或’ms’：

import time

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

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

print factorial(10)
# 输出：
# call factorial() in 0.005046 s
# 3628800

偏函数

简化函数的参数默认值
例子中sorted函数的参数有两个(list,cmp),第一个是列表，第二个是重写的比较函数

import functools

sorted_ignore_case = functools.partial(sorted,cmp=lambda a,b:cmp(a.upper(),b.upper()))

print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])
# 输出：
# ['about', 'bob', 'Credit', 'Zoo']