python学习-函数式编程
函数式编程
简介
函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数
Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。
高阶函数
Higher-order function 高阶函数
变量可以指向函数
# 直接打印abs, 指向函数名
print(abs(-10))
print(abs) # <built-in function abs>
# 尝试将函数名赋值给变量-> 函数本身也可以赋值给变量，即：变量可以指向函数。
a = abs
# print(a) # a()=abs() <built-in function abs>
# 通过变量调用函数
print(a(-20))
# 函数名也是变量: abs()这个函数，完全可以把函数名abs看成变量，它指向一个可以计算绝对值的函数！
# 将abs指向其他对象, 则不具备求绝对值的能力
abs=[1,2,3]
print(abs(-1)) # TypeError: 'list' object is not callable-> 现在abs不指向绝对值函数, 指向list
# 指向仅在本文件有效: 恢复abs函数，请重启Python交互环境;
# abs实际上是定义在import builtins模块中, 要覆盖abs的定义: import builtins; builtins.abs = [1,2,3]
传入函数
# 既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数
def add(x, y, f):
return f(x) + f(y)
map/reduce
li = [1,2,3,4,5];
def f1(x):
return x ** 2
# map(f1,li) 返回Iterator是惰性计算, 使用list()函数计算打印
print(type(map(f1,li)),list(map(f1,li))) # <class 'map'> [1, 4, 9, 16, 25]
# reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
from functools import reduce
def fn(x, y):
return x + y;
print(reduce(fn,[1,3,5,7,9]))
def fn(x, y):
return x * 10 + y
def char2num(s):
digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
return digits[s]
print(reduce(fn, map(char2num, '13579')))
# 整合
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))
# 使用lamda表达式简化
def char2num(s):
return DIGITS[s]
def str2int(s):
return reduce(lambda x, y: x * 10 + y, map(char2num, s))
print(str2int('123456'))
练习
# 利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']
def normalize(name):
pass
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)
# Python提供的sum()函数可以接受一个list并求和，请编写一个prod()函数，可以接受一个list并利用reduce()求积：
def prod(L):
pass
print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))
if prod([3, 5, 7, 9]) == 945:
print('测试成功!')
else:
print('测试失败!')
# 利用map和reduce编写一个str2float函数，把字符串'123.456'转换成浮点数123.456
def str2float(s):
a = list(map(int,[x for x in s if x != '.']))
b = reduce(lambda x,y:10*x+y,a)
for n in range(len(s)):
if s[n] == '.':
break
n+=1
k = len(s)-n-1
c = b/(10**k)
return c
print('str2float(\'123.456\') =', str2float('123.456'))
if abs(str2float('123.456') - 123.456) < 0.00001:
print('测试成功!')
else:
print('测试失败!')
filter()函数
def is_odd(n):
return n % 2 == 1
print(list(filter(is_odd,[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,78])))
def not_empty(s):
return s and s.strip()
print(list(filter(not_empty,['A', '', 'B', None, 'C', ' '])))
- filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。
# 素数: 埃氏筛法
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) # 构造新序列
# 打印1000以内的素数:
for n in primes():
if n < 1000:
print(n)
else:
break
练习
# 回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用filter()筛选出回数：
def is_palindrome(n):
pass
# 测试:
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()函数
print(sorted([36, 5, -12, 9, -21]))
# sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：
print(sorted([36, 5, -12, 9, -21], key=abs))
# 字符串排序
print(sorted(['bob', 'about', 'Zoo', 'Credit']))
print(sorted(['bob', 'about', 'Zoo', 'Credit'],key=str.lower))
# 反向排序，不必改动key函数，可以传入第三个参数reverse=True
print(sorted(['bob', 'about', 'Zoo', 'Credit'],key=str.lower,reverse=True))
练习
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
# 按名字排序
def by_name(t):
#这个是list里有一个tuple
#每次传进去一个tuple
return t[0].lower() #t[0]:取出姓名，按开头字母排序（不用取出姓名的第一个字母）
print(sorted(L,key=by_name))
# 按分数排序(从高到低)
def by_score(t):
return -t[1]
print(sorted(L,key=by_score))
返回函数
python高级函数 除了可以接受函数作为参数外，还可以把函数作为结果值返回
def calc_sum(*args):
ax = 0
for n in args:
ax = ax + n
return ax
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
调用lazy_sum()时，返回的并不是求和结果，而是求和函数
print(lazy_sum(1,2,3,4,5)) # <function lazy_sum.<locals>.sum at 0x0000029714F105E0>
print(lazy_sum(1,2,3,4,5)()) # 15
f = lazy_sum(1,2,3,4,5) # f=sum()得到的是函数
print(f()) # 调用sum函数
闭包
f1 = lazy_sum(1, 3, 5, 7, 9)
f2 = lazy_sum(1, 3, 5, 7, 9)
print(f1 == f2) # false
返回的函数在其定义内部引用了局部变量args，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
f1, f2, f3 = count()
print(f1()) # 9
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()
print(f1(),f2(),f3())
注意点: 闭包对外层变量的访问, 没有问题; 赋值会报错(类似与java对lambda表达式外部赋值)
def inc():
x = 0
def fn():
# nonlocal x: 访问可以, 赋值报错
# x = x + 1
return x
return fn
f = inc()
print(f()) # 1
print(f()) # 2
利用闭包返回一个计数器函数，每次调用它返回递增整数：
def createCounter():
i = 0;
def counter():
nonlocal i;
i = i + 1;
return i;
return counter
# 测试:
counterA = createCounter()
print(counterA(), counterA(), counterA(), counterA(), counterA()) # 1 2 3 4 5
counterB = createCounter()
if [counterB(), counterB(), counterB(), counterB()] == [1, 2, 3, 4]:
print('测试通过!')
else:
print('测试失败!')
# list可以回避这个问题，修改list中的值，并未改变list的指向。
def createCounter():
list = [0];
def counter():
list[0] = list[0] + 1
return list[0];
return counter
匿名函数
#在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。
li = list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(li)
# 匿名函数lambda x: x * x实际上就是：
def f(x):
return x * x
定义
关键字lambda表示匿名函数，冒号前面的x表示函数参数
限制
只能有一个表达式，不用写return，返回值就是该表达式的结果。
用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：
anoy = lambda k : k + 10
print(anoy) # <function <lambda> at 0x000002D3206A0700>
print(anoy(100)) # 110
# 可以把匿名函数作为返回值返回
def build(x, y):
return lambda: x * x + y * y
L = list(filter(lambda n : n % 2 == 1, range(1, 20)))
装饰器
# 函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。
from datetime import date
def now():
print(date.today())
f = now
f() # 2022-02-12
print(f.__name__) # now
print(now.__name__) # now
def log(func):
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
@log # now = log(now)
def now():
print(date.today())
now() # call now(): 2022-02-12
decorator本身需要传入参数
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') # now = log('execute')(now)
def now():
print(date.today())
now() # execute now(): 2022-02-12
import functools
def log(func):
@functools.wraps(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
作业:
# 设计一个decorator，它可作用于任何函数上，并打印该函数的执行时间：
import time, functools
def metric(fn):
@functools.wraps(fn)
def wrapper(*args, **kw):
start = time.time()
result = fn(*args, **kw)
end = time.time()
exe_time = 1000 * (end - start)
print('%s executed in %s ms' % (fn.__name__, exe_time))
return result
return wrapper
# 测试
@metric
def fast(x, y):
time.sleep(0.0012)
return x + y;
@metric
def slow(x, y, z):
time.sleep(0.1234)
return x * y * z;
f = fast(11, 22)
s = slow(11, 22, 33)
if f != 33:
print('测试失败!')
elif s != 7986:
print('测试失败!')
编写一个decorator，能在函数调用的前后打印出’begin call’和’end call’的日志。
写出一个@log的decorator，使它既支持：@log 又支持@log(“excecute”)
偏函数
import functools
int2 = functools.partial(int, base=2)
print(int2('1000000')) # 64
