函数是面向过程的程序设计的基本单元,函数式编程的思想更接近数学计算。
函数式编程就是一种抽象程度很高的编程范式,纯粹的函数式编程语言编写的函数没有变量,
因此,任意一个函数,只要输入是确定的,输出就是确定的,这种纯函数我们称之为没有
副作用。而允许使用变量的程序设计语言,由于函数内部的变量状态不确定,同样的输入,
可能得到不同的输出,因此,这种函数是有副作用的。
函数式编程最大的特点:允许把函数本身作为参数传入另一个函数,还允许返回一个函数。
1.高阶函数:
(1).变量可以指向函数:
>>>f = abs
>>>f
<built-in function abs>
>>>f = abs(-7)
>>>f
7
#如果一个变量指向一个函数,可以通过调用该变量来调用该函数,函数名就是指向函数的变量。
函数的参数可以接收变量,变量可以指向函数,那么一个函数就可以接收另一个函数
作为参数,这种函数就称为高阶函数。
def add(x, y, f):
return f(x) + f(y)
print(add(-5, 6, abs))
Output:11
(2).map()/reduce() (python内置):
(1).map():接收两个参数,一个是函数,一个是Iterable,map将传入的函数依次作用
到序列的每个元素,并把结果作为新的Iterator返回。
def f(x):
return x * x
list_t = [1, 2, 3, 4]
r = map(f, list_t)
print(list(r))
Output: [1, 4, 9, 16]
#将f(x)作用于list_t的每一个元素,将新的生成元素放在新的列表r中
>>>list(map(str, [1, 2, 3, 4, 5]))
['1', '2', '3', '4', '5'] #将每个元素转换为字符串\
(2).reduce():把一个函数作用在一个序列[x1, x2, x3, ...]上,
必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
#对一个序列求和
from functools import reduce
def add(x, y):
return x + y
sum_t = reduce(add, [1, 2, 3, 4])
print(sum_t)
Output:10
#把序列[1, 3, 5, 7, 9]变换成整数13579
from functools import reduce
def fn(x, y):
return x * 10 + y
sum_t = reduce(fn, [1, 3, 5, 7, 9])
print(sum_t)
Output:13579
#转换str为int
from functools import reduce
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]
sum_t = reduce(fn, map(char2num, '13579'))
print(sum_t)
Output:13579
#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))
#使用lambda函数(匿名函数)进一步简化
#lambda语句中,冒号前是参数,可以有多个,用逗号隔开,冒号右边是返回值
#匿名函数也是一个函数对象,可以赋值给变量,再通过变量调用
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 char2num(s):
return DIGITS[s]
def str2int(s):
return reduce(lambda x, y: x * 10 + y, map(char2num, s))
(3). filter():过滤序列,接收一个函数和序列,将函数依次作用于序列的每个元素,然后根据
返回值是True还是False决定是否保留该元素。该函数返回的是一个Iterator,即惰性序列,
需要使用 list()函数获得所有结果并返回list。
#删除list中的所有奇数
list_t = [1, 2, 3, 4, 5, 6]
def is_odd(n):
return n % 2 == 0
list_t = list(filter(is_odd, list_t))
print(list_t)
Output:[2, 4, 6]
#删除序列中的空字符串
def not_empty(s):
return s and s.strip()
#strip()函数删除序列的头尾的指定字符,默认是空格
#strip([chars]),char为指定的字符
list_t = list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
print(list_t)
Output:['A', 'B', 'C']
#使用filter求素数
算法:埃式筛法
首先,列出从2开始的所有自然数,构造一个序列:
2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取序列的第一个数2,它一定是素数,然后用2把序列的2的倍数筛掉:
3, 5, 7, 9, 11, 13, 15, 17, 19, ...
取新序列的第一个数3,它一定是素数,然后用3把序列的3的倍数筛掉:
5, 7, 11, 13, 17, 19, ...
取新序列的第一个数5,然后用5把序列的5的倍数筛掉:
7, 11, 13, 17, 19, ...
不断筛下去,就可以得到所有的素数。
python的计算思路:
先定义从3开始的一个奇数序列,然后定义筛选函数,最后使用生成器不断返回下一个素数。
def _odd_iter():
'''定义一个生成器,返回一个无限奇数序列'''
n = 1
while True:
n += 2
yield n
def _not_divisible(n):
'''定义筛选函数,用于删除奇数序列的元素的倍数'''
return lambda x : x % n > 0
def primes():
'''定义一个生成器,不断返回下一个素数'''
yield 2 #先返回第一个素数2
it = _odd_iter()
while True:
n = next(it)
yield n
it = filter(_not_divisible(n), it)
#获取输入的数字,转换为int类型,以此为跳出范围
num = int(input("Enter a number: "))
for n in primes():
'''定义退出条件'''
if n < num:
print(n)
else:
break
#回数:从左往右读和从右往左读都是一样的。
#设计一个程序筛选出回数
def is_palindrome(n):
m = str(n)
for i in range(len(m)):
if m[i-1] != m[-i]:
return False
return True
#Test
output = list(filter(is_palindrome, range(1,1000)))
print('1~1000: \n', output)
Output:1~1000:
[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, 202, 212, 222, 232, 242, 252, 262, 272, 282,
292, 303, 313, 323, 333, 343, 353, 363, 373, 383, 393, 404, 414, 424, 434, 444,
454, 464, 474, 484, 494, 505, 515, 525, 535, 545, 555, 565, 575, 585, 595, 606,
616, 626, 636, 646, 656, 666, 676, 686, 696, 707, 717, 727, 737, 747, 757, 767,
777, 787, 797, 808, 818, 828, 838, 848, 858, 868, 878, 888, 898, 909, 919,
929, 939, 949, 959, 969, 979, 989, 999]
(4). sorted():排序,作为高阶函数,允许接收一个key函数来实现自定义的排序。
#按绝对值大小排序
>>>sorted([-1, -4, 2, 3], key = abs)
[-1, 2, 3, -4]
key指定的函数将作用于list的每一个元素上,并根据key函数返回的结果进行排序。
然后 sorted()函数按照keys进行排序,并按照对应关系返回list相应的元素。
#对字符串排序(默认按照ASCII的大小比较,'Z'<'a')
>>>sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']
#忽略大小写,按照字母排序(先都变大写或小写再比较)
>>> 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']
2.返回函数:在高阶函数中把函数作为结果值返回
#普通可变参数求和
def calc_sum(*args):
ax = 0
for n in args:
ax += n
return ax
#不需要立即求和,不返回求和结果,只返回求和函数
def lazy_sum(*args):
def sum_test():
ax = 0
for n in args:
ax += n
return ax
return sum_test
#调用lazy_sum()函数时,返回的不是求和结果,而是函数sum_test()
>>>f = lazy_sum(1, 2, 3, 4)
>>>f
<function lazy_sum.<locals>.sum_test at 0x000001E76A13E6A8>
#调用函数f()时,才真正计算求和结果
>>>f()
10
闭包:
上面的例子中,在函数 lazy_sum()内部又定义了函数 sum_test(),且内部函数
sum_test()可以引用外部函数 lazy_sum()的参数和局部变量。当 lazy_sum()返回
函数 sum_test()时,相关参数和变量都保存在返回的函数中。这种程序结构称为
“闭包(Closure)”
需要注意,当调用 lazy_sum()时,每次都会返回一个新的函数,即使传入的参数相同:
>>> f = lazy_sum(1, 2, 3, 4)
>>> f1 = lazy_sum(1, 2, 3, 4)
>>> f == f1
False
返回的函数在其定义内部引用了局部变量args,所以,当一个函数返回了一个函数后,
其内部的局部变量还被新函数引用.另一个需要注意的问题是,返回的函数并没有立刻执行,
而是直到调用了 f()才执行。
#python中的循环结束以后,循环体中的临时变量i不会销毁,而是继续存在于执行环境中。
#并且python的函数只有在执行时,才会去找函数体里的变量的值。
def count():
fs = []
for i in range(1, 4):
def f():
return i * i
fs.append(f)
return fs
f1, f2, f3 = count()
>>> f1()
9
>>> f2()
9
>>> f3()
9
#当把函数加入fs列表里时,python还没有给i赋值,只有当执行时才去找。
#当for循环结束后,i的值为3,所以才会有上面的输出结果
返回的函数引用了变量i,但它并非立刻执行。等到3个函数都返回时,
它们所引用的变量i已经变成了3,因此最终结果为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()
>>> f1()
1
>>> f2()
4
>>> f3()
9
3.装饰器:decorator(本质上是返回函数的高阶函数),在代码运行期间动态增加功能
def now():
print('2018-5-22')
#在程序运行前打印日志
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('2018-5-22')
now()
Output: call now():
2018-5-22
'''
由于log()是一个decorator,返回一个函数,所以,原来的now()函数仍然存在,只是现在
同名的now变量指向了新的函数,于是调用now()将执行新函数,即在log()函数中返回的
wrapper()函数。rapper()函数的参数定义是(*args, **kw),因此,wrapper()函数可以
接受任意参数的调用。在wrapper()函数内,首先打印日志,再紧接着调用原始函数。
'''
如果decorator本身需要传入参数,那就需要编写一个返回decorator的高阶函数
#自定义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
这个3层嵌套的decorator用法如下:
@log('execute') #相当于执行了now = log('execute')(now)
def now():
print('2018-5-22')
Output:
>>> now()
execute now():
20188-5-22
首先执行 log('execute'),返回的是decorator函数,再调用返回的函数,参数是now函数,
返回值最终是 wrapper()函数。
函数也是对象,它有__name__等属性,但经过decorator装饰之后的函数,__name__已经从
原来的'now'变成了'wrapper':
>>> now.__name__
'wrapper'
因为返回的那个 wrapper()函数名字就是'wrapper',所以,需要把原始函数的 __name__
等属性复制到 wrapper()函数中,否则,有些依赖函数签名的代码执行就会出错。
不需要编写wrapper.__name__ = func.__name__这样的代码,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
针对带参数的decorator:
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
4.偏函数:当函数的参数个数太多,需要简化时,使用functools.partial可以创建一个新
的函数,这个新函数可以固定住原函数的部分参数,从而在调用时更简单。
int()函数可以把字符串转换为整数,当仅传入字符串时,int()函数默认按十进制转换:
>>> int('12345')
12345
#利用base参数实现N进制转换
>>> int('123', base = 8)
83
>>> int('123', 16)
291
#假设要转换大量的二进制字符串,每次都传入int(x, base=2)非常麻烦,
#可以定义一个int2()的函数,默认把base=2传进去
def int2(x, base = 2):
return int(x, base)
>>> int2('1000000')
64
>>> int2('1010101')
85
#借助functools.partial可以不用自己定义 int2()
#functools.partial的作用就是,把一个函数的某些参数给固定住(也就是设置默认值),
#返回一个新的函数,调用这个新函数会更简单。
import functools
int2 = functools.partial(int, base = 2)
>>> int2('1000000')
64
>>> int2('1010101')
85
'''
创建偏函数时,实际上可以接收函数对象、*args和**kw这3个参数,当传入:
int2 = functools.partial(int, base=2)
实际上固定了 int()函数的关键字参数base,也就是:
int2('10010')相当于:
kw = { 'base': 2 }
int('10010', **kw)
当传入:max2 = functools.partial(max, 10)
实际上会把10作为*args的一部分自动加到左边,也就是:
max2(5, 6, 7)相当于:
args = (10, 5, 6, 7)
max(*args)
'''
python-Functional Programiming基础知识
最新推荐文章于 2023-11-28 10:39:28 发布