函数式编程:

特点:允许传递的参数是函数,且允许返回一个函数。

由于Python允许使用变量,因此,Python不是纯函数式编程语言,同样的输入可能输出不同,有副作用。纯函数式编程语言没有变量,输入和输出是确定的,无副作用。

1.高阶函数(Higher-order function):

特点:高阶函数可以接受另一个函数作为参数,还可以把函数作为结果值返回。

变量可以指向函数,函数名也是变量, 所以可以作为参数传入函数。

  1.1 内置的函数:函数作为参数

1%.

2%.

# 将迭代器经函数的处理返回一个新的迭代器,是一种映射。
  list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
   # 返回 ['1', '2', '3', '4', '5', '6', '7', '8', '9'] 

   #累计计算:把序列[1, 3, 5, 7, 9]变换成整数13579
   from functools import reduce
   def fn(x, y):
       return x * 10 + y
  reduce(fn, [1, 3, 5, 7, 9])
   # 13579  
 
   # map()和reduce()合用:str’13579‘ 转化为int:13579
   def char2num(s):
       return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
   reduce(fn, map(char2num, '13579'))
# 整理为一个函数str2int,这些函数因为就一句也可以用匿名函数写
   from functools import reduce

   def str2int(s):
       def fn(x, y):
           return x * 10 + y
       def char2num(s):
           return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
       return reduce(fn, map(char2num, s))

            # 实现筛选功能

3%. filter(function, iterable)   【返回值是True则保留】

# 迭代的值
def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n

def _not_divisible(n):
    return lambda x: x % n > 0

# 定义一个生成器,不断返回下一个素数
def primes():
    yield 2
    it = _odd_iter() # 初始序列
    while True:
       n = next(it) # 返回序列的第一个数
       yield n
       it = filter(_not_divisible(n), it) # 构造新序列


# 打印30以内的素数:
for n in primes():
  if n < 30:
      print(n)
  else:
      break

# 找到回数
def is_palindrome(n):
    start = 0
    end = -1
    while start < len(str(n))/2:
        if str(n)[start] != str(n)[end]:
            return False
        else:
            start += 1
            end -= 1
    return True
output = filter(is_palindrome, range(100, 200))
print(output)

           # 排序

4%.

# 按照绝对值排序,key传入函数
sorted([36, 5, -12, 9, -21], key=abs)
# [5, 9, -12, -21, 36]

# 忽略大小写反向排序
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['about', 'bob', 'Credit', 'Zoo']

2 返回函数

  闭包:在函数内嵌套另一个函数,嵌套函数可以引用外部函数的参数和局部变量。而相关的参数和变量保存在返回函数。

# 结果都一样
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

#一个函数可以返回一个计算结果,也可以返回一个函数。
#返回一个函数时,牢记该函数并未执行,返回函数中不要引用任何可能会变化的变量。


# 结果1,2,3
def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行,因此i的当前值被传入f()
    return fs
f1, f2, f3 = count()
f1()
# 2次结果的不同

 3 匿名函数 (lambda 传入: 返回)

特点:

  无名匿名函数,不必担心函数名冲突

应用场景:
  1. 函数很小,一句话的事情
  2. 使用函数变量调用函数时, 如在触发事件需要传入参数的时候

# 1把匿名函数赋值给一个变量,再利用变量来调用该函数:
 f = lambda x: x * x

# 2把匿名函数作为返回值返回,比如:
def build(x, y):
    return lambda: x * x + y * y

4  装饰器

  向一个现有的对象添加新的功能,同时又不改变其结构

  使用场景:

  • 参数检查(Agrument checking)
  • 缓存(Caching)
  • 代理(Proxy)
  • 提供上下文(Context Provider)

import functools

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

@log('execute')
def now():
    print('2015-3-25')

now()
# 等价于
now = log('execute')(now)

5 偏函数

当函数的参数个数太多,需要简化时

  使用functools.partial可以创建一个新的函数,这个新函数可以固定住原函数的部分默认参数。

  通过设定参数的默认值,可以降低函数调用的难度

# 把一个函数的某些参数给固定住(也就是设置默认值)
# 进行二进制的转换
def int2(x, base=2):
    return int(x, base)

print('1000000 =', int2('1000000'))
print('1010101 =', int2('1010101'))

# 等价为
import functools
int2 = functools.partial(int, base=2)

print('1000000 =', int2('1000000'))
print('1010101 =', int2('1010101'))