二分法

二分法查找适用于数据量较大时，但是数据需要先排好顺序。主要思想是：（设查找的数组区间为array[low, high]）
（1）确定该区间的中间位置k
（2）将查找的值T与array[k]比较。若相等，查找成功返回此位置；否则确定新的查找区域，继续二分查找。
区域确定如下：array[k]>T 由数组的有序性可知array[k,k+1,……,high]>T;故新的区间为array[low,……，k-1]；
若array[k]<T 由数组的有序性可知array[k,k-1,……,low]<T;故新的区间为array[k+1,……，high]

应用：查找一个数是否在一个有序的列表中

def search(nums, target):
    mid_index = len(nums)//2
    mid_num = nums[mid_index]
    if not nums:
        print('not exists!')
    if mid_num == target:
        print('find it!')      
    elif mid_num < target:
        nums = nums[mid_index+1:]
        search(nums,target)
    else:
        nums = nums[:mid_index]
        search(nums, target)

nums = [-1,0,3,5,9,12]
target = 9
search(nums,target)

find it!

匿名函数

匿名函数是用关键字lambda定义的函数

# 语法
lambda 参数: 逻辑代码

# 如返回x,y的和
func = lambda x,y:x+y
res = func(1,2)
print(res)

匿名函数使用一次就失效了，一般不单独使用，与max最大值/min最小值/sorted排序/map映射/filter过滤连用

如：返回字典中工资最高的人

# max(iterable,key=func)    将func函数的返回值作为判断的依据，返回iterable中的最大值
saraly_dict = {
    'nick':30000,
    'egon':100000,
    'tank':2000,
    'alex':10212
}

res = max(saraly_dict, key=lambda name:saraly_dict[name])
print(res)

egon

如：返回字典中工资最低的人

# min(iterable,key=func)    将func函数的返回值作为判断的依据，返回iterable中的最小值
saraly_dict = {
    'nick':30000,
    'egon':100000,
    'tank':2000,
    'alex':10212
}

res = min(saraly_dict, key=lambda name:saraly_dict[name])
print(res)

tank

如: 将字典中按工资进行排序

# sorted(iterable,key=func)    将func函数的返回值作为判断的依据，对iterable进行从小到大排序
saraly_dict = {
    'nick':30000,
    'egon':100000,
    'tank':2000,
    'alex':10212
}

res = sorted(saraly_dict, key=lambda name:saraly_dict[name])
res1 = sorted(saraly_dict, key=lambda name:saraly_dict[name], reverse=True) # 加关键字reverse=True则从大到小排序
print(res)
print(res1)

['tank', 'alex', 'nick', 'egon']
['egon', 'nick', 'alex', 'tank']

如: 将列表中的字符都加上'abc'

# map(func,iterable)    将iterable中的每个元素传入到func中执行
lis = ['a', 'b','123']
res = map(lambda x:x+'abc', lis)
print(list(res))

['aabc', 'babc', '123abc']

如: 将列表中以'ed’结尾的元素筛选出来

# filter(func,iterable)    将iterable中的每个元素传入到func中进行筛选
lis = ['sorted', 'teach', 'jumped']
res = filter(lambda x: x.endswith('ed'), lis)
print(list(res))

['sorted', 'jumped']

内置函数

1.bytes() 编码字符，将unicode编码成指定字符

print(bytes('中国',encoding='utf8'))

b'\xe4\xb8\xad\xe5\x9b\xbd'

2.chr()/ord()与ASCII码之间转换

print(chr(97))    # chr将ASCII码转换成对应字符
print(ord('a'))    # ord将字符转换成对应的ASCII码

a
97

3.divmod(x,y) 取整取余

print(divmod(10,3))

(3, 1)

4.enumerate()获取索引和值

res = ['a', 'b','c']
for k,v in enumerate(res):
    print(k,v)

0 a
1 b
2 c

5.eval() 去除数据外的引号，引号里面是什么数据类型就返回什么数据类型

print(eval('[1,2,3]'))

[1, 2, 3]

6.hash() 可哈希不可变，不可哈希可变

print(hash('abc'))    # 若里面是可变数据类型，则会报错

1361908011752591342

7.abs 取绝对值

print(abs(-10))

8.all()若全为真，返回True,否则返回False

print(all(['abc',1]))

True

9.any()只要有一个为真就为True，否则返回False

print(any([0,'ab']))

True

10.bin()/oct()/hex() 转成二进制/八进制/十六进制的形式

print(bin(17))
print(oct(17))
print(hex(17))

0b10001
0o21
0x11

11.dir()列出所有的功能

import time
print(dir(time))

['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'clock', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'perf_counter', 'process_time', 'sleep', 'strftime', 'strptime', 'struct_time', 'time', 'timezone', 'tzname']

12.frozenset()不可变集合

print(frozenset([1,3,2]))

frozenset({1, 2, 3})

13.globals()/locals() 查看全局变量/局部变量

14.pow(x,y,z)

print(pow(3,2,4))    # 返回 x**y%z

15.round() 四舍五入

print(round(3.4))

16.sum()求和

print(sum([1,2,3]))

17.__import__() 通过字符串导入模块

m = __import__('time')
print(m.time())        # 就是导入了time模块，m.time()就是运行time.time()

1559730202.8626022

面向过程编程

按照一定的顺序，顺序中的每一步都可以看成函数，这个函数的输入是上一个函数的输出，这就叫面向过程编程

优点：

逻辑清晰，简单明了
每个函数可以独立的写出来

缺点：

相互之间会有一定的联系，上一步中断了，下一步也就中断了
有一个功能改变了，其他的功能也要改变
可扩展性差

day14-二分法、匿名函数、内置函数以及面向过程编程

二分法

匿名函数

内置函数

面向过程编程

猜你喜欢