#5 lambda, 高阶函数,闭包, decorator

一.first-citizen

python中的函数和js中的函数都是first-citizen,它们是对象，拥有自己的属性，比如

__name__: 函数名，这个和js中函数的'name'属性一致

def someFun:
  pass

print(someFun.__name__)  
someFun

可以作为参数传入函数中：

def mySum(a, b, f):
  return f(a) + f(b)

mySum(10, -100, abs)  
110

可以作为返回值(即高阶函数)

def add(a, b):
  def sum():
    return a + b
  return sum

f = add(7, 8)    
f()
15

可以看出 闭包 的概念，这一点和js中的闭包保持一致

二.lambda表达式

这个匿名函数的简写方式，几乎所有编程语言中都有，就是写法不一样，python中的lambda表达式：

lambda x: x * x

# 相当于
def someFun(x):
  return x * x

python中返回一个匿名函数，在js中比较常见的一种模式

def build(x, y):
  return lambda: x * x + y * y
# 调用时
build(3, 4)()

# 或者是匿名函数带有参数
def build():
  return lambda x, y: x * x + y * y
# 调用时
build()(3, 4)

更多lambda表达式会在下面的高阶函数中出现

三.函数式编程

函数式编程这种概念最近比较流行，高度的对事物进行抽象，是一种声明式的编程风格，与之相对的就是命令式的编程风格。

说到函数式编程，就不得不提这几个函数了： map, reduce, filter, sorted，这几个函数和js中的函数有一些差别

map

参数：

函数
Iterable 对象

返回值：

Iterator 对象，惰性序列

比如想将list '[1, 2, 3, 4]'中的每个元素都平方，可以这样写：

>>> def f(x):
...  return x * x

>>> m = map(f, [1, 2, 3, 4])
>>> m
 # 返回一个Iterator对象

# 使用 list() 函数将整个序列计算出来并返回一个list
>>> list(m)
[1, 4, 9, 16]

使用lambda表达式，上面的例子可以写为：

m = map(lambda x: x * x, [1, 2, 3, 4])

将字符串数字转换为整型:

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]

L = map(char2num, '12345')
[1, 2, 3, 4, 5]

使用map()函数将不规范的英文名变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']：

# 不使用map的做法：
>>> names = ['adam', 'LISA', 'barT']
>>> [name.title() for name in names]

# 使用map()
>>> def normalize(names):
...   def captilize(name):
...     return name.title()
...   return list(map(captilize, names))

reduce

概念和js中的reduce概念类似，将多个数变为一个数

值得注意的是，python中并不内置reduce函数，需要从 functools 模块中引入

from functools import reduce

下面代码默认引入该模块

例如将[1, 3, 5, 7, 9] 变为 '13579' 这样一个数：

reduce(lambda x, y: x * 10 + y, [1, 3, 5, 7, 9])

filter

这个函数和js中的filter还是很相似的

比如除去list中的空字符串和None:

>>> list(filter(lambda s: s and s.strip(), ['1', ' ', '', None, 'abc']))
['1', 'abc']

sorted

这个函数有3个参数，后面两个参数可选：

集合类型
key=someFunc: key 关键词，后面添加一个排序函数
reverse=False: 是否反向排序，默认为False

示例：

# 忽略大小写，进行升序排列
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']

# 按照降序排列
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']

对于复杂的数据类型，比如说list里面的元素为tuple：

>>> L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

# 按照姓名排序(其实默认排序即可)
def by_name(t):
  return t[:][0].lower() # t[:]表示复制整个tuple元素 t[:][0] 则表示名字

sorted(L, key=by_name)
[('Adam', 92), ('Bart', 66), ('Bob', 75), ('Lisa', 88)]


# 按照分数排序
def by_score(t):
  return t[:][1]

sorted(L, key=by_score)  
[('Bart', 66), ('Bob', 75), ('Lisa', 88), ('Adam', 92)]

四.闭包

python中也存在闭包，闭包的注意事项和js中也差不多，比如：

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

# 执行count(), 生成一个list, list中包含3个函数
f1, f2, f3 = count()

>>> f1()
9
>>> f2()
9
>>> f3()
9

结果都是9，而不是1， 4， 9，这是因为闭包的原因, i并没有立即计算，而是最终i=3的情况。避免这种情况在js中会使用立即执行函数或者arrow function，在python中，可以使用lambda函数来避免这种问题：

def count():
  fs = []
  def g(i):
    return lambda: i * i # 返回一个匿名函数
  for j in range(1, 4):
    fs.append(g(j))
  return fs

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

>>> f1()
1
>>> f2()
4
>>> f3()
9

或者在创建一个函数，用该函数的参数绑定循环变量的值，无论循环变量后续怎么变换，已绑定到函数参数的值不变：

def count():
  def f(j):
    def g():
      return j * j
    return g
  fs = []
  for i in range(1, 4):
    fs.append(f(i)) # 相当于立即执行函数
  return fs

五.装饰器decorator

decorator本质上就是一个高阶函数，在js中原本decorator已经提案，后来又停止支持

比如一个log的decorator:

def log(func):
  def wrapper(*args, **kw): # 任何函数都可以通过这种方式表达出来
    print('call %s():' % func.__name__)
    return func(*args, **kw)
  return wrapper  

# 使用时
@log
def now():
  print('2017-03-06')

>>> now()
call now():
2017-03-06  

# 实质上等价于
>>> log(now)()

如果需要给log添加一些参数，则可以多返回一层函数即可：

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

@log('excute')
def now():
  print('2017-03-06')

>>> now()
execute now():
2017-03-06  

# 相当于
log('excute')(now)()

但是这样有一个问题

>>> now.__name__
'wrapper'

因为经过2层返回之后，函数的'name' 属性由now变为了'wrapper', 可以使用 functools.wraps 来解决这个问题

import functools
def log(func):
  @functools.wraps(func) # 将func先包裹起来
  def wrapper(*args, **kw):
    print('call %s()' % func.__name__)
    return func(*args, **kw)
  return wrapper  

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

在面向对象(OOP)的设计模式中, decorator也称为装饰模式。OOP装饰模式需要通过继承和组合来实现.Python的 decorator既可以用函数来实现，也可以用类来实现

六.偏函数

也称为部分函数 partial，这个功能由 functools 模块提供。本质上就是将函数的某些参数固定，这样写的时候就不用将固定部分的参数带入

比如 int() 函数，可以将数字字符串转换为整型，默认是将字符串当作十进制的，实际上我们可以自定义进制

>>> int('123')
123

# 把'FF' 当作16进制
>>> int('FF', 16)
255

可以使用部分函数:

import functools
>>> int2 = functools.partial(int, base=2)

# 调用时
# 默认将 '1000000' 当作2进制进行转换
>>> int2('1000000')
64

本质上是固定了命名关键字参数base

总结

本章学习的内容较多，不过熟悉js语法的，学习起来相对简单，一些小的区别值得注意

python中函数也是一级公民，也就是可以当作变量来使用，函数有一个属性 ** __name__ **
map(), reduce(), filter(), sorted()的使用方法，他们返回的都是Iterator对象，是一种惰性序列，使用时要注意
python中的匿名函数，lambda表达式 的写法
闭包应当注意的事项
functools 模块的学习，本章中 reduce, partial, wraps 都来自该模块
decorator 的声明，本质上就是高阶函数

2017年3月6日 18:25:25