目录
1.算法之二分法
需求：
有一个按照从小到大顺序排列的数字列表
需要从该数字列表中找到我们想要的那一个数字
如何做更高效？
方案一 效率低
nums=[-3,4,5,7,10,13,21,45]
find_num=13
while True:
if find_num==13:
print('find num')
break
方案二:二分法
nums = [-3, 4, 5, 7, 10, 13, 21, 45]
def f1(find_num, list):
print(list)
mid_val = len(list) // 2
if find_num > list[mid_val]:
list = list[mid_val + 1:]
f1(find_num, list)
elif find_num < list[mid_val]:
list = list[:mid_val]
f1(find_num, list)
else:
print('find num')
f1(13, nums)
2.面向过程的编程思想
核心：'过程二字'，过程即流程，指的事做事的步骤：先做什么，再做什么，后做什么
基于该思想编写程序就好比设计一条流水线
优点:复杂的问题流程化，进而简单化
缺点：扩展性差
面向过程的编程思想应用场景解析
1.不是所有软件都需要频繁迭代更迭：比如编写脚本
2.即便是一个软件需要频繁更迭，也并不代表这个软件所有的组成部分都需要更迭
函数式
函数式编程是将计算机的运算视为数学意义上的运算，比起面向过程，函数式更加注重的是执行结果而非执行的过程，代表语言有：Haskell、Erlang。
函数式不符合python设计哲学，但也提供了很多函数式编程好的特性，如lambda，map，reduce，filter
1.def用于定义有名函数
func=函数的内存地址
def func(x,y): return x+y
2.匿名函数
lambda用于定义匿名函数
lambda x,y:x+y
3.调用匿名函数
方式一
res=(lambda x,y:x+y)(1,2)
print(res)
方式二
res=lambda x,y:x+y
print(res(1,2))
4.匿名函数用于临时调用一次的场景：更多的是匿名函数与其他函数配合使用
salaries={
'siry':3000,
'tom':7000,
'lili':10000,
'jack':2000
}
def func(k):
return salaries[k]
需求1：找出薪资最高的人
res=max(salaries,key=func)
res=max(salaries,key=lambda k:salaries[k])
print(res)
res=min(salaries,key=lambda k:salaries[k])
print(res)
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)
3.内置函数
了解
print(abs(-1))
print(all([1,'aaa','1']))
print(all([]))
print(any([0,None,1]))
print(any([]))
print(bin(11))
print(oct(11))
print(hex(11))
print(bool(''))
print(chr(65))
print(ord('A'))
print(callable(Foo)) # 是否能被调用
不可变集合
s=frozenset({1,2,3})
hash(不可变类型)
help() # 查看文档注释
print(pow(10,2,3)) #10的平方再取余数
print(round(1.5))
print(round(1.4)) #四舍五入
repr() # 交互式环境下，不打印默认调用，例如：'x' >>> 'x'
s=slice(1,4,2)
l1=['a','b','c','d','e']
l2=['aaa','bbb','ccc','ddd',444]
print(l1[142]) # l1[s]
print(l2[142]) # l2[s]
=================》掌握
v1='hello'
v2=[111,222,333,444,5555,6666]
res=zip(v1,v2)
print(list(res))
=================》掌握
print(divmod(10000,33)) # 得到商和余数
=================》掌握
class Foo
pass
obj=Foo()
obj.xxx=1111
print(dir(obj)) # obj.哪些属性
=================》掌握
for i,v in enumerate(['a','b','c']) print(i,v)
=================》掌握
res=eval('{a1}') # 执行字符串中的表达式
print(res,type(res))
=================》掌握
class Foo
pass
obj=Foo()
print(isinstance(obj,Foo))
print(isinstance([],list)) # 类型判断推荐使用isinstance
print(type([]) is list) # 不推荐使用
issubclass() # 判断是否是子类
=================》掌握
import 'time' # 错误
time=__import__('time')
time.sleep(3)
4.什么是模块
模块就是一系列功能的集合体，分为三大类
Ⅰ.内置的模块
Ⅱ.第三方的模块
Ⅲ.自定义的模块：一个python文件就是一个模块，文件名m.py，模块名m
ps：模块有四种形式
a.使用python编写的.py文件
b.已被编译为共享库或DLL的C或C + +扩展
c.把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）
d.使用C编写并链接到python解释器的内置模块
2.为何要有模块
I:内置与第三的模块拿来就用，无需定义，这种拿来主义，可以极大地提升自己的开发效率
II:自定义的模块
可以将程序的各部分功能提取出来放到一模块中为大家共享使用
好处是减少了代码冗余，程序组织结构更加清晰
3.如何用模块
import foo
1.首次导入模块会发生3件事
1)、执行foo.py
2)、产生foo.py的名称空间，将foo.py运行过程中产生的名字都丢到foo的名称空间中
3)、在当前文件中产生的有一个名字foo，该名字指向2中产生的名称空间
之后的导入，都是直接引用首次导入产生的foo.py名称空间,不会重复执行代码
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()
3、可以以逗号为分隔符在一行导入多个模块
建议如下所示导入多个模块
import time
import foo
import m
不建议在一行同时导入多个模块
import time,foo,m
4、导入模块的规范
I. python内置模块
II. 第三方模块
III. 程序员自定义模块
import time
import sys
import 第三方1
import 第三方2
import 自定义模块1
import 自定义模块2
import 自定义模块3
5、import 。。。 as 。。。
import foo as f # f=foo
f.get()
6、模块是第一类对象
7、自定义模块的命名应该采用纯小写+下划线的风格
8、可以在函数内导入模块
def func():
import foo
返回