递归与lamdba与高阶函数

递归

自己调用自己

必须有一个出口

#需要：3以内数字累加和 3 + 2 + 1 = 6

def sum_numbers(num):
    #2. 出口
    if num == 1:
        return 1
    #如果不是1，重复执行累加并返回结果
    return num + sum_numbers(num-1)

sum_result = sum_numbers(3)
#输出结果为6
print(sum_result)

---

lambda表达式

如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化。

语法：

lambda 参数列表：表达式(返回值)

注意：

lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用。

lambda表达式能接受任何数量的参数但只能返回一个表达式的值

案例：  返回值  100

#1.函数
# def fn1():
#     return 100
#
# result = fn1()
# print(result)

# 2. lambda
#lambda 参数列表：表达式
fn2 = lambda:100
# print(fn2)  #la,dba内存地址

#100返回值 调用函数
print(fn2())

作用：节省代码

lambda 案例  #计算a+b

#计算a+b

#函数实现

def add(a,b):
    return a + b

result = add(1,2)
print(result)

#lamdba实现
fn1 = lambda a,b:a+b
print(fn1(3,2))

lmbda的几种参数形式

#lamdba的参数形式
#1.无参数
fn1 = lambda: 100
print(fn1())

#2.有一个参数
fn2 = lambda a: a
print(fn2('gyq gyq'))

#3.默认参数
fn3 = lambda a,b,c=100:a+b+c
print(fn3(10,20))

#4.可变参数：*args #返回的值是一个元组
fn4 = lambda *args:args
print(fn4(10,20,30,40)) # (10, 20, 30, 40)
print(fn4(10))

#5.可变参数: **kwargs #收集的是关键字参数，返回的是字典
fn5 = lambda **kwargs: kwargs
print(fn5(name='python'))
print(fn5(name='python',age=30))

lambda的应用

带判断的lamdba——与三目运算符类似

fn1 = lambda a,b: a if a > b else b #谁打返回谁
print(fn1(1,20))

lambda列表数据按字典key的值排序
#列表数据按字典key的值排序
students = [
{'name': 'TOM', 'age': 20},
{'name': 'Gyq', 'age': 19},
{'name': 'Jack', 'age': 18},
]

#sort(key=lambda...,reverse=bool数据)
#1. name key对应的值进行升序排序 按首字母顺序前后排序
students.sort(key=lambda x: x['name'])
print(students)#按照首字母进行排序

#2. name key对应的值进行降序排序，按首字母顺序前后排序
students.sort(key=lambda x: x['name'],reverse=True)
print(students)

#3.age key对应的的值进行升序排序,从小到大
students.sort(key=lambda x: x['age'])
print(students)

---

高阶函数

函数作为参数传入，这样的函数称为高阶函数。高阶函数是函数式编程的体现。

abs()函数可以完成对数字求绝对值计算

# abs()函数可以完成对数字求绝对值计算

sum=abs(-10)
print(sum)

#round()函数可以完成对数字的四舍五入计算
sum1 = round(1.2) # 1
sum2 = round(1.9) # 2

print(sum1) #1
print(sum2) #2

# 任意两个数字，按照指定要求整理数字后在进行求和计算
def add_num(a,b):
return abs(a) + abs(b)

result = add_num(-1,2)
print(result)

方法二

#方法二
def sum_num(a,b,f):
    return f(a) + f(b)

result = sum_num(-1,2,abs)
print(result) #3

#写法一
# def add_num(a,b):
# #绝对值
# return abs(a) + abs(b)
#
# result = add_num(-1.1,1.9)
# print(result) #3

#写法二 第三个参数用来接受将来传入的函数
def sum_num(a,b,f):
return f(a) + f(b)

result1 = sum_num(-1,5,abs)
print(result1)

result2 = sum_num(1.1,1.3,round)
print(result2)

结论：函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度快。

---

内置高阶函数

map()

map(函数名,列表名)，将传入的函数作用到列表的每个元素中，并将结果组成新的列表(Python2)/迭代器(Pthon3)返回。

案例1：计算list序列中各个数字的2次方

list1 = [1,2,3,4,5]

#2.准备2次方计算的函数
def func(x):
    return x ** 2

#调用map
result = map(func,list1)

#4.验收成果
print(list(result))

reduce()

reduce(函数名,列表名)， 其中函数名必须有两个参数。每次函数计算的结果继续和序列的下一个元素做积累计算。

案例一：计算list1序列中各个数字的累加和

list1 = [1,2,3,4,5]

#1.导入模块
import functools

#2.定义功能函数
def func(a,b):
    return a + b

#3.调用reduce ,作用：功能函数计算的结果和序列的下一个数据做累计计算
result = functools.reduce(func,list1)
print(result)

filter()

用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表，可以使用list()转换。

list1 = [1,2,3,4,5,6,7,8,9,10]

#1.定义功能函数：过滤序列中的偶数
def func(x):
    return x % 2 == 0

#2.调用filter
result = filter(func,list1)

# 使用list()转换
print(list(result))