函数式编程
What is 函数式编程
本质上来说函数名也是一个变量,所以函数可以作为参数插入另外一个函数
也可以作为另外一个函数的返回值(闭包).
好处
用每一个函数完成细小的功能,然后一系列函数任意组合之后完成更大的功能.
函数的可重入性
当一个函数在运行时,不读取或改变除局部作用域以外的其他变量的时候,此函数为可重入函数.可重入函数有一个特性,如果每一次的参数一样,则其结果也是一样的
#可重入函数示例
def myadd(x,y):
return x + y
#不可重入额函数示例
y = 300
def myadd2(x):
return x + y
print(myadd2(10)) #310
y = 400
print(myadd2(10))#410
高阶函数
满足两个条件之一的就是高阶函数:
1> 以函数作为参数
2> 返回值是一个函数
map 函数(映射)
原型
iterable = map(function,iterable1,iterable2)
作用
将后面的可迭代对象作为参数带入前面的函数中,生成一个新的可迭代对象.
必须满足的条件
后面的可迭代对象必须和前面的参数的个数保持一致,并且映射结束的条件是,如果有一个可迭代对象结束,整个函数就结束.
# 求 1**2 + 2**2 + 3**2 + ...+ 9**2的和
# (用函数式和高阶函数map实现)
#求x的平方
def mypow(x):
return x ** 2
s = 0
#生成可迭代对象it,里面存放的就是各项的平方
it = map(mypow,range(1,10))
for x in it:
s += x
print("和是:",s)
# 以上代码可以简化为一行
print("和是:",sum(map(mypow,range(1,10))))
#2. 求 1**3 + 2**3 + 3**3 + ...+ 9**3的和
# 可以使用匿名函数代替mypow
s2 = 0
it2 = map(lambda x:x ** 2,range(1,10))
#可以使用sum(iterable) 一个可迭代对象的求和公式
s2 = sum(it2)
print("和是:",s2)
#1**9 + 2**8 + 3**7 + .... + 9**1的和,一行代码实现.匿名函数以及range()从大到小迭代.
s3 = sum(map(lambda x,y:x ** y,range(1,9),range(9,0,-1)))
print("和是:",s3)
filter (过滤)
原型
iterable = filter(function,itreable)
作用
将一个可迭代对象带入function,进行过滤,如果function的返回值为真就保留,如果为假就丢弃掉.
然后将保留的可迭代对象返回.
写一个过滤器求出100~200之间的所有的素数的和
def isPrime(n):
if n < 2:
return False
for x in range(2,n):
if n % x == 0:
return False
return True
s = sum(filter(isPrime,range(100,201)))
print("和是: ",s)
reduce
原型
ret = reduce(function,iterable,[initializer])
作用
也接收两个参数,最后那个参数是可选的,指定初始值.这个函数一开始会将可迭代对象的前面两个数带入函数求一个结果,然后这个结果和可迭代对象依次进行累计,得到一个结果.
注意
function必须是两个参数,python3中不再是内置模块,而是放到了functools模块中要通过from functools import reduce导入
例如,编写一个函数,接收x和y,返回x和y的和:
def func(x,y):
return x + y
调用reduce(f,[1,3,5,7,9])时,reduce函数将做如下计算.
先计算头两个元素：f(1, 3)，结果为4；
再把结果和第3个元素计算：f(4, 5)，结果为9；
再把结果和第4个元素计算：f(9, 7)，结果为16；
再把结果和第5个元素计算：f(16, 9)，结果为25；
由于没有更多的元素了，计算结束，返回结果25。
reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：
reduce(f, [1, 3, 5, 7, 9], 100)
结果将变为125，因为第一轮计算是：
计算初始值和第一个元素：f(100, 1)，结果为101。
sorted函数
原型
list = sorted(iterable,key=None,reverse=False)
功能
传入一个可迭代对象,按照key指定的某种元素作为参考,reverse规定是否反转对一个可迭代对象进行排序,返回一个排序之后的列表.key只接收一个参数,就是可迭代对象中的元素
实例
>>>sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5] # 默认为升序
>>>example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> result_list = sorted(example_list, key=lambda x: x*-1)
>>> print(result_list)
[7, 6, 5, 4, 3, 2, 1, 0]
>>>
>>>l=[('a', 1), ('b', 2), ('c', 6), ('d', 4), ('e', 3)]
>>>sorted(l, key=lambda x:x[0])
Out[39]: [('a', 1), ('b', 2), ('c', 6), ('d', 4), ('e', 3)]
>>>sorted(l, key=lambda x:x[0], reverse=True)
Out[40]: [('e', 3), ('d', 4), ('c', 6), ('b', 2), ('a', 1)]
>>>sorted(l, key=lambda x:x[1])
Out[41]: [('a', 1), ('b', 2), ('e', 3), ('d', 4), ('c', 6)]
>>>sorted(l, key=lambda x:x[1], reverse=True)
Out[42]: [('c', 6), ('d', 4), ('e', 3), ('b', 2), ('a', 1)]
sort()和sorted()函数的区别
*sort 与 sorted 区别：(sorted不改变原来的可迭代对象,sort是在原列表上进行操作)
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作.*
zip函数
原型
zip_objcet = zip([iterable,...])
功能
ip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，
可以将元组解压为列表。
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 返回一个对象
>>> zipped
>>> list(zipped) # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c)) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> a1, a2 = zip(*zip(a,b)) # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
>>>