day12.txt
函数式编程
函数式编程是用一系列函数解决问题
函数是一等公民
说明：
用每一个函数完成细小的功能，一系列函数的任何组成可解决大问题
函数仅接受输入并尝试输出，不包括任何可能影响输出的内部状态
函数的可重入性
当一个函数没有访问除局部变量以外的变量，则此函数为可重入函数
示例：
＃可重入 函数
def myadd1(x,y)
return x+y
#不可重入函数
s=0
def myadd2(x,y):
global s
s+=x+y
return s
高阶函数 High Order Function
什么是高阶函数
满足下列调节中一个的函数即为高阶函数
函数接受一个或多个函数作为参数传入
函数返回一个函数
python 内建函数的高阶函数
map ,filter,sorted
map 函数：
map (func,*iterables) 返回可迭代对象，此可迭代对象用func对可迭代对象iterable中的每个元素作为
参数计算后得到结果，再返回，当最短的一个可迭代对象不再提供数据时迭代结束
def power2(x):
return x**2
#生成一个可迭代对岸死昂，此可迭代对象可以生成１～９的自然是的平方
for x in map(power2,range(1,10)):
print(x)
#生成一个可迭代对象，此可迭代对象可以生成
＃ １××4, 2**3, 3**2 ,
for x in map(pow,range(1,5),range(4,0,-1),range(5,100)):
print(x)
练习：
求：１**2+2**2+3**2+...9**2的和
求：１**3+2**3+3**3+...9**3的和
求：１**9+2**8+...9**1的和
# def pow1(x):
# return x**2
# s=0
# for x in map(pow1,range(1,10)):
# s=s+x
# print(i)
print(sum(map(pow2(x),range(1,10))))
print(sum(map(lambda x:x**3,range(1,10))))
print(sum(map(lambda x,y:x**y,range(1,10),range(9,0,-1))))
<=>等价于 pow,
filter函数
filter(func,iterable)返回一个可迭代对象，此可迭代对象将对iterable获取的数据用函数func进行筛选
：func将iterable中的每个元素进行求值，返回false 则丢弃，返回true 则保留此数据
示例：
def isodd(x):
return x%2 ==1
#判断x是否是奇数，如果是奇数返回true,否则
＃生成１～１００的奇数
for x in filter(isodd,range(100)):
print(x)
#生成１～１００以内的偶数放到列表内
even=[x for x in filter((lambda x:x%2),range(1,100))]
print(even)
练习：
１，把１～100之间的全部素数放在列表primes中
def isprime(x)
if x<2:
return False
for i in range(2,x):
if x%2==0:
return False
else:
return True
prime=[x for x in filter(isprime,range(100))]
print(prime)
sorted函数
作用：
将原可迭代对象的数据进行排序，生成排序后的列表
格式：
sorted(iterable,key=None,reverse=False)
说明：
iterable 是可迭代对象
key函数是用来提供比较值的函数，这个值将作用排序的依据
reverse标志用来设置是否降序排列
此示例示意sorted函数的用法
l=[5,-2,-4,0,3,1]
l2=sorted(l)#[-4,-2,0,1,3,5]
print('l2=',l2)
l3=sorted(l,reverse=True)
print('l3=',l3)#[5,3,1,0,-2,-4]
l4=sorted(l,key=abs) #[0,1,-2,3,-4,5]
练习
name=['Tom','Jerry','Spike','Tyke']
排序的依据是’moT 'yerrJ','ekipS' 'ekyT'
结果是：
name=['Tom','Jerry','Spike','Tyke']
def x(a):
r=a[::-1]
print('222222',r)
return r
l=sorted(name,key=x)
print(l)
递归函数 recursion
示例：
＃函数直接调用子句
def f1():
f1()
递归说明：
递归一定要空值递归的层数，当复合一定条件时要终止递归调用
几乎所有的递归都能用while循环来代替
优缺点：
优点是可以把问题简单化，让思路更为清晰，代码更简洁
缺点是因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果 #当递归次数多时，会崩溃
递归函数调用分为两个阶段：
１，递推阶段
从原问题除非，按递归公式递推从未知到已知，组中到达递归终止条件
２.回归阶段
按递归终止条件求出结果，逆向逐步代入递归公式，回归原问题求解
示例：
#此示例示意递归调用和根据条件结束递归
def fx(n):
print("递归进入第",n,"层")
if n==3:
return
print("递归退出第",n,"层")
fx(1)
print('程序结束')
def myfac(n):
#如果
if n==1:
return 1
return n*myfac(n-1)
print(myfac(50))
练习：用递归方式算1+2+3+4...n的和
def mysum(n):
if n==1:
return 1
return n+mysum(n-1)
print(my(100))
思考题：
已知有5位朋友在一起
第五位朋友说他比第四位朋友大两岁
第四位朋友说他比第三位朋友大两岁
第三位朋友说他比第二位朋友大两岁
第二位朋友说他比第一位朋友大两岁
第一位朋友说他10岁
def getage(n): #求第n个人的 年级
if n==1:
return 10
return getage(n-1)+2
print(getage(5))
闭包 closure
什么是闭包
闭包是指引用了此函数外部变量的函数
如果一个内嵌函数访问了外部嵌套函数的变量,则这个内嵌函数就是闭包
闭包必须满足三个条件:
1. 必须有一个内嵌函数
2. 内嵌函数必须引用外部函数中的变量
3. 外部函数返回值必须是内嵌函数
示例：
def make power(x)
Y用闭包创建的任意的
# f(x)=a*x**2+b*x+c
def get_fx(a,b,c):
def fx(x):
return a*x**2+b*x+c
return fx
f123=get_fx(1,2,3)
print(f123(20))
print(f123(50))
练习；
1，编写程序求1~20的阶乘的和
1！+...10!
def
2. 改写之前的学生信息的程序,要求添加四个功能:
| 5) 按学生成绩高-低显示学生信息 |
| 6) 按学生成绩低-高显示学生信息 |
| 7) 按学生年龄高-低显示学生信息 |
| 8) 按学生年龄低-高显示学生信息 |
3. 已知有列表:
L = [[3, 5, 8], 10, [[13, 14], 15, 18], 20]
1) 写一个函数 print_list(lst) 打印出所有的数字
print_list(L) # 3 5 8 10 13 ....
2) 写一个函数 sum_list(lst) 返回列表中所有数字的和
print(sum_list(L)) # 106
注:
type(x) 函数可以返一个对象的类型
如:
>>> type(20) is int # True
>>> type([3, 5, 8]) is list # True
>>> type(20) is list # False
def print_list(list):
for x in lsit:
#当x是数字时，打印这个数字，
if type(x) is int:
print(x)
#当x是列表，则打印列表
else:
print_list(x)
print_list(l)
def sum_list(list):
s=0
for x in list:
if type(x) is list:
s+=x
else:
s+=sum_list(x)
print(sum_list(l))
