二分法/面向思想/匿名函数

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

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

nums=[-3,4,7,10,13,21,43,77,89]
find_num=10

nums=[-3,4,13,10,-2,7,89]
nums.sort()
print(nums)

　　

方案一：整体遍历效率太低
for num in nums:
    if num == find_num:
        print('find it')
        break

方案二：二分法
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)

　　

 

面向过程/对象

 编程范式/思想

在我们写代码的时候我们从何入手，不同的思想会让我们有不同的着重点。

面向过程和函数式便是众多编程思想中的两个流派

强调：不同的范式应用于不同场景他们本身没有好坏之分

2 面向过程

面向过程的重点就是过程，做一件事要先做什么，后做什么，类似于流水线

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

缺点：程序的可扩展性差，因为一套流程通常是死的，我们通常不能用a流程去完成b事物

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

函数式

函数式编程并非用函数编程这么简单，而是将计算机的运算视为数学意义上的运算，比起面向过程，函数式更加注重的是执行结果而非执行的过程，代表语言有：Haskell、Erlang。而python并不是一门函数式编程语言，但是仍为我们提供了很多函数式编程好的特性，如lambda，map，reduce，filter

匿名函数与lambda

def定义有名函数

#func是存放函数的内存地址的名字
def func(x):
   	return x 

　　

lambda

#匿名函数定义
#lambda 参数1，参数2...:返回值

lambda x,y:x+y

def func(x,y):
    return x+y

#函数调用
res = (lambda x,y:x+y)(1,2)
#匿名函数由于没有名字的特性，所以如果不绑定名字的话，在函数定义结束后就被当做垃圾回收了，
#所以通常情况下都是直接在定义时执行函数，通常用做其他函数连用

func(1,2)

　　

匿名函数和内置函数的应用

需求：定义一个字典，取出其中value最大的key和value最小的key

dict1 = {"hz":100,"lxt":1234,"hzxc":101}
#max,min的工作原理都是迭代器
#取出其中value最大的key
#max的第一个值(需要找最大值的可迭代对象，如果是字典，找最大key)
res = max(dict1 key=lambda k:dict1[k])

#取出其中value最大的key
res = min(dict1 key=lambda k:dict1[k])

#补充 sorted排序
sorted(dict1)#默认给key排序，得到一个列表

　　

map,reduce,filter(了解知识)

#map = 映射
#把一个可迭代对象的每一个值拿出来当做函数的参数运行一次
l = [1,2,3,4]
res = map(lambda x:x**2,l)
#res是一个迭代器，它里面存放着l的每一个元素的平方


#reduce函数可以接收三个参数，一个是函数，第二个是可迭代对象，第三个是初始值
from functools import  reduce
l = [1,2,3,4]
res = reduce(lambda x,y:x+y,l)
print(res)
>>>10
#1 没有初始值，reduce函数会先迭代一次array得到的值作为初始值，作为第一个值数传给x，
#然后继续迭代一次l得到的值作为第二个值传给y，运算的结果为3

#2 将上一次reduce运算的结果作为第一个值传给x，然后迭代一次l得到的结果作为第二个值传给y，
#依次类推，知道迭代完l的所有元素，得到最终的结果10



#过滤列表l
l = [1,2,3,4]
res = filter(lambda x:x>3,l)
#filter会迭代列表l把得到的值传给匿名函数，如果得到结果为真，则过滤出该元素，得到一个迭代器
res >>> 4