Python笔记（2）函数

python中一切皆对象，函数也看做对象。函数被函数名所引用，但是同样的他也可以被其他标识符所引用，可以作为参数传递。

def f():
    return "hi"

可见a引用了函数返回值，b引用了函数本身，a不可调用，b可调用。而函数作为参数，即引用函数本身，下面的装饰器就是以函数作为参数，引用的函数本身，而不是返回值。

常用的几个内建函数Map，Reduce，Filter，lamda。

Filter

筛选出满足过滤条件的元素

s = "@431$%$314&6i7(431)^&^%2l#%^i6861642k765e&$%65%^$^#$p%^&*%66757y%*^&%th%*&^%&^$o$&*^n4637"
print filter(str.isalpha,s)

Map

　　接收两个参数，第一个是函数，第二个是list，返回结果

l = [random.randint(0,100) for i in range(10)]

def sub50(a):
    return a-50

print map(sub50,l)

Reduce

和map一样接收两个参数，但是他返回一个结果，会迭代第二个参数list，不停的计算。

# 1+2+3+...+99
def f_add(a,b):
    return a+b
print reduce(f_add,range(1,100))

　　python3中Reduce被从全局命名空间中移除，要想使用需要--from functools import reduce，在函数式中reduce所表达的概念称为规约fold。

这里的map reduce和大数据中的map reduce不是一回事。

Lambda

lambda就是一个匿名函数，在需要一个函数，但是不用费力起名字的时候用lambda.

map(lambda x:x*x, [x for x in range(10)])
##等价于
def pf(x):
    return x * x

map(pf, [x for x in range(10)])

map,filter,reduce并没有列表解析容易理解，3里面返回的是一个iterator而不再是一个list。

回调 CallBack 也即函数作为参数，运行到callback()返回上一层

闭包closure

绑定外部变量的函数

闭包和装饰器 都是函数作为返回值

def pow_x(x):
    def echo(value):
        return value**x
    return echo

lst = [pow_x(2),pow_x(3),pow_x(4)]
for p in lst:
    print "closure",p(2)

1.嵌套函数

2.内部函数用了外部变量

3.外部函数返回了内部函数

如果外部变量是list，是可以改变的。但是只是一个变量，是无法改变的。

函数内部要注意LEGB原则，有局部变量的时候，就不再调用外部变量。

装饰器decorator

装饰就是在原有函数的基础上，加一些其他的功能，他是函数作为返回值，函数作为参数的一种应用。

多层嵌套就是用了闭包，被修饰函数作为绑定量。

两层嵌套结构

目标函数可以带参数

def time_cost(f):
    def _f(*arg, **kwarg):
        start = time.clock()
        a=f(*arg,**kwarg)
        end = time.clock()
        print f.__name__,"run cost time is ",end-start
        return a
    return _f

@time_cost
def list_comp(length):
    return [(x,y) for x in range(length) for y in range(length) if x*y > 25]

if __name__ == '__main__':
    list_comp(1000)

　　

三层嵌套结构

不仅目标函数可以带参数，装饰器也可以带参数

递归

递归就是1）函数自己调用自己2）有明确的出口。常用于Fibonacci数列，树图的遍历等数据或是结构上定义为递归的情况。递归和循环是等价的。

递归的次数过多，会造成栈溢出，并且Python并不支持尾递归优化。

#字符串取反
def reverse_str(s):
    if len(s) <= 1:
        return s
    else:
        return reverse_str(s[1:]) + s[0]