1.1 高级用法
目录
1.1 高级用法
1.函数可以被引用(可以赋值)
2.函数可以作为参数传入另外一个函数
3.可以将函数作为返回值
4.函数可以作为容器的元素
2.1 匿名函数（lambda）
3.1 高阶函数
3.1.1 高阶函数简介
3.1.2 map（）
3.1.3 reduce（）
3.1.4 filter
3.1.5 sorted
4.1 递归函数
5.1 练习
6.1 答案解析
1.函数可以被引用(可以赋值)
def fn():
print('我是fn')
f = fn # 赋值函数
f()2.函数可以作为参数传入另外一个函数
def fn():
print('我是fn')
def fn2(x): # x = fn
x() # fn()
fn2(fn)3.可以将函数作为返回值
def fn():
print('我是fn')
def fn2(x): # x = fn
return x
a = fn2(fn)
print(a)4.函数可以作为容器的元素
list1 = [1, 2, 3, fn]
list1[3]() # fn()2.1 匿名函数（lambda）
匿名函数：没有名字的函数
匿名函数用关键字lambda实现
lambda函数的语法,如下
lambda 参数列表:运算表达式
def fn(x):
return x * x
f = lambda x: x * x
print(f(5))
总结
1.lambda并不会带来程序运行效率的提高，只会使代码更简洁
2.如果使用lambda，lambda内不要循环，有的话用标准函数完成
3.lambda只是为了减少单行函数的定义而存在3.1 高阶函数
3.1.1 高阶函数简介
abs():对数字求绝对值计算
绝对值：就是将一个数变正数，0还是0
round():四舍五入 bug =》 奇数满足四舍五入，偶数 四舍大于5入
小数二进制。
def ab_sum(a, b, f):
return f(a) + f(b)
print(ab_sum(-1, -4.5, lambda x:-x))
print(ab_sum(-1, -4.5, abs))
print(ab_sum(-1, -4.5, round))
python所提供的的内置高阶函数
map filter reduce sorted3.1.2 map（）
语法
map(func,seq):将传入的函数变量func作用到序列变量seq的每个元素中，并将结果组成新的迭代器返回
高阶内置函数 func的参数都是有固定含义
# 将列表中的各个数字+1
list1 = [-1, 2, -3, 4, -5]
# map 可以直接操作序列中的每个元素
print(list(map(lambda x:x+1, list1))) # 222
总结：
1.map内置函数的作用是操作序列中的所有元素，并返回一个迭代器，迭代器要转列表
2.lambda表达式可以专门配合高阶内置函数来简洁实现3.1.3 reduce（）
语法
reduce(func,seq) ：聚合
func 必须要有2个参数
注意：reduce() 传入的参数func必须有2个参数
reduce是将每次函数的结果继续和序列的下一个元素做累计计算(类似于累加法)
func(x,y)
reduce是需要导包，不是内置函数
from functools import reduce // 导入一个功能
def func(x, y):
return x + y
a = reduce(func, list1)
print(a)
a = reduce(lambda x,y:x+y, list1)
print(a)总结：
1.reduce就是平时遇见累积的都可以用
2.reduce返回一个值
3.reduce需要导入才能使用 from functools import reduce
3.1.4 filter
语法
filter(func,seq) : 用于过滤序列，过滤掉不符合条件的元素。结果要通过list转换---------(过滤)
def func(x): # x就代表每个元素，和map一样
return 布尔值 # 如果布尔值为真，则保留，否则过滤
# 保留一个序列中所有的偶数
# 除了0和 空字符串 都为
# 常见的转换为False : 0,"",[],(),{},set(),None
# def o2x(x): # 最终版
# return x % 2 == 0
print(list(filter(lambda x:x%2==0, list1)))list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def scy(x):
if x % 2 == 0:
return x
print(list(filter(scy,list1)))3.1.5 sorted
返回一共排序后的序列。
sorted 默认的排序规则函数，参数key ： key就是函数
list2 = ["小明:69", "大明:79", "小美:59", "小芳:89", '小娟:100', "马可波罗:99"]
def f(x): # x 代表每个值，和map，filter是一样的
# return ： 返回排序要比较的值
arr = x.split(":") # ["木槿",'69']
# arr[0] 名字
# arr[1] 分数 字符串
return int(arr[1])
print(sorted(list2, key=f)) # 编码
print(sorted(list2,key=f,reverse=True))
print(sorted(list2,key=lambda x: int(x.split(":")[1]),reverse=True))list2 = ["小明:69", "大明:79", "小美:59", "小芳:89", '小娟:100', "马可波罗:99"]
def scy1(x):
yyds = x.split(":")
return int(yyds[1])
print(sorted(list2,key=scy1))4.1 递归函数
递归：函数的内部调用了自己这个就叫递归
def func():
print('你好，我是天天')
func() # 函数的代码执行完就结束
func()
# 函数的作用域生命周期：调用时产生，调用结束时销毁递归的原则
1.如果要定义递归函数，不想让它报错的话，必须要有出口
2.设计一个出口，不断的向出口接近
> 接近出口（参数变化）一般是写在递归调
# 1*2*3*4*......*9
# 阶乘
def f(n): # n 是 1*2*3* .。。。9 # 1*......100
if n == 1:
return 1 # 返回1
return n * f(n - 1) # 变化都在递归调用里面写 jc(8) jc(7) jc(6) jc(5) .... jc(2) jc(1)
print(f(10)) # f(10) <=> 10*9 * 8*7*6*5*4*3*2*15.1 练习
# 1 . 对于序列 [-1,3,-5,-4] 的每个元素求绝对值
# 2 . 用map来处理字符串列表啊,把列表中所有人都变成sb,比方lucy_sb
name=['lucy','lilei','hanmeimei']
# 3 . 将一串数字‘1 3 5 7 8’转化为整型，并以列表形式输出
# 4. 用【递归】实现阶乘，定义一共函数有一个参数n
# 返回值是 1*2*3*....*n
# 5 .
要求用递归实现
斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……（从第3位开始，每一位数字都是前两位数字之和）
在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用。
要求输入N，输出第N位数字。如：
输入：8
输出：216.1 答案解析
# 1 . 对于序列 [-1,3,-5,-4] 的每个元素求绝对值
list1=[-1,3,-5,-4]
print(list(map(abs,list1)))
# 2 . 用map来处理字符串列表啊,把列表中所有人都变成sb,比方lucy_sb
'第一种方法'
name=['lucy','lilei','hanmeimei']
def scy1(x):
c=x+'_sb'
return c
print(list(map(scy1,name)))
'第二种方法'
def scy2(y):
return y+'_sb'
print(list(map(scy2,name)))
'第三种方法'
print(list(map(lambda x:x+'_sb',name)))
# 3 . 将一串数字‘1 3 5 7 8’转化为整型，并以列表形式输出
l1='1 3 5 7 8'
'第一种方法'
def scy3(m):
return int(m)
print(list(map(scy3,l1.split(' '))))
'第二种方法'
print(list(map(lambda g:int(g),l1.split(' '))))
# 4. 用【递归】实现阶乘，定义一共函数有一个参数n
# 返回值是 1*2*3*....*n
def scy1(n):
if n==1:
return 1
else:
return n*scy1(n-1)
numbers=int(input("请输入一个正整数: "))
res=scy1(numbers)
print("%d的阶乘是： %d"%(numbers,res))
# 5
# 要求用递归实现
# 斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，
# 指的是这样一个数列：1、1、2、3、5、8、13、21、34、……
# （从第3位开始，每一位数字都是前两位数字之和）
# 在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用。
# 要求输入N，输出第N位数字。如：
# 输入：8
# 输出：21
def yyds(n):
if n == 1 or n == 2:
return 1
else:
return yyds(n - 1) + yyds(n - 2)
n = int(input("请输入数列的项数为： "))
print(yyds(n))本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
