基础

匿名函数的关键字为 lambda

1
lambda argument1, argument2,... argumentN : expression
1
2
3
4
square = lambda x: x ** 2

print(type(square)) # <class 'function'>
print(square(5)) # 25
  1. lambda 是一个表达式(expression),而非一个语句(statement
    • 表达式 - 用一系列公式去表达
    • 语句 - 完成某些功能
  2. lambda 可以用在列表内部,而常规函数 def 不能
  3. lambda 可以用作函数参数,而常规函数 def 不能
  4. 常规函数 def 必须通过其函数名被调用,因此必须首先被定义
    • lambda 是一个表达式,返回的函数对象不需要名字,即匿名函数
  5. lambda 的主体只有一行简单表达式,并不能扩展成多行的代码块
    • lambda 专注于简单任务,而常规函数 def 负责更复杂的多行逻辑
1
2
y = [(lambda x: x * x)(x) for x in range(10)]
print(y) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
1
2
3
4
l = [(1, 20), (3, 0), (9, 10), (2, -1)]

l.sort(key=lambda x: x[1]) # sort by second element
print(l) # [(2, -1), (3, 0), (9, 10), (1, 20)]

lambda - 简化代码复杂度,提高代码可读性

1
2
3
squared = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
for e in squared:
print(e) # 1 4 9 16 25

函数式编程

  1. 函数式编程,即代码中的每一块都是不可变的(immutable),都由纯函数(pure function)的形式组成
  2. 纯函数 - 函数本身相互独立互不影响,对于相同的输入,总会得到相同的输出,并且没有任何副作用
  3. 优点 - 纯函数不可变性使得程序更加健壮,并且更加易于调试和测试
  4. 缺点 - 限制多 + 难写
  5. Python 并非一门函数式编程语言,而 Scala 是,Python 仅提供一些函数式编程的特性

map

map(function, iterable) - 对 iterable 中的每个元素,都应用 function 函数,最后返回一个可遍历的集合

1
2
3
4
5
6
7
8
9
l = [1, 2, 3, 4, 5]
l = map(lambda x: x * 2, l)
print(type(l)) # <class 'map'>
print(list(l)) # [2, 4, 6, 8, 10]

s = (1, 2, 3, 4, 5)
s = map(lambda x: x * 2, s)
print(type(s)) # <class 'map'>
print(tuple(s)) # (2, 4, 6, 8, 10)

map / for / list comprehension
map() 最快,因为直接由 C 语言编写,运行时不需要通过 Python 解释器间接调用,并且内部做了诸多优化

1
2
3
4
5
6
7
8
$ python3 -m timeit -s 'xs=range(1000000)' 'map(lambda x: x*2, xs)'
5000000 loops, best of 5: 77.3 nsec per loop

$ python3 -m timeit -s 'xs=range(1000000)' '[x * 2 for x in xs]'
10 loops, best of 5: 30.7 msec per loop

$ python3 -m timeit -s 'xs=range(1000000)' 'l = []' 'for i in xs: l.append(i * 2)'
5 loops, best of 5: 42 msec per loop

filter

filter(function, iterable) - 对 iterable 中的每个元素,都使用 function 判断,并返回 True 或者 False
将返回 True 的元素组成一个新的可遍历集合

1
2
3
4
l = [1, 2, 3, 4, 5]
l = filter(lambda x: x % 2 == 0, l)
print(type(l)) # <class 'filter'>
print(list(l)) # [2, 4]

reduce

reduce(function, iterable) - 对集合进行一些累积操作
对 iterable 中的每个元素以及上一次调用后的结果,应用 function 进行计算,最后返回一个单独的数值

1
2
3
4
5
6
from functools import reduce

l = [1, 2, 3, 4, 5]
sum = reduce(lambda x, y: x + y, l)
print(type(sum)) # <class 'int'>
print(sum) # 15