[python全栈]02.python基础[part II](5)

目录

1. 函数式编程
2. map函数
3. filter与sorted函数
4. 递归函数
5. 闭包

1. 函数式编程

函数式编程是指用一系列函数决定问题
函数的功能完备 :
	1.函数本身可以赋值给变量,赋值后变量绑定函数
	2.允许将函数本身作为参数传入另一个函数
	3.允许返回一个函数
函数的可重入性:一个函数传入的参数一定,则结果必须一定
	要求: def定义的函数不要访问除局部变量以外的变量
eg :#不可重入函数
	y = 200
	def myadd(x)：
		return x+y	
	print(myadd(10))	#210
	y = 300
	print(myadd(10))	#310
	#可重入函数
	def myadd(x,y) :
		return x+y
	print(myadd(10,20))

2. map函数

高阶函数 High Order Function :
只要满足下列条件中的一个,函数即为高阶函数:
	1.函数接受一个或多个函数作为参数传入
	2.函数返回一个函数
python中内建(builtins)的高阶函数: map, filter, sorted

map函数:	map(func,*iterables) 
	作用: 用函数和可迭代对象中的每一个元素作为参数计算出新的可迭代对象，		
			当最短的一个可迭代对象不再提供数据时,此可迭代对象生成结束
	eg:
		def pow2(x) :
			return x**2
		for x in map(pow2,range(1,10)):
			print(x,end = ' ')
		#>>>1 4 9 16 25 36 49 64 81
	eg: #使用内建pow函数生成1*4, 2**3, 3**2, 4**1
	for x in map(pow,range(1,10),range(4,0,-1)):
		print(x,end = ' ')	#>>>1 8 9 4 
	eg:
		for x in map(pow,[2,3,5,7],[4,3,2,1].range(5,10)):
			print(x)
		#2**4%5; 3**3%6; 5**2%7; 7**1%8

#1. 求 1 ** 2 + 2 ** 2 + 3 ** 2 + ... + 9**2 的和
def pow2(x):
	return x**2
print(sum(map(pow2,range(1,10))))
#print(sum(map(lambda x : x**2,range(1,10))))	#>>>285
#2. 求 1**9 + 2**8 + 3**7 + ... + 9**1的和  # 11377
print(sum(map(lambda x,y : x**y,range(1,10),range(9,0,-1))))
print(sum(map(pow,range(1,10),range(9,0,-1))))

3. filter与sorted函数

filter 函数 :filter(func,iterable)
作用: 筛选可迭代对象iterable中的数据,返回一个可迭代对象
	此可迭代对象将对iterable进行筛选
说明: 函数 func 将对每个元素进行求值,返回False则将此数据丢弃
	返回True则保留此数据
eg:
	def isodd(x):	#判断一个函数是否为奇数
		return x%2 == 1
	for i in filter(isodd,range(10)):
		print(i)
	even = [x for x in 
					filter(lambda x : x%2==0,range(10))]	#返回偶数
	print(even)
eg:  
#1. 将 1 ~20 内的偶数用filter筛选出来，形成列表
#2. 用filter函数将2~100之间的所有素数(prime) 放入到列表中
L = [x for x in filter(lambda x : x%2==0,range(1,20))]
print(L)

def isprime(x) :
	if x <=1:
		return False
	for i in range(2,x):
		if x % i == 0 :
			return False
	return True
L = list(filter(isprime,range(100)))
print(L)
#>>>[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

sorted 函数 : 
作用: 将原可迭代对象的数据进行排序,生成排序后的列表
格式: sorted(iterable,key=None,reverse=False)
说明:	iterable 可迭代对象
		key 函数是用来提供一个参考值,这个值将作为排序的依据
		reverse 标志用来设置是否降序排序
eg :	
	L = [5, -2, -4, 0, 3, 1]
	L2 = sorted(L)		#>>> L2 = [-4, -2, 0, 1, 3, 5]
	L3 = sorted(L,key =abs )	#按照绝对值大小 L3 = [0, 1, -2, 3, -4, 5]
