day20 函数收尾+面向过程+模块

目录

• 一、算法（二分法）
• 二、面向过程与函数式
  • 1 编程范式/思想
  • 2 面向过程
  • 3 函数式
  • 3.1 匿名函数与lambda
• 三、模块
  • 1 什么是模块
  • 2 为何要有模块
  • 3 怎么用模块
    • 3.1第一次导入模块会发生3件事情：
    • 3.2引用：
    • 3.3导入模块的规范：

一、算法（二分法）

前引：算法就是高效解决问题的办法

算法之二分法

需求：有一个从小到大顺序排列的列表，如何高效的找到其中一个值

方案一、for循环（遍历效率太低）

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

方案二、二分法

list1 = [1,4,5,6,7,8,9,10,15,48,98,99,789,10000]
def twocut_serch(find_num,fine_list):
    print(fine_list)
    if fine_list==[]:
        print("找不到")
        return
    mid =len(fine_list)//2
    half_num = fine_list[mid]
    if half_num>find_num:
        #查左边
        twocut_serch(find_num,fine_list[:mid])
    elif half_num<find_num:
        twocut_serch(find_num,fine_list[mid+1:])
    else:
        print("找到了")
twocut_serch(2,list1)

二、面向过程与函数式

1 编程范式/思想

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

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

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

2 面向过程

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

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

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

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

3 函数式

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

3.1 匿名函数与lambda

1 .def定义有名函数

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

2 .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)

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

需求：定义一个字典，取出其中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

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

reduce

#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

filter

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

三、模块

1 什么是模块

模块就是一系列功能的集合体，分为三大类

1. 内置模块
2. 第三方模块
3. 自定义模块（一个py文件本身就是一个模块，文件名：m.py，模块名：m）

ps：模块有四种形式
　　1 使用python编写的.py文件

　　2 已被编译为共享库或DLL的C或C++扩展

　　3 把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）

　　4 使用C编写并链接到python解释器的内置模块

2 为何要有模块

原因一、内置和第三方模块拿来就用，无需定义，这种拿来主义，可以极大的提升自己的开发效率

原因二、自定义模块

​ 可以将程序的各部分功能提取到一个模块供大家一起使用

​ 好处是减少了代码冗余

3 怎么用模块

3.1第一次导入模块会发生3件事情：

1. 产生该模块的的名称空间，将foo.py运行过程中产生的名字传给foo的名称空间中
2. 执行foo.py
3. 在当前文件内产生一个名字foo，把名字指向1中的名称空间

ps：重复导入不会重复执行代码

3.2引用：

引用foo内的变量：foo.x

引用foo内的函数：foo.get()

ps：此处对foo.py引用的名字不会和当前名称空间冲突

ps：可以用分隔符同行导入多个模块（不建议使用）

3.3导入模块的规范：

前：python内置模块

中：第三方模块

后：程序员自定义模块