day11
函数式编程
是指用一系列函数解决问题
示例:
求1 + 2 + 3 + ....+ 100的和
方法一
s = 0
for x in range(1,101):
s += x
print(s)
方法二
print(sum(range(1,101)))
函数的可重入性:
当一个函数输入一定,则输出必然一定的函数称为可重入性函数
说明:
可重入函数内一定不会访问局部变量以外的变量
示例:
#可重入函数:(推荐使用)
def myadd(x,y):
return x + y
print(myadd(100, 200)) #300
#不可重入函数:
y = 200
def myadd():
return x + y
print(myadd(100)) #300
y = 300
print(myadd(100)) #400
高阶函数High Order Function
什么是高阶函数:
满足下列条件中的一个的函数即为高阶函数
1.函数接收一个或多个函数作为参数传入
2.函数返回一个函数
python内置的高阶函数:
map, filter, sorted
map函数:
map(func, *iterable) (*iterable为星号元组形参,可存储多个对象)
返回一个可迭代对象,此可迭代对象用函数func对可迭代对象iterable中的每一个元素作为参数计算后得到新的数据
示例见:
mymap.py
def power2(x):
return x ** 2
for x in map(power2,range(1,10)):
print(x) #1 4 9 16 ... 81
练习一:
1.求:1**2 + 2**2 + 3**2 + ... +9**2的和
#代码
#方法一
def sums(n):
return n**2
s = 0
for n in map(sums,range(1,10)):
s += n
print(s)
#方法二
s = 0
for x in map(lambda x: x ** 2,range(1,10)):
s += x
prnt(s)
#方法三
print(sum(map(lambda x: x ** 2,range(1,10))))
2.求:1**3 + 2**3 + 3**3 + ... +9**3的和
print(sum(map(lambda x: x ** 3,range(1,10))))
示例2见:
mymap2.py
def mypow(x, y):
return x ** y
for i in map(mypow,[1,2,3,4],(4,3,2,1)):
print(i)
#代码
练习二:
求1**9 + 2 ** 8 + 3**7 + ... + 9**1的和
# 方法一
def mypow(x, y):
return x ** y
s = 0
for x in map(mypow,range(1,10),range(9,0,-1)):
s += x
print(s)
# 方法二
s = 0
for n in map(lambda x, y:x ** y,range(1,10),range(9,0,-1)):
s += n
print(s)
#方法三
print(sum(map(pow,range(1,10),range(9,0,-1))))
filter函数:
filter(function,iterable)
作用:
筛选可迭代对象iterable中的数据,返回一个可迭代对象,此可迭代对象只返回iterable中符合条件的数据
function将对iterable中提供的每一个数据进行求布尔值,如果为True则保留,返回False则丢弃此数据
示例见:
myfilter.py
def isadd(x):
return x % 2 == 1
for x in filter(isadd,range(10)):
print(x)
L = list(filter(isadd,range(10)))
print("L=",L)
练习三:
1.将1~20的偶数用filter生成可迭代对象后,将可迭代对象生成的数据存于列表中
最终结果:
L = [2,4,6,8,10.....18,20]
#代码
#方法一
def ou(n):
return n % 2 == 0
L = list(filter(ou,range(2,21)))
print(L)
#方法二
def ou(n):
if n % 2 == 0:
return True
return False
L = list(filter(ou,range(2,21)))
print(L)
#方法三
L = list(filter(lambda n: n%2==0,range(2,21)))
print(L)
2.用filter函数将1~100之间所有的素数放入到列表L中
print(L) #[2,3,5,7....]
def sushu(n):
if n < 2:
return False
for b in range(2,n):
if n % b == 0:
return False
return True
L = list(filter(sushu,range(100)))
print(L)
sorted函数
作用:
将原可迭代对象的数据进行排序,生成排序后的列表
函数参照格式:
sorted(interable,key=None,reverse=False)
说明;
interable 可迭代对象
key
函数是用来提供一个值,这个值作为排序的依据,如果不给出key函数,则用原数据的值进行排序和比较
reverse标志用来设置是否降序排列
示例:
L = [5, -2, -4, 0, 3, 1]
L2 = sorted(L) #[-4, -2, 0, 1, 3, 5]
L3 = sorted(L,reverse=True) #[5, 3, 1, 0, -2, -4]
L4 = sorted(L,key=abs,reverse=False)
#[0, 1, -2, 3, -4, 5]按绝对值排序
L5 = sorted(L,key=abs,reverse=True)
#[5, -4, 3, -2, 1, 0]
names = ['Tom', 'Jerry', 'Spike', 'Tyke']
L6 = sorted(names)
#['Jerry', 'Spike', 'Tom', 'Tyke']
L7 = sorted(names, key=len)
#['Tom', 'Tyke', 'Jerry', 'Spike']
练习四:
names = ['Tom', 'Jerry', 'Spike', 'Tyke']
排序依据是字符串的反序
'moT' 'yrreJ' 'ekipS' 'ekyT'
结果:
['Spike','Tyke','Tom','Spike']
#方法一:
names = ['Tom', 'Jerry', 'Spike', 'Tyke']
S = []
for i in range(len(names)):
S.append(names[i][::-1])
L = sorted(S)
N = []
for x in range(len(L)):
N.append(L[x][::-1])
print(N)
#方法二:
names = ['Tom', 'Jerry', 'Spike', 'Tyke']
def k(s):
return s[::-1]
L = sorted(names,key=k)
print(L)
递归函数 recurison
递归是指 函数直接或间接调用自身
递归示例:
#函数直接调用自身
def f():
f() #直接调用自身
f()
print("递归完成")
#函数间接调用自身
def fa():
fb()
def fb():
fa()
fa()
print("递归完成")
递归说明:
递归一定要控制递归的层数,当符合某一条件时要终止递归调用,几乎所有的递归都能用while循环来代替
递归的优缺点:
优点:
可以把问题简单化,让思路理会清晰,代码更简洁
缺点:
递归因系统环境影响大,当递归深度太大时,可能会得不到预知的结果
递归调用分为两个阶段:L
递推阶段:
从原问题出发,按递归公式递推,从未知到已知,最终达到递归终止条件
回归阶段:
按递归终止条件得出结果,逆向逐步带入递归公式,回归到原问题的求解
示例:
限制递归层数的示例见:
recurison2.py
def fx(n):
print("递归进入第",n,'层')
if n == 3:
return
fx(n+1)
print("递归退出第",n,'层')
fx(1) #调用
print("程序结束")
#结果:
# 递归进入第 1 层
# 递归进入第 2 层
# 递归进入第 3 层
# 递归退出第 2 层
# 递归退出第 1 层
# 程序结束
递归求阶乘示例见:
recurison_factorial.py
def myfac(n):
#5! = 5 * 4!
#5! = 5 * 4! * 3!
#5! = 5 * 4! * 3! * 2!
#5! = 5 * 4! * 3! * 2! * 1!
#5! = 5 * 4! * 3! * 2!
#5! = 5 * 4! * 3!
#5! = 5 * 4!
if n == 1:
return 1
#如果不是1,则递推到下一级求解
return n * myfac(n - 1)
print(myfac(5))
print(myfac(4))
练习五:
用递归实现求和:
def mysum(n):
#返回 1+2+3+4+5+...+n的和
print(mysum(100))
#代码
def mysum(n):
if n == 1:
return 1
return n + mysum(n - 1)
print(mysum(100))
闭包 closure
什么时闭包
闭包是指引用了此函数外部变量的函数
如果一个内嵌函数访问了外部嵌套函数的变量,则这个内嵌函数就是闭包
闭包必须满足的三个条件:
1.必须有一个内嵌函数
2.内嵌函数必须引用外部函数中的变量
3.外部函数返回值必须是内嵌函数
示例见:
closure.py
def make_power(y):
def fn(x):
return x ** y
return fn
pow2 = make_power(2)
print("5的平方是:",pow2(5))
def pow3(x):
return x**3
pow3 = make_power(3)
print('6的三次方是:',pow3(6))
print('5的三次方是:',pow3(5))
pow10 = make_power(10)
print('2的十次方',pow10(2))
练习六:
已知有五位朋友在一起
第五个人说他比第四个人大2岁
第四个人说他比第三个人大2岁
第三个人说他比第二个人大2岁
第二个人说他比第一个人大2岁
第一个人说他十岁
编写程序:
1.算出第5个人几岁?
2.算出第3个人几岁?
def myage(x):
return (x-1)*2+10
print(myage(3))
print(myage(5))
def myage(x):
if x == 1:
return 10
return myage(x - 1) + 2
print(myage(3))
print(myage(5))
课后练习:
1.写程序算出1~20的阶乘的和
1!+2!+3!+4!+.....+20!
#方法一:
def myfac(n):
if n == 1:
return 1
return n * myfac(n - 1)
# L = []
# for i in range(1,21):
# L.append(myfac(i))
# print(sum(L))
print(sum(map(myfac,range(1,21))))
#方法二:
def myfac(n):
s = 1
for i in range(1,n+1):
s = s * i
return s
def sum_factorial(n):
s = 0
for i in range(1, n):
s += myfac(i)
return s
print(sum_factorial(20))
2.已知有列表:
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
L = [[3,5,8], 10, [[13,14],15,18],20]
def print_list(lst):
for i in lst:
if type(i) is int:
print(i)
if type(i) is list:
print_list(i)
print_list(L)
def sum_list(lst):
s = 0
for x in lst:
if type(x) is int:
s += x
elif type(x) is list:
s += sum_list(x) #求x绑定列表的和
return s
print("和是:", sum_list(L))
(3)改写之前的学生信息的程序,要求添加四个功能:
| 5)按学生成绩高-低显示学生信息 |
| 6)按学生成绩低-高显示学生信息 |
| 7)按学生年龄高-低显示学生信息 |
| 8)按学生年龄低-高显示学生信息 |
def input_student(L):
L = []
while True:
a = input("请输入姓名：")
if a == '':
break
b = int(input("请输入年龄: "))
c = int(input("请输入成绩: "))
d = {}
d["name"] = a
d['age'] = b
d['score'] = c
L.append(d)
return L
def get_chinese_char_count(s):
c = 0
for i in s:
if ord(i) > 127:
count += 1
return c
def output_student(L):
m = 0
for i in L:
j = i["name"]
m = max(len(j),m)
count = get_chinese_char_count(j)
print('+'+'-'*(m-count)+'+'+'-'*m+'+'+'-'*(m+1)+'+')
print('|'+'name'.center(m)+'|'+'age'.center(m)+'|'+'score'.center(m+1)+'|')
print('+'+'-'*(m-count)+'+'+'-'*m+'+'+'-'*(m+1)+'+')
for i in L:
j = i["name"]
p = str(i["age"])
q = str(i["score"])
print('|'+j.center(m)+'|'+p.center(m)+'|'+q.center((m+1))+'|')
print('+'+'-'*(m-count)+'+'+'-'*m+'+'+'-'*(m+1)+'+')
def delete_student(L):
n = input("请输入您要删除信息学生的名字：")
print("正在删除学生信息")
for a in L:
if a["name"] == n:
L.remove(a)
print("学生信息已经删除")
break
else:
print("您输入的姓名不存在")
return L
def alter_student(L):
a = input("请输入您要修改信息的学生名字：")
b = input("请输入您要修改信息的学生年龄：")
c = input("请输入您要修改信息的学生成绩：")
for m in L:
if m["name"] != a:
print("学生不存在")
if m["name"] == a:
m["age"] = b
m["score"] = c
print("学生信息已经修改")
return L
def score_high_student(L):
def get_score(d): #d是字典
return d['score']
L2 = sorted(L, key=get_score, reverse=True)
output_student(L2)
def score_low_student(L):
def get_score(d): #d是字典
return d['score']
L2 = sorted(L, key=get_score, reverse=False)
output_student(L2)
def age_high_student(L):
L2 = sorted(L, key=lambda d:d['age'], reverse=True)
output_student(L2)
def age_low_student(L):
L2 = sorted(L, key=lambda d:d['age'])
output_student(L2)
def operate():
print("+------------------------------+")
print("|1)添加学生信息 |")
print("|2)显示学生信息 |")
print("|3)删除学生信息 |")
print("|4)修改学生信息 |")
print("|5)按学生成绩高-低显示学生信息 |")
print("|6)按学生成绩低-高显示学生信息 |")
print("|7)按学生年龄高-低显示学生信息 |")
print("|8)按学生年龄低-高显示学生信息 |")
print("|q)退出 |")
print("+------------------------------+")
def main():
L = []
while True:
operate()
x = input("请输入您的选择：")
if x == 'q':
break
elif x == '1':
L += input_student(L)
elif x == '2':
output_student(L)
elif x == '3':
delete_student(L)
elif x == '4':
alter_student(L)
elif x == '5':
score_high_student(L)
elif x == '6':
score_low_student(L)
elif x == '7':
age_high_student(L)
elif x == '8':
age_low_student(L)
main()