python学习的第十六天匿名函数、函数的递归、面向过程编程

一、匿名函数

1、定义：没有名字的函数，特点是只能在定义时候使用一次

2、为何要用匿名函数

强调：匿名函数的定义就相当于只产生一个变量在值,而没有绑定任何名字,所以会在定义完之后就被回收,无法重复使用,只能在定义时使用一次

应用:当某一个功能仅使用一次就没有再重复使用的必要了,就应该定义成匿名函

3、如何用匿名函数：

格式：lambda x,y:x+y             将参数x和y相加

（1）max:比较后取最大值

salaries = {
    'egon': 3000,
    'alex': 100000000,
    'wupeiqi': 10000,
    'yuanhao': 2000
}

要求拿到数字最大的那个人的名字

如果要直接max，只能比较字符串，还需要加个key

ps:key=函数的内存地址: 作用是控制max函数的比较的值   key=函数    不影响最终结果的数据类型

print(max(salaries,key=lambda k:salaries[k]))                         alex

原理：

 1. key将可迭代对象salaries变成迭代器对象iter_obj
 2. 并用next(iter_obj)得到一个人名,然后将该人名当作参数传给key指定的函数, 然后调用函数将函数的返回值当作比较依据
3. 比较大小,取出最大值对应的人名

（2）sorted:排序    默认是从小到大

nums=[10,-1,11,9,23]

print(sorted(nums)                       [-1, 9, 10, 11, 23]

 salaries={
#     'egon':3000,
#     'alex':100000000,
#     'wupeiqi':10000,
#     'yuanhao':2000
# }

按数字的大小将名字排序

print(sorted(salaries,key=lambda x:salaries[x])

如果从大到小的顺序排列

print(sorted(salaries,key=lambda x:salaries[x],reverse=True))

（3）map：映射

names = ['alex', 'wupeiqi', 'yuanhao', 'kevin', 'hu老师']

将名字后面填个'dsb'，有三种方式

# 方式一:手动实现
# new_names=[]
# for name in names:
#     new_names.append(name+'dsb')
# print(new_names)

# 方式二:列表生成式
new_names = [name + 'dsb' for name in names]
# print(new_names)

# 方式三:map+匿名函数
res = map(lambda x: x + 'dsb', names)
# print(res)
# print(list(res))

（4）reduce:数字相加，字符串拼接

1到100的求和

# 方式一:手动实现
# res=0
# for i in range(101):
#     res+=i
# print(res)

# 方式二:列表生成式
# print(sum([i for i in range(101)]))

# 方式三:reduce+匿名函数   python3需要引用模块
from functools import reduce
# print(reduce(lambda x,y:x+y,[i for i in range(101)],100))              5150     
# print(reduce(lambda x,y:x+y,[i for i in range(101)]))                 5050
# print(reduce(lambda x,y:x+y,['h','e','l','l','o'],'----------'))

----------hello

（5）filter:过滤后取的值，函数相当于筛选的条件

# 方式一:手动实现
new_names=[]
for name in names:
    if name.endswith('sb'):
        new_names.append(name)
print(new_names)

# 方式二:列表生成式
new_names=[name for name in names if name.endswith('sb')]
print(new_names)

# 方式三:filter+匿名函数
res=filter(lambda name:name.endswith('sb'),names)
print(res)
print(list(res))

二、函数递归

1. 什么是函数递归
函数的递归调用是函数嵌套调用的一种特殊形式,
特殊在调用一个函数的过程中又直接或者间接地调用了该函数本身

递归本质就是一个循环的过程,
但是递归必须满足两个原则:
（1）. 每进入下一层递归,问题的规模必须有所减少
（2）. 递归必须有一个明确的结束条件或者说有一个明确的进入下一层递归的条件
并且递归有两个明确的阶段
（1）. 回溯: 一层一层地递归调用下去
（2）. 递推: 再某一层结束掉递归,然后一层一层返回

2, 为何要用递归:
在某些情况下,基于递归来使用重复的过程比while循环更加简单

3, 如何用

# 递归举例:
# age(5)=age(4)+2
# age(4)=age(3)+2
# age(3)=age(2)+2
# age(2)=age(1)+2
# age(1)=18

# age(n)=age(n-1)+2 # n>1
# age(1)=18         # n=1
# def age(n):
#     if n == 1:
#         return 18
#     return age(n-1)+2
#
# res=age(5)
# print(res)

list1=[1,[2,[3,[4,[5,[6,[7,[8,[9,]]]]]]]]]      取出列表里的所有数字

# list1=[1,[2,[3,[4,[5,[6,[7,[8,[9,]]]]]]]]]
# def func(l):
#     for item in l:
#         if type(item) is list:
#             # 将item当作一个新列表传给功能本身
#             func(item)
#         else:
#             print(item)
# func(list1)

4、二分法：二分法是算法的一种,算法是如何高效地解决问题的思路

# nums=[1,13,15,23,27,31,33,57,73,81,93,94,97,101] # 从小到大排列的数字列表

如何在列表中找值（in排除）

正常操作：

 for num in nums:
#     if 58 == num:
#         print('find it')
#         break
# else:
#     print('not exists')

用二分法的思路：

def binary_search(find_num,nums):
    print(nums)
    if len(nums) == 0:
        print('not exists')
        return

    # 功能
    mid_index = len(nums) // 2
    if find_num > nums[mid_index]:
        # in the right
        nums=nums[mid_index+1:]
        # 重新运行功能,传入新列表
        binary_search(find_num,nums)
    elif find_num < nums[mid_index]:
        # in the left
        nums=nums[:mid_index]
        # 重新运行功能,传入新列表
        binary_search(find_num,nums)
    else:
        print('find it')

# binary_search(97,nums)
binary_search(95,nums)

三，面向过程编程

面向过程编程:
核心是过程二字,过程指的是解决问题的步骤,即先干什么再干什么后干什么...
基于该思想编写程序脑子里应该始终思考过程二字,就好比在设计一条流水线,是一种
机械式的思维方式

优点:复杂的问题的流程化,进而简单化
缺点:扩展性差