python学习——基础（五）

函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，所以，任意一个函数，只要输入是肯定的，输出就是肯定的，这种纯函数咱们称之为没有反作用。而容许使用变量的程序设计语言，因为函数内部的变量状态不肯定，一样的输入，可能获得不一样的输出，所以，这种函数是有反作用的。

函数式编程的一个特色就是，容许把函数自己做为参数传入另外一个函数，还容许返回一个函数！

Python对函数式编程提供部分支持。因为Python容许使用变量，所以，Python不是纯函数式编程语言。

map函数：对list的每一个元素做用于传入的函数中

def fc(x):
    return x*x

print map(fc, [1, 2, 3, 4, 5, 6, 7, 8, 9])# 将list的每一个元素在fc中调用；参数：函数、list

结果：
[1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce函数：对list的前两个元素迭代的做用于传入的函数

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

List = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print reduce(prod,List)# 相似于1,2先传入prod,2*3传入，6*4传入...

结果：
362880

filter函数：和map()相似，filter()也接收一个函数和一个序列。和map()不一样的时，filter()把传入的函数依次做用于每一个元素，而后根据返回值是True仍是False决定保留仍是丢弃该元素

def is_odd(n):
    return n % 2 == 1

filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])
# 结果: [1, 5, 9, 15]

把一个序列中的空字符串删掉：

def not_empty(s):
    return s and s.strip()# “s字符串” 与 “s字符串首尾删除空格后的字符串”的交集

filter(not_empty, ['A', '', 'B', None, 'C', '  '])
# 结果: ['A', 'B', 'C']

filter() 删除1~100的奇数：

L = range(1,101)
print L

def dealMethond(x):
    return x%2 == 0

print filter(dealMethond, L) # 对L中的元素进行过滤

sorted对元素进行排序：

def reverse(s1, s2):
    if s1 < s2:
        return 1
    elif s1 == s2:
        return 0
    else :
        return -1

List = ['a', 1, 'd', 'b','120']
print sorted(List, reverse) # 能够自定义排序规则

结果：['d', 'b', 'a', '120', 1]

注： 一般是函数参数在前，可是sorted的函数参数是可选的，放在第二个调用比较方便，不然你必须传入

sorted(None, list)

返回函数：

高阶函数除了能够接受函数做为参数外，还能够把函数做为结果值返回

def count():
    fs = []
    for i in range(1, 4):
        def square(i):
            def func():
                return i*i
            return func
        fs.append(square(i))
    return fs

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

func函数做为返回值；即便传入的参数一致，返回的函数也是不相同的；

匿名函数：

关键字lambda表示匿名函数，匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。用匿名函数有个好处，由于函数没有名字，没必要担忧函数名冲突。此外，匿名函数也是一个函数对象，也能够把匿名函数赋值给一个变量，再利用变量来调用该函数

能够把匿名函数做为返回值返回：

def count():
    fs = []
    for i in range(1, 4):
        def func(i):
            return lambda i = i: i*i
        fs.append(func(i))
    return fs

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

装饰器：

decorator就是一个返回函数的高阶函数

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print '%s():%s' % (func.__name__, args[0])
        return func(*args, **kw)
    return wrapper

@log
def f(name):
    return 'f now %s' % name

print f('syc')

结果：
f():syc
f now syc

当log带参数时：

def log(text=None):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print '%s():%s:%s' % (func.__name__, args[0], text)
            return func(*args, **kw)
        return wrapper
    return decorator

@log('execute')
def f(name):
    return 'f now %s' % name

print f('syc')

结果：
f():syc:execute
f now syc

偏函数：

使用functools.partial能够建立一个新的函数，这个新函数能够固定住原函数的部分参数，从而在调用时更简单。

int2 = functools.partial(int, base=8)

print int2('10001011')

结果：2097673