算法之二分法

就是将一个列表或（其他容器）里面的数排列组合，将要找里面的数的时候从中间切分比较留半，然后再重复，最终至找到或者最后切分为空

 1 x = [11, 2, 3, 44, 55, 66, 77, 88, 99, 100, 23, 34, 45, 56, 67]
 2 x.sort()
 3 def bijiao(l):
 4     if len(l) == 0:
 5         print('没有找到这个数。')
 6         return 123
 7 
 8     zhongjian = len(l)//2
 9     if s > l[zhongjian]:
10         l = l[zhongjian+1:]
11         bijiao(l)
12     elif s < l[zhongjian]:
13         l = l[:zhongjian]
14         bijiao(l)
15     else:
16         print('找到了%s'% s)
17 
18 
19 s = int(input('请输入你想要比较的数：'))
20 bijiao(x)

三元表达式

当需求功能是二选一的时候，才用三元表达式

语法结构：

条件成立返回 if 前面的值   if 条件 else 条件不成立返回 else 后面的值

1 is_beautiful = True
2 res = '干饭' if 1 > 2 else '学习' if False else '喜欢' if is_beautiful else '不喜欢'

列表生成式

在列表每个元素后面添加内容

例：

1 lst = ['a', 'b', 'c', 'd']
2 res = [name + '1' for name in lst]
3 print(res)  # ['a1', 'b1', 'c1', 'd1']
4 
5 res1 = [name + '1' for name in lst if name != 'b']
6 print(res1)   # ['a1', 'c1', 'd1'] if后面不能加else

其他生成式

1.字典

将一个列表字典按照索引生成一个字典

1 l = [1, 2, 3]
2 res = {i: j for i, j in enumerate(l)}
3 print(res)   # {0: 1, 1: 2, 2: 3}

2.集合

将一个列表字典按照索引生成一个集合

1 l = [1, 2, 3]
2 res = {i for i in l}
3 print(res)   # {1, 2, 3}

3.元组（pass）

迭代器

匿名函数

 没有名字的函数，就是只有名字和返回值的简化

一般配合采用的内置函数使用

语法格式：

lambda  形参 ：返回值

1 res = lambda x: x + 1
2 print(res(2))   # 3
3 print((lambda x: x + 1)(2))  # 3

常见的内置函数

1.map（）（循环）

底层原理就是将容器里的数一个一个传到函数里

1 def a(x):
2     return x + 1
3 
4 
5 l = [1, 2, 3, 4, 5]
6 
7 res = map(a, l)
8 print(res)  # <map object at 0x000001891B2E29D0> 内存地址
9 print(list(res))  # [2, 3, 4, 5, 6]

2.zip（）（拉链）

将多个元素以对应的索引值，组合成一个元组，以最短的元素为最终长度

1 l = 'hdkcxb'
2 l1 = [4, 5, 7, 8, 's']
3 res = zip(l1, l)
4 print(list(res))  # 需要转变类型，不然会输出内存地址

3.max（）（取最大值）

按照ASCII取元素内最大的值

4.min（）（取最小值）

按照ASCII取元素内最小的值

比较字典的v值返回K：

key = 后面只能加函数

1 l1 = {'a': 4, 'b': 5, 'c': 7, 's': 8}
2 print(min(l1, key=lambda key: l1[key]))

5.filter （过滤）

将后面元素里面的一个一个提取出来，然后满足前面函数条件的取出来重新组合

1 l1 = [11, 33, 44, 5, 66]
2 print(list(filter(lambda key: key > 30, l1)))    # [33, 44, 66]