1、二分法
算法：是高效解决问题的办法
算法之二分法
需求：有一个按照从小到大顺序排列的数字列表
需要从该数字列表中找到我们想要的那个一个数字
如何做更高效？？？
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、面向过程编程思想
编程思想/范式
面向过程的编程思想：
核心是"过程"二字，过程即流程，指的是做事的步骤：先什么、再什么、后干什么
基于该思想编写程序就好比在设计一条流水线
优点：复杂的问题流程化、进而简单化
缺点：扩展性非常差
面向过程的编程思想应用场景解析：
1）不是所有的软件都需要频繁更迭：比如编写脚本
2）即便是一个软件需要频繁更迭，也不并不代表这个软件所有的组成部分都需要一起更迭
3、匿名函数
3.1 def用于定义有名函数
func=函数的内存地址
def func(x,y):
return x+y
print(func)
3.2 lamdab用于定义匿名函数
print(lambda x,y:x+y)
3.3 调用匿名函数
方式一：
res=(lambda x,y:x+y)(1,2)
print(res)
方式二：
func=lambda x,y:x+y
res=func(1,2)
print(res)
4、匿名函数的应用(内置函数max、sorted等)
salaries={
'siry':3000,
'tom':7000,
'lili':10000,
'jack':2000
}
需求1：找出薪资最高的那个人=》lili
res=max([3,200,11,300,399])
print(res)
res=max(salaries)
print(res)
salaries={
'siry':3000,
'tom':7000,
'lili':10000,
'jack':2000
}
迭代出的内容 比较的值
'siry' 3000
'tom' 7000
'lili' 10000
'jack' 2000
def func(k):
return salaries[k]
========================max的应用
res=max(salaries,key=func) # 返回值=func('siry')
print(res)
res=max(salaries,key=lambda k:salaries[k])
print(res)
========================min的应用
res=min(salaries,key=lambda k:salaries[k])
print(res)
========================sorted排序
salaries={
'siry':3000,
'tom':7000,
'lili':10000,
'jack':2000
}
res=sorted(salaries,key=lambda k:salaries[k],reverse=True)
print(res)
========================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) # 生成器
========================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)
========================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)
5、模块
5.1 什么是模块？
模块就是一系列功能的集合体,分为三大类
I：内置的模块
II：第三方的模块
III：自定义的模块
一个python文件本身就一个模块，文件名m.py，模块名叫m
ps：模块有四种形式
1 使用python编写的.py文件
2 已被编译为共享库或DLL的C或C++扩展
3 把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）
4 使用C编写并链接到python解释器的内置模块
5.2 为何有用模块
I:内置与第三方的模块拿来就用，无需定义，这种拿来主义，可以极大地提升自己的开发效率
II:自定义的模块
可以将程序的各部分功能提取出来放到一模块中为大家共享使用
好处是减少了代码冗余，程序组织结构更加清晰
5.3 如何用模块
y=333
z=444
import foo
首次导入模块会发生3件事
2）执行foo.py
3）产生foo.py的名称空间，将foo.py运行过程中产生的名字都丢到foo的名称空间中
4）在当前文件中产生的有一个名字foo，该名字指向2中产生的名称空间
之后的导入，都是直接引用首次导入产生的foo.py名称空间,不会重复执行代码
import foo
import foo
import foo
import foo
5.2 引用：
print(foo.x)
print(foo.get)
print(foo.change)
强调1：模块名.名字，是指名道姓地问某一个模块要名字对应的值，不会与当前名称空间中的名字发生冲突
x=1111111111111
print(x)
print(foo.x)
强调2：无论是查看还是修改操作的都是模块本身，与调用位置无关
import foo
x=3333333333
foo.get()
foo.change()
print(x)
print(foo.x)
foo.get()
5.3 可以以逗号为分隔符在一行导入多个模块
建议如下所示导入多个模块
import time
import foo
import m
不建议在一行同时导入多个模块
import time,foo,m
5.4 导入模块的规范
I. python内置模块
II. 第三方模块
III. 程序员自定义模块
import time
import sys
import 第三方1
import 第三方2
import 自定义模块1
import 自定义模块2
import 自定义模块3
5.5 import 。。。 as 。。。
import foo as f # f=foo
f.get()
import abcdefgadfadfas
abcdefgadfadfas.f1
abcdefgadfadfas.f2
abcdefgadfadfas.f3
import abcdefgadfadfas as mmm
mmm.f1
mmm.f2
mmm.f3
5.6 模块是第一类对象
import foo
5.7 自定义模块的命名应该采用纯小写+下划线的风格
5.8 可以在函数内导入模块
def func():
import foo