递归与高阶函数

函数补充

匿名函数

一、概念

Python中有一个lambda表达式，lambda有匿名的意思，并且lambda表达式就是简化的函数，所以被叫做匿名函数。

二、理解

匿名函数和普通函数的关系理解为单分支结构和三目运算符的关系。

三、匿名函数在语法上就是有单一的严格限制的固定语法。在语义上是普通函数的语法糖。

语法糖（糖衣语法），是英国的计算机学家提出的一个概念。语法糖就是对已经存在的语法的简化。
语法糖能提高代码的可读性，但是不影响功能。

# 案例：计算两个数字的和
def numSum(num1, num2):
    return num1 + num2


print(numSum(10, 20))
# ------------------------------------
numSumLambda = lambda num1, num2: num1 + num2
print(numSumLambda(10, 20))

匿名函数语法：
函数名 = lambda 形参:返回值
函数名(实参)

# 练习：计算1-100的和（使用匿名函数）
def total(start=1, end=100):
    sum = 0
    for i in range(start, end + 1):
        sum += i
    return sum


totalLambda = lambda start, end: sum([i for i in range(start, end + 1)])
print(totalLambda(1, 100))

# 并不是所有的普通函数都可以转为匿名函数

# 练习：使用匿名函数判断年份是否是闰年
leapYear = lambda year: True if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0 else False
print(leapYear(2005))

递归

一、递归

递归就是一种循环的思想。函数内嵌套本身函数

函数之间是一个相互调用的过程，递归是对于函数来说的，但是递归是一种特殊的函数调用（自己调自己）

二、迭代（递推）思维和递归思维

递推思维：斐波那契数列：根据已有的数据推算规律（正向的推算）
递归思维：根据规律逆向推算。

三、递归虽然是循环的思想，但是要注意循环结束的条件，不然就陷入了死循环。

著名的计算机学家：迭代是人，递归是神。

斐波那契数列的递推实现与递归实现

a = 1
b = 1
N = 9
for i in range(N - 2):
    MID = a + b
    a = b
    b = MID
print(b)


# 递归思想
def fib(N):
    if N == 1 or N == 2:
        return 1
    else:
        return fib(N - 1) + fib(N - 2)


print(fib(9))
"""
fib(9) = fib(8) + fib(7)
fib(8) = fib(7) + fib(6)
fib(7) = fib(6) + fib(5)
fib(6) = fib(5) + fib(4)
fib(5) = fib(4) + fib(3)
fib(4) = fib(3) + fib(2)
fib(3) = fib(2) + fib(1)
"""

如何写出递归思想的代码：

1. 知道最终结果的计算规律。
2. 从需要算的结果向前推。
3. 了解递归结束的条件
4. 学会自己调自己的方式

高阶函数

高阶函数
将一个函数当做另一个函数的参数，叫做高阶函数。函数内嵌套其他函数。
自定义函数相当于是定义了一个数据类型为function的变量

print(max)


def func1():
    print('这是一个函数')


print(func1)
func1()
a = func1
a()


def func2(func):
    print('这是另一个函数')
    func()


func2(func1)

二、Python常用高阶函数：max、min、sorted、map、reduce

max、min：获取容器中最大（最小）的元素

nums = [10, 55, 67, 666, 900]
print(max(nums))

max(容器,key=函数)：按照函数定义的方式获取容器中的最大值。
函数的要求：（1）函数有且仅有一个形参。（2）必有有返回值。

案例：按照数字中个位数的大小取值(找出那个数字的个位数最大)。

nums = [10, 55, 67, 666, 900]


def unitNum(num):
    return num % 10


print(max(nums, key=unitNum))
print(max(nums, key=lambda num: num % 10))
print(min(nums, key=unitNum))

sorted(容器,key=函数)：按照函数指定的形式对容器中元素排序
函数的要求：（1）函数有且仅有一个形参。（2）必有有返回值。

nums = [10, 55, 67, 666, 900]
print(sorted(nums, key=lambda num: num % 10))

reduce:根据传递的容器对容器中每个元素做累计。
reduce(函数,容器,初始值)
函数要求：
a.函数有两个形参。第一个形参开始指向初始值，然后再指向每次累计的结果。第二个形参指向容器中每个元素。
b.必须有返回值。

from functools import reduce

nums = [10, 55, 67, 666, 900]
# 对列表中元素做累乘。
print(reduce(lambda total, num: total * num, nums, 1))

reduce和for循环对比：

reduce性能明显不及for循环，但是如果从代码可读性（优雅的写法）reduce是更好的。

map():根据容器产生一个新的序列
map(函数, 容器1, 容器2, …)
函数要求：
a.函数有N（容器数量）个形参。
b.有返回值。

map函数的结果是一个可迭代对象，可以将这个可迭代对象使用构造器语法转换为列表、元组、集合等容器。

names = ['小明', '小王', '小李']
chinese = [90, 95, 80]
english = [60, 70, 80]
# {'name':'小明','chinese':90,'english':60}
map_iter = map(lambda a, b, c: {'name': a, 'chinese': b, 'english': c}, names, chinese, english)
print(map_iter)
# for i in map_iter:
#     print(i)
print(list(map_iter))