day20：面向过程与函数式

一、二分法

算法：是高效解决问题的办法
算法之二分法

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

1.1【方案一】：整体遍历效率太低

for num in nums:
    if num == find_num:
        print('find it')
        break

1.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')

在这里插入图片描述

1.3【方案三】：二分法真实案例

nums=[-3,4,10,7,8,1,2,11,13,21,43,77,89]
nums = sorted(nums)

def binary_search(find_num,l):
    print(l)
    if len(l) == 0:
        print('找的值不存在')
        return

    mid_index = len(l) // 2
    print(f'中间值：{l[mid_index]}')

    if find_num > l[mid_index]:
        l = l[mid_index+1:]
        binary_search(find_num, l)
    elif find_num < l[mid_index]:
        l = l[0:mid_index]
        binary_search(find_num,l)

    else:
        print(f'找到了')

    return mid_index

binary_search(2,nums)

二、面向过程

面向过程：也叫做编程思想/范式

2.1 面向过程的编程思想：

核心是"过程"二字，过程即流程，指的是做事的步骤：先什么、再什么、后干什么
基于该思想编写程序就好比在设计一条流水线。详细的，若程序一开始是要着手解决一个大的问题，按照过程式的思路就是把这个大的问题分解成很多个小问题或子过程去实现，然后依次调用即可，这极大地降低了程序的复杂度。

2.2 优缺点

优点：复杂的问题流程化、进而简单化
缺点：扩展性非常差

2.3 面向过程的编程思想应用场景解析：

1、不是所有的软件都需要频繁更迭：比如编写脚本
2、即便是一个软件需要频繁更迭，也不并不代表这个软件所有的组成部分都需要一起更迭

2.4 应用场景

面向过程的程序设计一般用于那些功能一旦实现之后就很少需要改变的场景， 如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程去实现是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护， 那还是用面向对象最为方便。

三、函数式

3.1 匿名函数与lambda

①def用于定义有名函数，def后接函数名
【注】：func的函数名值指向内存地址

# func=函数的内存地址
def func(x,y):
    return x+y
print(func) # 输出：<function func at 0x7fb01465bd08>

②lamdab用于定义匿名函数，即没有函数名
【注】：lambda函数式的函数名为“<”lambda“>”，后面加括号()和参数，即可调用lambda匿名函数

print(lambda x,y:x+y)   # 输出：<function <lambda> at 0x7fc3bb05ad08>

3.2 调用匿名函数

方式一：

res=(lambda x,y:x+y)(1,2)
print(res)

方式二：

func=lambda x,y:x+y
res=func(1,2)
print(res)

上述两种方法均没有使用到lambda函数的精髓，不要这样用多此一举。

3.3 匿名函数lambda使用场景

【重点】：匿名用于临时调用一次的场景：更多的是将匿名与其他函数配合使用

'''案例1：max的使用方法'''

salaries={
    'siry':3000,
    'tom':7000,
    'lili':10000,
    'jack':2000
}
# 需求1：找出薪资最高的那个人=》lili

# res=max([3,200,11,300,399])
# print(res)  #  399

res=max(salaries)  # max(iterable, *[, default=obj, key=func])  可以看出max必须先传入一个迭代器,这里传入的是字典salaries,
                   # 字典迭代器得到的是key值,随后比较key的大小,即名字中最大的那个
print(res)

'''案例2：lambda匿名函数'''
# 求薪资最高的那个人名

salaries={
    'siry':3000,
    'tom':7000,
    'lili':10000,
    'jack':2000
}
# 迭代出的内容    需比较的值
# 'siry'         3000
# 'tom'          7000
# 'lili'         10000
# 'jack'         2000

'''2.1 常规定义函数的操作'''
def func(k):
    return salaries[k]

res = max(salaries, key=func) # 每次获取到迭代器salaries的名字时，将名字作为参数传给func，得到需要比较的值
print(res)

print('======================================')

'''我们来分析一下:我们时临时用一下获取结果，后面不会在使用了。看上面定义的有名函数func的方法，
   定义完使用完后不会被回收，引用计数不会清零，而使用匿名函数的方法使用完后立即释放，
   所以匿名函数常用于临时使用一次的场景'''
   
'''2.2 lambda匿名函数用法'''
#解释下max这里的用法，先传入一个可迭代的对象，每次next()会取一个值，由于这里的可迭代对象是字典，所以取出的是名字，key=lambda ...是匿名函数，即无函数名的函数，使用lambda时需要给lambda传入一个变量，这里的变量是x，用来接收salaries字典迭代后获取的名字，每次获取到名字后传给lambda函数进行调用，这里是执行salaries[x]，获取到了名字对应的薪资，然后将返回值传给max，next()获取4次后，max里面得到了4个人的薪资，再比较薪资大小。
res1 = max(salaries, key= lambda x:salaries[x]) 
print(res1)


'''2.3 如何取得工资最低的人名'''
res2 = min(salaries, key=lambda k:salaries[k])
print(res2) # jack

3.4 sorted排序

案例：以字典为例

salaries={
    'siry':3000,
    'tom':7000,
    'lili':10000,
    'jack':2000
}

print(sorted(salaries)) # 输出：['jack', 'lili', 'siry', 'tom']，根据ASCALL码比较首字母，从小到大排序
'''根据工资，从低到高排序，输出名字'''
res=sorted(salaries,key=lambda k:salaries[k],reverse=True)
print(res)  # ['lili', 'tom', 'siry', 'jack']
'''根据工资，从高到低排序，输出名字'''
res1=sorted(salaries,key=lambda k:salaries[k],reverse=False)
print(res1) # ['jack', 'siry', 'tom', 'lili']

3.5 map的应用(了解)

'''案例：map的应用'''

# l=['alex','lxx','wxx','薛贤妻']
# new_l=(name+'_dsb' for name in l)
# print(new_l)

# res=map(lambda name:name+'_dsb',l)
# print(res) # 生成器

3.6 filter的应用（了解）

'''案例：filter的应用'''

# l=['alex_sb','lxx_sb','wxx','薛贤妻']
# res=(name for name in l if name.endswith('sb'))
# print(res)

# res=filter(lambda name:name.endswith('sb'),l)
# print(res)

3.7 reduce的应用(了解)

'''案例：reduce的应用'''

from functools import reduce
res=reduce(lambda x,y:x+y,[1,2,3],10) # 16
print(res)

res=reduce(lambda x,y:x+y,['a','b','c']) # 'a','b'
print(res)