函数式编程

函数式编程(python)

一：高阶函数

1：变量可以指向函数

abs(-10) -->10
x = abs(-10) --> x = 10
y = abs  --> <built-in function abs>   #变量本身可以指向函数
z = abs  z(-10) --> 10

2：函数名也是变量

abs = 10  abs(-10) --> 报错
注：由于abs函数实际上是定义在import builtins模块中的，所以要让修改abs变量的指向在其它模块也生效，要用import builtins; builtins.abs = 10。

3：传入函数

如果一个函数能够接受另一个函数作为参数，那个这个函数就称为高阶函数
eg:
	def add(x,y,f):
		return f(x)+f(y)
	x = -5
	y = -2
	f = abs  # 注意：不能写为 f = abs()
	print(add(x,y,f))  --> 7
上述：add函数能够接受abs函数作为参数，因此将add函数称为高阶函数

4：map/reduce

4.1:iterable & iterator

iterable 用来判断是否可以迭代
iterator 用来判断是否是迭代器
凡是可以for循环的 都是Iterable
凡是可以next()的，都是Iterator
集合数据类型：list、tuple、dict、set 都是Iterable 不是 Iterator，但可以通过iter()获得一个Iterator对象
for循环的本质就是通过next()来获取下一个对象
	list1 = [1,3,2,4]
	for it in list1:
		pass
	上述for循环等价于以下代码
	it = iter(list1)
	while True:
		try:
			x = next(it)
		except StopIteration:
			break

4.2：map函数

map(f(s),Iterable)函数接受两个参数、第一个参数为一个函数，一个是Iterable 
map将传入的函数依次作用的序列的每个元素，并将结果作为新的Iterator返回
eg:
def f(x):
	return x*x
list1 = [1,2,3,4,5]
r = map(f,list1)  # r 是一个Iterator
print(list(r)) --> [1,4,9,16,25]
list(map(str,[1,2,3])) -->['1','2','3']

4.3:reduce函数

python3默认不会加载reduce函数，需要进行导入：from functools import reduce
reduce(f(x),Iterable) 要执行的函数必须接收两个参数，这两个参数进行运算，并将运算的结果再次和第三个元素进行运算，依次类推！

4.4： filter函数

filter 会让列表中的每一元素都执行一次函数，并将执行函数返回为真或不为None的结果
eg:
def test(s):
if s % 2 ==0:
    return s
list3 = [4,23,6,7,8]
n = filter(test,list3)
print(list(n)) -->[4, 6, 8]

4.5:sorted排序函数

1：默认从小到大排序
	eg1:
	list4 = [3,5,-2,8,6,-4]
	print(sorted(list4)) --> [-4,-2,3,5,8,6]
	list5 = ['zhangsan','Lisi','wangwu']
	print(sorted(list5)) -->['Lisi', 'wangwu', 'zhangsan']  # 对字符串排序遵从ASCii码顺序
2：可用key函数来实现自定义排序
	list4 = [3,5,-2,8,6,-4]
	print(sorted(list4,key=abs)) --> [-2,3,-4,5,8,6]
	list5 = ['zhangsan','Lisi','wangwu']
	print(sorted(list5,key=str.lower)) -->['Lisi', 'wangwu', 'zhangsan']反向排序
3:可用reverse=True 进行反向排序
	list4 = [3,5,-2,8,6,-4]ur
	print(sorted(list4,key=abs,reverse=True --> [8, 6, 5, -4, 3, -2]
	list5 = ['zhangsan','Lisi','wangwu']
	print(sorted(list5,key=str.lower)) -->['zhangsan', 'wangwu', 'Lisi']

二：返回函数

2.1 函数作为返回值

1:通常的求和函数
	def wg_add(*args):
		sum = 0
	    for i in args:
	        sum = sum +i
	    return sum
	print(wg_add(1,3,5,6)) --> 15
2:若不需要立即求和，要在后面的代码中根据需要计算可进行如下改写
	def wg_add1(*args):
	    def sum1():
	        sum = 0
	        for i in args:
	            sum = sum+i
	        return sum
	    return  sum1  # return sum1()
	f = wg_add1(1,2,3)
	# 当我们调用 wg_add1函数时，返回的并不是求和结果，而是求和函数,当我们调用f时，才正真返回求和结果
	print(f) --><function wg_add1.<locals>.sum1 at 0x0000000002B1B840>
	print(f())  -->6

2.2：闭包

闭包是指：
1：当一个内函数使用了外函数的临时变量
2：外函数的返回值是内函数的引用

eg1:

	def outer(y):
    	x = 10
    	def inner():
	        # x = 2      # 当直接修改x的值是实际上是重新定义了一个x对象、并未实质修改其外函数的临时变量的值
	        nonlocal x  # 若此处需要修改临时变量x 的值，需要在此处申明nonlocal关键字
	        x=2
	        return x+y # 内函数使用了外函数的临时变量
    	return inner(),x  # 外函数的返回值是内函数的引用
	print(outer(20))  --> (22, 2)
eg2:
	def wg_coun():
	    wg1 = []
	    for i in range(1,4):
	        def wg_f():
	            return i*i
	        wg1.append(wg_f)
	    return wg1
	w1,w2,w3 = wg_coun() # 并非立即执行
		# 每次循环都创建了一个函数，将创建的3个函数都返回
		#当调用w1()是才会执行，此时，应用的变量i变为了3，所以最终结果为9
	print(w1(),w2(),w3())  -->9,9,9 

三：匿名函数

函数语法： lambda arg1,arg2:expression

print(list(map(lambda x:x*3,[1,2,3,4]))) --> [3, 6, 9, 12]

3.1 无参匿名函数

t = lambda :True
print(t())  --> True

3.2 带参匿名函数

t = lambda x,y:x+y
print(t(1,3)) --> 4

3.3 匿名函数调用

t = lambda x,y:x+y
# 用t(arg1,arg2)进行匿名函数调用
print(t(1,3)) --> 4

3.4 嵌套使用

# lambda嵌套到普通函数中,lambda函数本身做为return的值
def wg2(n):
return lambda x:x+n
print(wg2(3)(4)) --> 7

四：装饰器

python 装饰器是用来拓展原来函数功能的一种函数，这种函数的特殊之处是它的返回值也是一种函数、使用python装饰器的好处是在不用更改原函数代码的前提下给函数增加新功能

1：一般而言，我们要拓展原函数，最直接的方式就是侵入到原函数代码里面进行修改