函数
lambda表达式(又名匿名函数表达式)
作用:创建一个匿名函数对象
同def类似,但不提供函数名
语法:
lambda [形参1, 形参2, ……] : 表达式
示例:
def myadd(x, y):
return x + y
可以改写为:
myadd = lambda x, y: x + y
print(myadd(100, 200))
print(myadd('abc', '100'))
'''
运行结果:
300
abc100
'''
语法说明:
1、lambda 值是一个表达式,它用来创建一个函数对象2、当lambda表达式调用时,先执行冒号后面的表达式,并返回表达式的结果的引用
3、lambda表达式创建的函数只能包含一条表达式
4、lambda比函数简单,且可以随时创建和销毁,有利于减少程序的耦合度
练习:
#! /usr/bin/python3
'''
1、写一个lambda表达式,判断这个数的平方加一能否被5整除,如果能返回True,否则返回False
'''
fx = lambda n: (n ** 2 + 1) % 5 == 0
print(fx(4))
print(fx(3))
#! /usr/bin/python3
'''
2、写一个lambda表达式,求两个变量的最大值:
'''
# mymax=lambda x,y : max(x,y)
mymax = lambda x, y: x if x > y else y
print(mymax(55, 63))
看懂下面的程序在做什么:
def fx(f, x, y):
r = f(x, y)
print(r)
fx((lambda a, b: a + b), 100, 200)
fx((lambda a, b: a ** b), 3, 4
eval 和 esec 函数
eval函数:
作用:把一个字符串当成一个表达式执行,返回表达式执行后的结果
格式:
eval(source, globals=None, locals=None)
示例:
x = 100
y = 200
s = 'x+y'
v=eval(s)
print(v)
print(eval('x+y', {'x': 10, 'y': 20})) # 大括号内为设置的全局变量 结果:30
print(eval('x+y', {'x': 10, 'y': 20}, {'x': 1, 'y': 2})) # 第二个大括号内为设置的局部变量 结果:3
print(eval('x+y', {'x': 10, 'y': 20}, {'x': 1})) #结果:21
exec函数:
作用:把一个字符串当成程序来执行
格式:
exec(soure, globals=None, local=None)
示例:
s = 'x=100; print("hello"); x += 1; print(x)'
print(s)
exec(s)
'''
自己写一个程序,解释执行用户输入的任何语句
'''
while True:
s=input('请输入语句$ >>>>')
if s=='bye':
break
eval(s)
函数式编程:
是指用一系列函数解决问题函数是一等公民
1、函数本身是对象可以赋值给变量,复制后变量绑定函数2、允许将函数作为实参传入另一个函数
3、允许函数返回一个函数
函数式编程的好处:
1、每一个函数完成细小的功能,一系列菡数的任意组合可以解决大的问题2、函数仅接收输入并产生输出,不会影响其他全局变量的状态
思考:
求 1 + 2 + 3 + …… + n 的和
print(sum(range(n+1)))
练习:
求1+1/2+1/4+1/8+……+1/2**n
print(sum([1 / 2 ** x for x in range(n + 1)]))
高阶函数 High Order Function
什么是高阶函数:满足下列条件中的一个的函数即为高阶函数
1、函数接受一个或多个函数作为参数传入
2、函数返回一个函数
python内置(builtins)的高阶函数
map, filter, sortedmap 函数
map(func, *iterables) 用函数对可迭代对象的每一个元素作为参数计算出新的可迭代对象,当最短的一个可迭代对象不再提供数据时,此可迭代对象生成结果示例:
#生成一个可迭代对象,要求此可迭代对象可以生成1-9自然数的平方
#! /usr/bin/python3
def power2(x):
return x ** 2
for x in map(power2, range(1, 10)):
print(x)
# 求以上数据的和
print(sum(map(power2, range(1, 10))))
示例:
生成一个可迭代对象,要求次可迭代对象生成1**4,2**3,3**2,4**1
for x in map(pow,[1,2,3,4],[4,3,2,1]):
print(x)
练习:
'''
1、求1**2+2**2+3**2+……9**2的和
'''
s = sum(map((lambda x: x ** 2), range(1, 10)))
print(s)
'''
2、求1**3+2**3+3**3+……9**3的和
'''
s = sum(map((lambda x: x ** 3), range(1, 10)))
print(s)
'''
3、求1**9+2**8+3**7+……9**1的和
'''
s = sum(map(pow, range(1, 10), range(9, 0, -1)))
print(s)
filter 函数:
格式:filter(func,iterable)
作用:
筛选可迭代对象iterable中的数据,返回一个可迭代对象,次可迭代对象将对iterable进行筛选
函数func将对iterable中的每个元素进行求职,返回False时将此数据丢弃,返回True保留此数据
示例:
# isodd函数判断x是否为奇数,是奇数返回True
def isodd(x):
return x % 2 == 1
# 打印十以内的奇数:
for i in filter(isodd, range(10)):
print(i)
# 生成10以内所有偶数的列表
l = [i for i in filter(lambda x: x % 2 == 0, range(10))]
print(l)
sorted 函数:
作用:将元可迭代的数据进行排序,生成排序后的列表
格式:
sorted(iterable,key=None, reverse=False)
参数说明:
iterable 可迭代对象
key 绑定函数,此函数用来提供一个排序的依据
reverse 标志是否设置是否降序排序(从大到小)
示例:
L = [5, -2, -4, 0, 3, 1]
L2 = sorted(L)
print(L2) # L2 = [-4, -2, 0, 1, 3, 5]
L3 = sorted(L, reverse=True)
print(L3) # L3 = [5, 3, 1, 0, -2, -4]
L4 = sorted(L, key=abs)
print(L4) # L4 = [0, 1, -2, 3, -4, 5]
示例:
names = ['Tom', 'Jerry', 'Spike', 'Type']
L = sorted(names) # ['Jerry', 'Spike', 'Tom', 'Type']
# 能否根据名字的长度进行排序?
L = sorted(names, key=len) # ['Tom', 'Type', 'Jerry', 'Spike']
# 根据名字最后字母排序
L = sorted(names, key=lambda x:x[::-1]) # ['Spike', 'Type', 'Tom', 'Jerry']
递归函数 recursion
函数直接或间接的调用自身示例
#直接调用自身
def f():
f() # 调用自身
f()
print('递归完成')
#函数间接调用自身的实例
def fa():
fb()
def fb():
fa()
fa()
递归说明:
递归一定要控制递归的层数,当符合某一条件时终止递归几乎所有递归都能用循环来代替
递归的优缺点
优点:递归可以把问题简单化,让路径更为清晰,代码更为简洁
缺点:
递归因系统环境影响大,当递归深度太大时,可能会得到不可预知的结果
示例:
#此程序用来示意递归函数的调用
# 以下程序会无限递归,永不终止
def story():
print('从前有座山,山上有座庙,庙里有个老和尚讲故事:',end='')
story()
print('故事讲完了')
story()
#此程序用参数来控制最大次数为3
def story(times): #times 代表讲故事的次数
print('第',times,'遍')
print('从前有座山,山上有座庙,庙里有个老和尚讲故事:')
if times>=3:
return #不要再讲故事了
story(times+1)#当前次数加一,再讲一遍
print('故事讲完了')
story(1)
#此程序用参数来控制最大次数为3
def fx(n): #times 代表讲故事的次数
print('现在第',n,'层')
if n>=3:
return #不要再讲故事了
fx(n+1)#当前次数加一,再讲一遍
print('递归的第',n,'层结束')
fx(1)
print('程序解释,当前回到了主程序')
'''
运行结果
现在第 1 层
现在第 2 层
现在第 3 层
递归的第 2 层结束
递归的第 1 层结束
程序解释,当前回到了主程序
'''
递归函数的实现方法
先假设函数已经实现示例:
'''
求:100+99+98+……+1的和
分析:
先假设 mysum(x)已经完成,且能求x+x-1+……+1的和
'''
def mysum(x):
if x==1:
return 1
return x+mysum(x-1)
print(mysum(100))
练习:
1、编写函数myfac(x)计算x的阶乘x!
5!=5*4*3*2*1
print(myfac(5)) # 120
2、写程序计算出1~20的阶乘的和
1!+2!+3!+……+20!
思考:
能否用函数式编程中的高阶函数实现
3、已知有列表:
L=[[3,5,8],10,[[13,14],15],18]
1)写一个函数print_list(lst)打印出列表中所有数字
print_list(L)
2)写一个函数sum_list(lst)返回列表中所有数字的和
print(sum_list(L)) #86
注:
type(x)可以返回一个变量的类型
如:
>>> type(20) is int #True
>>> type([1,2,3]) is list # True
5、开始学生信息管理项目:
需要两个函数:
input_student() 返回学生信息的字典的列表
output_student() 以表格方式打印学生信息
学生信息:
姓名(name) 字符串
年龄(age) int
成绩(score) int
input_student()调用时等待用户输入学生信息,当输入姓名为空时结束输入,最后将学生信息形成字典存入列表中返回
def input_student():
pass
L=input_student()
请输入学生姓名:小张
请输入学生年龄:20
请输入学生成绩:98
请输入学生姓名:小李
请输入学生年龄:23
请输入学生成绩:100
请输入学生姓名:<回车>输入结束
此时列表数据为:
L=[{'name':'小张',
'age':20,
'score':98},
{'name':'小李',
'age':23,
'score':100}]
def output_student():
pass
print(L) #打印出字典的列表
output_student(L) #打印出学生信息的表格如下
+---------------+---------------+-------------+
| name | age | score |
+---------------+---------------+-------------+
| 小张 | 20 | 98 |
| 小李 | 23 | 100 |
+---------------+---------------+-------------+