eg :
	name = ['Tom','Jerry','Spike','Tyke']
	sorted(name,key=len)	#按照姓名长度排
	#按照姓名反序排序: 'moT','yrreJ','ekipS','ekyT'
	def reve(name):
    	return name[::-1]
	name2 = sorted(name,key = reve)
	print(name2)	#>>>['Spike', 'Tyke', 'Tom', 'Jerry']
	#L2 = sorted(name,key = lambda n : n[::-1])

4. 递归函数

递归函数 recursion :
	函数直接或间接的调用自身
说明 :1.递归一定要控制递归的层数,当符合某一条件时要终止递归,
	2.几乎所有的递归都能用while循环来代替
递归的优缺点 :
	优点 :递归可以把问题简单化,让思路更为清晰,代码更简洁
	缺点: 递归因系统环境影响大,当递归深度太大,可能得到不可预知结果
递归函数的实现方法 :
	先假设函数已经实现
eg:#递归的实现
	def mysum(x):
		if x<=1:	#设置递归的终止点
			return 1
		return x + mysum(x-1)
	print(mysum(100))	
eg :#直接调用自身
	def f1():
		print('1')
		f1()
	f1()
	#间接调用自身
	def f1():
		print('f1')
		f2()
	def f2():
		print('f2')
		f1()
	#控制递归的层数 :
	def fx(n):
		print('递归进入第n层',n,'层')
		if n == 3:
			return
		fx(n+1)
		print('递归退出第',n,'层')
	fx(1)
	print('程序结束')
#递归进入第n层 1 层
#递归进入第n层 2 层
#递归进入第n层 3 层
#递归退出第 2 层
#递归退出第 1 层
#程序结束

练习 : 编写程序用递归阶乘 
def myfac(x):
	if x == 1 :
		return 1
	return x * myfac(x-1)
print(myfac(5))

5. 闭包

闭包 closure :
	将内嵌函数的语句和这些语句的执行环境打包在一起时
	得到的对象叫做闭包(closure)
闭包必须满足三个条件 :
	1.必须有一个内嵌函数
	2.内嵌函数必须引用外部函数中的变量
	3.外部函数返回值必须是内嵌函数
eg :#闭包的创建和调用
	def make_power(y) :
		def fx(arg):
			return arg ** y
		return fx
	pow2 = make_power(2)	#>>>pow2(arg) = arg**2
	print(pow2(3))		#>>>9
	pow3 = make_power(3)	#>>>pow3(arg) = arg**3
	print(pow3(3))		#>>>27

练习

#使用闭包生成二元一次函数族
def f1(a,b,c):
	def fx(x):
		return a*x**2+b*x+c
	return fx

# 编写函数求阶乘 myfac(x)

def myfac(x):
	if x == 1 :
		return 1
	return x * myfac(x-1)
print(myfac(10))

def myfac(n) :
	s = 1
	for i in range(1,n+1):
		s *= i
	return s
	
def myfac(n):
	i = 0
	s = 1
	while i < n :
		i+=1
		s*=i
	return s

#2. 写程序算出1~20的阶乘的和
1!+2!+3!+…+20!

def myfac(x):
	if x == 1 :
		return 1
	return x * myfac(x-1)
print( sum( map(myfac, range(1,21)) ) )	#>>>2561327494111820313

#3. 已知有列表:
L = [[3,5,8], 10, [[13, 14], 15, 18], 20]
1) 写一个函数print_list(lst) 打印出所有元素
print_list(L) # 打印 …
2) 写一个函数 sum_list(lst) 返回这个列表中所有元素的和
注:
type(x) 可以返回一个变量的类型
如:
type(20) is int # 返回True
type([1,2,3]) is list # 返回True

def print_list(lst) :
    for i in lst :
            if type(i) is int:
                    print(i,end = ' ')
            elif type(i) is list:
                    print_list(i)	#如果传入是列表,进入列表中递归
def print_list2(L):
	for x in L :
		if type(x) is list :
			print_list2(x)
		else:
			print(x) 
def sum_list(lst):
	s = 0
	for x in lst :
		if type(x) is list :
			s += sum_list(x)
		else :
			s += x
	return s
L = [[3,5,8], 10, [[13, 14], 15, 18], 20]
#print_list(L)
print(sum_list(L))
#>>>3 5 8 10 13 14 15 18 20 
#>>>106