Python学习笔记（五）

函数式编程

# 函数式编程

# 高阶函数--把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。
def xx(a):
	return a*a

def func (a,b,c):      
	return c(a)+c(b)

print(func(-10,-12,xx))	

# map()--函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为iterators(迭代器)返回
I = map(str,[1,2,3,4])

for x in I:
	print(x)

I = map(abs,[-1,-2,-3,-4])
L = list(I)
print(L)

# filter()--filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
def is_even(n):
    return n % 2 == 0

lf = filter(is_even, [x for x in range(1,100)])
lf = list(lf)
print(lf);


# sorted 函数
k = sorted(['a', 'b', 'c', 'd', 'e'])
print(k)


# 返回一个函数
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

f = lazy_sum(1, 3, 5, 7, 9)
f1 = lazy_sum(1, 3, 5, 7, 9,10)

print(f,'\n',f(),'\n',f1())


# 通过cout返回三个函数(以list形式返回,函数平没有执行),因为i在变，函数的结果为调用时当前i值。
# 如下函数f1(),f2(),f3()在调用时i值都已为3
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())
print(f2())
print(f3())


# 通过创建一个函数，用该函数的参数绑定变量当前的值，变量的改变，对已返回函数的值没有影响
def count():
	fs = []
	for i in range(1, 4):
		def f(j):
			def g():
				return j*j
			return g		
		fs.append(f(i))

	return fs

x = ()
x = count()
print(x[0])
print(x[1])
print(x[2])
f1,f2,f3 = count()
print(f1())
print(f2())
print(f3())

# 匿名函数--lambda

def is_radices(x):	
	return x%2 == 1

# is_radices与 lambda x: x%2 == 1 意义相同

la = filter(is_radices, [x for x in range(1,10)])
int1 = 0
for v in la:
	int1 = int1 + v
print(int1)

la1 = filter(lambda x: x%2 == 1, [x for x in range(1,10)])
int2 = 0
for v in la1:
	int2 = int2 + v
print(int2)

# 装饰器--decorator(本质上也是一个函数)

def hello(name):
	print('hello',name)

hi = hello
hello('老李')
hi('老张')

# 调用函数对象的__name__属性(显示函数名称)
print(hello.__name__)
print(hi.__name__)

# 定义decorator接受函数，返回函数(任意个参数)
import functools		# 导入functools模块

def wlog(func):					#定义没有参数的decorator
	@functools.wraps(func)		#若缺少,函数的name属性将改变为wrlog(最终的返回函数)
	def wrlog(*args, **kw):
		print ('write %s()start:' % func.__name__)
		call = func(*args, **kw)
		print ('write %s()end:' % func.__name__)
		return call
	return wrlog

def rlog(text):					#定义有参数的decorator
	def decorator(func):		#若缺少,函数的name属性将改变为rlog(最终的返回函数)
		@functools.wraps(func)
		def relog(*args, **kw):
			print ('%s %s():' % (text, func.__name__))
			return func(*args, **kw)
		return relog
	return decorator

# 将decorator作用于函数
@wlog 						# 调用没有参数的decorator
def say(name):
	print('say',name)

say('小小')
print(say.__name__)

@rlog('success')			# 调用有参数的decorator
def talk(name):
	print('talk',name)

talk('大大')
print(talk.__name__)

# 偏函数(固定函数的部分参数，使函数生成新的函数)
import functools

def Square(x,n):
	i,sum = (0,0)
	while i <= x:
		j = 1
		temp = 1
		while j <= n:
			temp = temp*i
			j = j + 1			
		sum = sum + temp
		i = i + 1
	return sum

Square1 = functools.partial(Square, n=3)

print(Square1(3))