Python学习笔记:Python函数式编程
学自廖雪峰巨佬的Python3教程:https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014317848428125ae6aa24068b4c50a7e71501ab275d52000
1.我们通过把大段代码拆成函数,通过一层一层的函数调用,就可以把复杂任务分解成简单的任务,这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。而函数式编程就是一种抽象程度很高的编程范式,纯粹的函数式编程语言编写的函数没有变量,因此,任意一个函数,只要输入是确定的,输出就是确定的,这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言,由于函数内部的变量状态不确定,同样的输入,可能得到不同的输出,因此,这种函数是有副作用的。
2.高阶函数
- map()和reduce()
map()接收两个参数,一个是函数,一个是Iterable对象,map将传入的函数依次作用到Iterable对象里的每个元素,并把结果作为新的Iterator返回
>>> def f(x):
... return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
由于结果r是一个Iterator,因此需要通过list()函数将整个序列都计算出来并返回一个list()
reduce()把一个函数作用在一个一个序列上,这个函数必须接收两个参数,reduce把结果和序列的下一个元素做累积计算
>>> from functools import reduce
>>> def add(x, y):
... return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25
还可以通过reduce函数写出一个str2int的函数
from functools import reduce
DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def str2int(s):
def fn(x, y):
return x * 10 + y
def char2num(s):
return DIGITS[s]
return reduce(fn, map(char2num, s))
代码如下:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
def normalize(name):
return str.upper(str.lower(name)[:1]) + str.lower(name)[1:len(str.lower(name))]
# 测试:
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)
代码如下:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from functools import reduce
def prod(L):
def fn(x, y):
return x * y
return reduce(fn, L)
# 测试
print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))
if prod([3, 5, 7, 9]) == 945:
print('测试成功!')
else:
print('测试失败!')
代码如下:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from functools import reduce
def str2float(s):
def char2num(s):
digit = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
return digit[s]
def fn(x, y):
return x * 10 + y
s1 = s[:s.index('.')]
s2 = s[s.index('.') + 1:]
return reduce(fn, map(char2num, s1)) + reduce(fn, map(char2num, s2)) / pow(10, len(s2))
# 测试
print('str2float(\'123.456\') =', str2float('123.456'))
if abs(str2float('123.456') - 123.456) < 0.00001:
print('测试成功!')
else:
print('测试失败!')
- filter
filter()也接收一个函数和一个序列。和map
不同的是,filter()把传入的函数依次作用于每个元素,然后根据返回值是True
还是False
决定保留还是丢弃该元素。
比如只保留序列里的奇数
def is_odd(n):
return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]
用filter求素数,使用筛法
首先构造一个从3开始的奇数序列,这是一个生成器,并且是一个无限序列:
def _odd_iter():
n = 1
while True:
n = n + 2
yield n
然后定义一个筛选函数,这里使用了lambda表达式,构建了一个闭包:
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) # 构造新序列
调用primes()生成器,并且设置退出循环的条件:
# 打印1000以内的素数:
for n in primes():
if n < 1000:
print(n)
else:
break
代码如下:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
def is_palindrome(n):
count = 0
i = 0
if 0 < n < 9:
return True
else:
while i < len(str(n)) // 2:
if str(n)[i] == str(n)[len(str(n)) - 1 - i]:
count += 1
i += 1
return count == len(str(n)) // 2
# 测试:
output = filter(is_palindrome, range(1, 1000))
print('1~1000:', list(output))
if list(filter(is_palindrome, range(1, 200))) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101,
111, 121, 131, 141, 151, 161, 171, 181, 191]:
print('测试成功!')
else:
print('测试失败!')
- sorted
Python内置的sorted()函数用于对list进行排序,默认顺序从小到大,还可以接收一个key函数来实现自定义的排序,例如按绝对值大小排序:
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]
key指定的函数将作用于list的每一个元素上,并根据key函数返回的结果进行排序
对字符串排序则是按照ASCII的大小比较的,如果要实现反向排序,则可以传入第三个参数reverse=True
代码如下:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_name(t):
return t[0]
L2 = sorted(L, key=by_name)
print(L2)
def by_score(t):
return -t[1]
L2 = sorted(L, key=by_score)
print(L2)
3.返回函数
- 函数作为返回值
高阶函数除了可以接受函数作为参数外,还可以把函数作为结果值返回。
实现一个可变参数的求和很简单,但是,如果不需要立刻求和,而是在后面的代码中,根据需要再计算呢?答案就是可以不反悔求和的结果,而是返回求和的函数:
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
当调用lazy_sum()的时候,返回的并不是求和结果,而是求和函数,调用函数f的时候,才真正计算求和的结果:
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>
>>> f()
25
在这个例子中,我们在函数lazy_sum中又定义了函数sum,并且,内部函数可以引用外部函数lazy_sum的参数和局部变量,当lazy_sum返回函数sum时,相关参数和变量都保存在返回的函数中,这种程序结构称为闭包。
再注意一点,每次调用lazy_sum()时,都会返回一个新的函数,即使传入相同的参数:
>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False
f1()和f2()的调用结果互不影响
- 闭包(我可以吐槽一下这个东西真的很毒吗)
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
f1, f2, f3 = count()
在上面的例子中,每次循环,都创建了一个新的函数,然后,把创建的3个函数都返回了。你可能认为调用f1(),f2(),f3()结果应该是1,4,9,但实际结果是:
>>> f1()
9
>>> f2()
9
>>> f3()
9
全部都是9!原因就在于返回的函数引用了变量i,但它并非立刻执行,等到3个函数都返回时,它们所引用的变量i已经变成了3,因此最终结果为9
返回闭包时牢记一点:返回函数不要引用循环变量,或者后续会发生变化的变量。
代码如下:(这里引用大佬代码= =因为我闭包学的还不够好呜呜)
方法1:使用list在函数内部引用其地址,并改变其值
def createCounter():
a = [0]
def counter():
a[0] += 1
return a[0]
return counter
执行分析:
调用createCounter,实例化counterA对象,给a赋初值[0],给counterA的返回值是counter()函数;
print语句内调用counterA,开始执行函数counter(),a[0]+=1->a[0]=1,返回a[0]的值给counter(),然后再返回给counterA(),
循环5次这个过程。
方法2:利用生成器,完成数值加1
def createCounter():
def counter():
n = 1
while True:
yield n
n += 1
c = counter()
def g():
return next(c)
return g
执行分析:
调用createCounter,实例化counterA对象,内部调用counter()并实例化c对象,返回值为函数g;
print语句内调用CounterA,获取返回值为函数g,调用函数g,获取返回值为next(c),调用函数counter(),生成器返回值1,n+=1,循环5次这个过程。
理解容易实现难啊!
4.匿名函数
当传入函数时,有些时候,不需要显式的定义函数,直接传入匿名函数更方便。
以map()函数为例,计算f(x)=x^2,关键字lambda表示匿名函数,冒号前的x表示函数参数
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]
匿名函数有个限制,就是只能有一个表达式,不用写return。此外,匿名函数也是一个函数对象,也可以把匿名函数赋值给一个变量,再利用变量来调用该函数。
代码如下:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# def is_odd(n):
# return n % 2 == 1
# L = list(filter(is_odd, range(1, 20)))
L = list(filter(lambda x: x % 2 != 0, range(1, 20)))
print(L)
5.装饰器
由于函数也是一个对象,而且函数对象可以被复制给变量,所以通过变量也能调用该函数。
函数对象有一个__name__属性,可以拿到函数的名字:
>>> def now():
... print('2015-3-25')
...
>>> f = now
>>> f()
2015-3-25
>>> now.__name__
'now'
>>> f.__name__
'now'
假设我们要增强now()函数的功能,比如在函数调用前后自动打印日志,但又不希望修改now()函数的定义,这种在代码运行期间动态增加功能的方式,称之为装饰器(Decorator)
本质上,decorator就是一个返回函数的高阶函数,所以定义一个打印日志的装饰器如下:
def log(func):
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
然后将修饰器置于函数的定义前
@log
def now():
print('2015-3-25')
相当于执行了语句
now = log(now)
调用now()函数时,相当于现在指向了新的函数,即在log()函数中返回的wrapper()函数,wrapper()函数的参数定义是(*args,**kw),因此,wrapper()函数可以接受任意参数的调用,在wrapper函数内,首先打印日志,再紧接着在return处调用原始函数。
如果修饰器本身需要传入参数,那就需要编写一个返回修饰器的高阶函数。比如要自定义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('execute')
def now():
print('2015-3-25')
>>> now()
execute now():
2015-3-25
>>>print(now.__name__)
wrapper
首先执行now函数的时候,就会先执行log('execute'),传入参数为text='execute',返回的是decorator函数,再调用返回的decorator函数,返回的是wrapper函数,再调用返回的wrapper函数,打印传入的text和函数名,然后调用now函数本身,输出日期。
但是看经过decorator装饰之后的函数,它的__name__已经从原来的now变成了wrapper,因为返回的那个wrapper()函数名字就是wrapper,所以需要把原始函数的__name__等属性复制到wrapper()函数中,否则有些依赖函数签名的代码执行就会出错。Python内置的functools.wraps就是干这个的,所以一个完整的decorator写法如下
import functools
def log(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
带参数的
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
def metric(fn):
@functools.wraps(fn)
def wrapper(*args, **kw):
t1 = time.time()
fx = fn(*args, **kw)
t2 = time.time()
print('%s executed in %s ms' % (fn.__name__, t2 - t1))
return fx
return wrapper
代码如下:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
def begin_call(func):
def wrapper(*args, **kw):
print("begin")
x = func(*args, **kw)
print("end")
return wrapper
def log(func):
def wrapper(*args,**kw):
print("xxxxxxxxxx")
return func(*args,**kw)
return wrapper
def log(text):
def decorator(func):
def wrapper(*args, **kw):
print(text)
return func(*args, **kw)
return wrapper
return decorator
@log('love')
def one_plus(x):
print(x + 1)
one_plus(1)
6.偏函数
Python的偏函数和数学意义上的不一样,在介绍函数参数的时候,通过设定参数的默认值,可以降低函数调用的难度,而偏函数也可以做到这一点。
假设要转换大量的二进制字符串,每次都传入Int(x,base=2)非常麻烦,因此可以定义一个int2()的函数,默认把base=2传进去:
def int2(x, base=2):
return int(x, base)
而使用functools.partial就是帮助我们创建偏函数的,不需要自己定义int2(),可以直接使用下面的代码创建一个新的函数int2:
>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85
创建出来的偏函数也是可以传入其他值的