持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第11天，点击查看活动详情
大家好，我是木大木大，因为疫情和环境原因啊，在家开始了自学python的路子，从此深坑加一人。后面我会每天持续更新一些学习python的过程，当然一开始就是一些基础啦，希望大家多多支持，莫嫌弃啦~
匿名函数
1.1 高级用法
1.函数可以被引用(可以赋值)
def fn():
print("我是fn")
f = fn
print(f,fn) # <function fn at 0x00000285399F73A0> <function fn at 0x00000285399F73A0>
f() # 我是fn
2.函数可以作为参数传入另外一个函数
def fn():
print("我是fn")
def fn2(x): # x——》fn
print(x)
x() # x()==fn()
fn2(fn)
3.可以将函数作为返回值
def fn():
print("我是fn")
def fn2(x): # x——》fn
return x
x = fn2(fn) # fn
x() # 我是fn
4.函数可以作为容器的元素
def fn():
print("我是fn")
list1 = [1,2,3,fn]
f = list1[3] # fn
f()
1.2 匿名函数(lambda)
语法：
lambda 参数列表:运算表达式
# 普通写法
def fn(x):
return x*x
print(fn(5))
# lambda写法
f = lambda x:x*x
print(f(5)) # 25
总结：
1.lambda并不会带来程序运行效率的提高，只会使代码更加简洁
2.如果使用 lambda，lambda内部不要有循环，因为可读性不好，有的话请使用标准函数来完成，目的使为了代码有可重用性和可读性
3.lambda只是为了减少单行函数的定义而存在，如果一个函数，只有一个返回值，只有一句代码，就可以使用 lambda
1.3 高阶函数
1.3.1 高阶内置函数简介
高阶函数其实就是把函数作为参数传入
abs() # 绝对值
print(abs(-1)) # 1
sum()
print(sum([1, 2, 3, 4, 5])) # 15
print(sum((2, 3, 4), 2)) # 元组计算总和后再加 2 得到结果是11
print(sum([2, 3, 4, 1], 1)) # 列表计算总和后再加 1 得到结果是11
round() # 四舍五入，精度问题 四舍六入
print(round(4.3)) 4
print(round(4.8)) 5
def ab_sum(a,b):
return abs(a) + abs(b)
res = ab_sum(-1,-4)
print(res)
任意两个数字，对2个数字求绝对值后进行求和
def ab_sum(a,b,f):
return f(a) + f(b)
result = ab_sum(-1,-4,abs)
print(result) # 5
def ab_sum(a,b,f):
return f(a) + f(b)
result = ab_sum(-1,-4.3,round)
print(result) # -5
任意两个数字，对2个数字求相反数的和
def xfs(x):
return -x
def ab_sum(a,b,f):
return f(a) + f(b)
result = ab_sum(-1,4,xfs)
print(result)
1.3.2 map()
map(func,seq) 第一个参数是给一个函数，第二个参数是给一个序列类型，map返回的是一个迭代器
将列表序列中各个元素加一
# 普通写法
list1 = [1,2,3,4,5]
list2 = []
for i in list1:
list2.append(i+1)
print(list2) # [2, 3, 4, 5, 6]
# map写法
list1 = [1,2,3,4,5]
def add1(x):
return x+1
print(list(map(add1,list1))) # [2, 3, 4, 5, 6]
迭代器就是可以用来循环迭代取值
list可以一次性拿到迭代器所有元素并且放到数组中
list1 = [-1,2,-3,4,-5]
print(list(map(abs,list1))) # [1, 2, 3, 4, 5]
list1 = [1,2,3,4,5]
def add1(x):
return '木大'
print(list(map(add1,list1))) # ['木大', '木大', '木大', '木大', '木大']
# lambda写法
list1 = [1,2,3,4,5]
print(list(map(lambda x: x + 1, list1)))
总结：
1.map内置函数的作用就是操作序列中所有的元素，并返回一个迭代器，迭代器转为列表
2.咱们的lambda表达式可以专门配合我们的高阶内置函数来做简单实现
1.3.3 filter()
语法：
filter(func,seq)第一个参数是给一个函数，第二个参数给一个序列类型，用于过滤序列，过滤掉不符合条件的元素，结果可以通过list转换
保留一个序列中所有的偶数
# 普通写法
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for i in list1:
if i % 2 != 0:
list1.remove(i)
print(list1)
# filter写法
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def o2s(x):
return x % 2 == 0
print(list(filter(o2s, list1)))
# lambda写法
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(filter(lambda x: x % 2 == 0, list1)))
1.3.4 sorted()
sorted(序列类型,key=函数)
返回一个排序后的序列
list1 = [2,4,1,3,5,6,9,7]
print(sorted(list1)) # 升序 [1, 2, 3, 4, 5, 6, 7, 9]
print(sorted(list1,reverse=True)) # 降序 [9, 7, 6, 5, 4, 3, 2, 1]
根据列表中的分数进行排序
# 普通写法
list1 = ["七零:69","久违:79","大力:89","乃荣:100","小川:59"]
def f(x):
arr = x.split(":")
return int(arr[1])
print(sorted(list1, key=f))
# lambda写法
list1 = ["七零:69","久违:79","大力:89","乃荣:100","小川:59"]
print(sorted(list1, key=lambda x: int(x.split(":")[1])))
max(可迭代对象,key=函数)：根据函数获取可迭代对象的最大值
min(可迭代对象,key=函数)：根据函数获取可迭代对象的最小值
a = ["张三:100","李四:77","王五:99","赵六:50"]
def f(x):
return int(x.split(":")[1])
print(min(a,key=f)) # 赵六:50
print(max(a,key=f)) # 张三:100
总结：
有了这些内置高阶函数，我们可以更加灵活的去操作序列类型，比原始的for循环 if判断 要简单那么一点，但是其实也就简单一点点，更多是变灵活了
1.3 递归函数
如果一个函数的内部调用了自己，那么这个就叫做递归
如果要定义递归函数，不想让它报错的话，必须要有出口
不断地向出口接近
打印1-500
def fun(x): if x == 501: return print(x) return fun(x+1) # f(1) f(2) =>f(501) fun(1)
1234...9 9! = 987654321 9! = 98! 9! = 987! 9! = 9876! n! = n*(n-1)!
def f(n): if n ==1: return 1 return nf(n-1) # 5432*1 a = f(5) print(a)
函数的递归：是函数嵌套调用的一种特殊形式，函数嵌套调用在调用一个函数的过程当中调用了另外的函数。函数的递归在调用一个函数的过程中又调用到本身
