7、Python之与函数有关

7.1函数的递归

什么是函数的递归

是函数嵌套使用的一种特殊方式，具体指的是在调用函数的过程中又直接或间接的调用到本身

递归的本质就是循环

了解：默认调用1000层

直接调用f1

def f1():
    print('from f1')
    f1()
f1()

间接调用函数f1本身:在调用f1的过程中，又调用f2，而在调用f2的过程中又调用f1

def f1():
    print('from f1')
    f2()

def f2():
    print('from f2')
    f1()

f1()

强调：递归不应该无限的调用下去， 就必须让递归调用在满足某个特定条件下终止。

def f1(n):
    if n == 20:
        return 
    print(n)
    n+=1
    f1(n)
f1(0)

递归的两个阶段：回溯和递推

回溯：一层一层的往下调用的过程

递推：满足某种结束条件，结束递归调用，然后一层一层返回

案例：

l=[1,2,[3,[4,[5,[6,[7,[8,[9,10,11,[12,[13,]]]]]]]]]]

def f1(list1):
    for x in list1:
        if type(x) is list:
            # 如果是列表，应该再循环、再判断,即重新运行本身的代码
            f1(x)
        else:
            print(x)

f1(l)

7.2二分法

二分法是一种算法

需求：有一个按照从小到大顺序排列的数字列表需要从该数字列表中找到我们想要的那个一个数字如何做更高效？

此时就需要使用二分法

def binary_search(find_num,列表):
    mid_val=找列表中间的值
    if find_num > mid_val:
        # 接下来的查找应该是在列表的右半部分
        列表=列表切片右半部分
        binary_search(find_num,列表)
    elif find_num < mid_val:
        # 接下来的查找应该是在列表的左半部分
        列表=列表切片左半部分
        binary_search(find_num,列表)
    else:
        print('find it')

案例：

nums=[-3,4,7,10,13,21,43,77,89]
find_num=8
def binary_search(find_num,l):
    print(l)
    if len(l) == 0:
        print('找的值不存在')
        return
    mid_index=len(l) // 2 # 取到的就是中间值

    if find_num > l[mid_index]:
        # 接下来的查找应该是在列表的右半部分
        l=l[mid_index+1:]
        binary_search(find_num,l)
    elif find_num < l[mid_index]:
        # 接下来的查找应该是在列表的左半部分
        l=l[:mid_index]
        binary_search(find_num,l)
    else:
        print('find it')

binary_search(find_num,nums)

注意：如果列表不是有序排列的，可以先用sort方法给列表排序在使用二分法查找

7.3面向过程的编程

什么是面向过程

核心是过程，过程即流程，指的是做事的步骤，先干什么，再干什么，最后干什么，该编程思想就好比设计一条流水线

优点：复杂的问题流程化，进而简单化

缺点：拓展性差

应用场景：

1.不是所有的软件都需要频繁更迭

2.即便是一个软件需要频繁更迭，也不代表这个软件的所有部分都需要一起更迭

7.4匿名函数

函数式编程并非用函数编程这么简单 ， 而是将计算机的运算视为数学意义上的运算。

与数学相关的。

代表语言有：Haskell、Erlang。而python并不是一门函数式编程语言，但是仍为我们提供了很多函数式编程好的特性，如lambda，map，reduce，filter

使用def关键字创建的是有名字的函数，使用lambda关键字创建则是没有名字的函数，即匿名函数

1.定义有名函数

# func=函数的内存地址
def func(x,y):
    return x+y

2.定义匿名函数

lambda x,y:x+y
# print(lambda x,y:x+y)  # 打印匿名函数的内存地址

3.调用匿名函数

# 方式一：内存地址() 极少使用
# res=(lambda x,y:x+y)(1,2)
# print(res)

# 方式二：不使用这种方式
# func=lambda x,y:x+y
# res=func(1,2)

匿名函数在定义出来的那一刻就要去调用

使用场景：临时使用一次的场景中，将匿名函数与其他函数配合使用的场景

应用小案例：

# 应用小案例
sal={
    'a':3000,
    'b2':7000,
    'c03':10000,
    'd004':2000
}
# 需求1：找出薪资最高的那个人
# res=max([1,4,6,2])
# print(res)
# res=max(sal)
# print(res) # 此时的结果是b2，因为，字典的迭代是拿key值来作比较

# 定义有名的函数，但是用完之后就不在使用了，应该定义匿名函数
# def func(k):
#     return sal[k]
# res=max(sal,key=func)
# print(res)

res=max(sal,key=lambda k:sal[k])
print(res)

# sorted()排序
res=sorted(sal,key=lambda k:sal[k])
print(res)