二分法
二分法思路
1.二分法的使用前提条件：列表中得数字必须要有序
2.将对象整除2分成两部分
3.将目标数值与分割后的对象做比较来确定目标数值在哪一部分
4.继续重复这两个步骤直至找到目标数值
- 例
# 判断此表中是否有20这个数
l = [1, 22, 44, 10, 3, 45, 66, 88, 101, 20, 30, 40, 12]
1.传统做法
for i in l:
if i == 20:
print('存在')
break >>>存在
2. 二分法实现
l = [1, 22, 44, 10, 3, 45, 66, 88, 101, 20, 30, 40, 12]
l.sort()#进行排序
print(l)#[1, 3, 10, 12, 20, 22, 30, 40, 44, 45, 66, 88, 101]
target_num = 20#定义一个目标20
def my_half(target_num, l):#定义两个参数，target_num为查找的目标数字，l为查找的列表
if len(l) == 0:
print('不好依稀，没找到')
return
#获取中间索引值
middle_index = len(l) // 2 #6，使用整除目的在于兼容长度为奇数情况
if target_num > l[middle_index]:#如果20大于中间索引数据值则说明目标值在右侧
l_right=l[middle_index+1 :] #[7: ]中间索引值+1，从索引7开始一直到末尾获取值
print(l_right)
my_half(target_num, l_right)
elif target_num < l[middle_index]:#如果20小于中间数字，说明目标值在左侧
l_left=l[ :middle_index]#[ :6]从开始到6
print(l_left)
my_half(target_num, l_left)
else:
print('找到了')
my_half(target_num, l)
>>> [1, 3, 10, 12, 20, 22, 30, 40, 44, 45, 66, 88, 101]
[1, 3, 10, 12, 20, 22]
[20, 22]
[20]
找到了
三元表达式
三元表达式是一种简化if-else语句的表达式形式，它可以用一个简单的语句来代替复杂的if-else结构
- 例1
比较大小：
1.传统做法：
def my_max(a, b):
if a > b:
return a
else:
return b
2.三元表达式
def my_max(a, b):
return a if a > b else b
print(my_max(1, 10))
a = 1
b = 10
>>>10
- 例2
a = 1
b = 10
c = 10
d = 20
res=a if a > b else (c if c > d else d)
print(res)>>>20
'''不推荐使用三元表达式嵌套使用'''
- 例3
is_beautiful=True
res = '漂亮' if is_beautiful else '不漂亮'
print(res)>>>漂亮
cmd = input('请选择是否输入:(y/n)')
res='继续' if cmd == 'y' else '不继续'
print(res)
生成式
列表生成式
语法res = [变量 for 变量 in 可迭代对象 if 条件 ]
元素和for循环不能省略，if语句根据实际情况可以省略
- 例1
name_list = ['kevin', 'jack', 'ly', 'tony']
# 需求是：把列表中得名字都添加一个后缀:_NB
1. 传统做法：
new_list = []#存储拼接后的新列表
for name in name_list:
res='%s_NB' % name#或者name+"_NB"
new_list.append(res)#new_list拼接res
print(new_list)
>>>['kevin_NB', 'jack_NB', 'ly_NB', 'tony_NB']
2. 使用列表生成式：
name_list = ['kevin', 'jack', 'ly', 'tony']
#res = ['%s_NB' % name for name in name_list]
res = [name+'_NB' for name in name_list]#原理是先执行for循环
print(res)
>>>['kevin_NB', 'jack_NB', 'ly_NB', 'tony_NB']
- 例2
name_list = ['kevin', 'jack', 'ly', 'tony']
#需求：除了jack不加，其他都加，如果是jack直接去掉
1传统做法：
name_list = ['kevin', 'jack', 'ly', 'tony']
new_list = []
for name in name_list:
if name == 'jack':
continue
else:
res = '%s_NB' % name
new_list.append(res)
print(new_list)
>>>['kevin_NB', 'ly_NB', 'tony_NB']
2列表生成式的使用
name_list = ['kevin', 'jack', 'ly', 'tony']
res = ['%s_NB' % name for name in name_list if name != 'jack']#
>>>['kevin_NB', 'ly_NB', 'tony_NB']
#首先检查"name_list"中的每个元素是否等于字符串"jack"。如果是，则跳过该元素，继续循环处理下一个元素；否则，将当前元素与后缀"_nb"连接起来，并将结果添加到新列表"res"中。
- 例3
#jack换成666
name_list = ['kevin', 'jack', 'ly', 'tony']
res = ['%s_NB' % name if name != 'jack' else '666' for name in name_list ]
print(res)#三元表达式+for
>>>['kevin_NB', '666', 'ly_NB', 'tony_NB']
字典生成式
- 例1
#要求以字典形式呈现
l1 = ['name', 'age', 'salary']
l2 = ['kevin', 18, 3000]
new_dict = {}
for i in range(len(l1)):#i为遍历元素0、1、2
new_dict[l1[i]] = l2[i]#l1、l2通过i索引 给字典添加值(key不存在就增加值)
print(new_dict)
>>> {'name': 'kevin', 'age': 18, 'salary': 3000}
- enumerate用法
enumerate：用于将一个可遍历的对象（如列表、元组或字符串）组合为一个索引序列，可以解压赋值出来两个值（索引，元素），enumerate(对象，start) 参数start:控制的是起始位置，默认不写是从0开始
l1 = ['name', 'age', 'salary']
l2 = ['kevin', 18, 3000]
for i, l1 in enumerate(l1,start=1):#参数start不写从0开始
print(i ,l1)#i是索引值，j是具体的元素值
>>>1 name
2 age
3 salary
# 字典生成式
l1 = ['name', 'age', 'salary']
res={i:l1 for i,l1 in enumerate(l1)}
print(res)
>>>{0: 'name', 1: 'age', 2: 'salary'}
集合生成式
l1 = ['name', 'age', 'salary']
res = {i for i in l1}
print(res)
>>>{'name', 'salary', 'age'}
元组生成式(生成器）
l1 = ['name', 'age', 'salary']
res = (i for i in l1)
print(res)
>>><generator object <genexpr> at 0x00000249F870CC10>
匿名函数
匿名函数关键字lambda
是没有名称的函数，它通常在定义时直接作为参数传递给其他函数或者作为返回值返回 eg:lambda x: x**2
语法格式：lambda 形参:返回值
- 例1
res=lambda x:x+1
print(res(1))#2
- 例2
print((lambda x: x +1)(2))#3
分析：此代码可拆分为
res=lambda x: x +1
print(res(2))
调用时将实参2传给x作为lambda函数的输入，得到返回值2+1 即因此输出结果为3
- 例3
def index(x):
return x ** 2
print(index(2))#4
res=lambda x:x**2
print(res(2))#4
内置函数
- map
它有两个参数：函数及可迭代对象，将传入的函数作用于可迭代对象中的每个元素；使用 map() 函数将可迭代对象的每个元素都传递给函数进行处理并返回一个新的可迭代对象
l = [1,2,3,4,5,6,7,8,9]求列表中数字的平方
def index(x):#x=1\x=2\x=3...
return x**2
res=list(map(index, l)) # map(index,l)底层原理for循环l,将元素1作为参数传给index得到结果1的平方值，即1，以此类推
#直接打印map打印不出来需要转列表才能打印
print(res) >>>[1, 4, 9, 16, 25, 36, 49, 64, 81]
结合匿名函数
l = [1,2,3,4,5,6,7,8,9]
res=list(map(lambda x:x**2, l))
print(res) >>>[1, 4, 9, 16, 25, 36, 49, 64, 81]
- zip
可有多个参数，参数为可迭代对象。将多个可迭代对象组装成元组形式，当传入的可迭代对象长度不同时，zip() 函数会以最短的序列为准进行组装
#拼接列表
# 传统做法：
l=[11,22,33]
ll1 =['name','age','hobby']
lst =[]#定义空列表存放新元组
for i in range(len(ll1)):
lst.append((ll1[i],l[i]))#通过列表索引取值得到元组的元素 再将元组添加到列表中
print(lst)
>>>[('name', 11), ('age', 22), ('hobby', 33)]
# zip做法：
l=[11,22,33]
ll1 =['name','age','hobby']
res =list(zip(l,ll1))#需要转成列表才能打印出结果
print(res)
>>>[('name', 11), ('age', 22), ('hobby', 33)]
l = [11, 22, 33, 44, 55, 66]
ll1 = ['name', 'age', 'hobby', 'aaa', 'b', 'ccc', 'ddd', 'fff']
ll2 = ['nam2e', 'age1', 'hobby1', 'aaa1', 'b', 'ccc', 'ddd', 'fff']
ll3 = ['name1', 'age2', 'hobby2', 'aaa2', ]
res =list(zip(ll3,ll2,ll1,l))
print(res)
>>>[('name1', 'nam2e', 'name', 11), ('age2', 'age1', 'age', 22), ('hobby2', 'hobby1', 'hobby', 33), ('aaa2', 'aaa1', 'aaa', 44)]
#当拉链多个数据时，按照列表长度最短的返回成列表
- max 最大值
求出列表中最大值
l = [1, 2, 10, 30, 5, 6, 7, 8]
print(max(l))
>>>30
- min 最小值
求出列表最小值
l = [1, 2, 10, 30, 5, 6, 7, 8]
print(min(l))
>>>1
- 针对max min拓展：
如果是字典则根据ascii表比较的是k值，A-Z:65-90， a:97
d = {
'Aevin': 10000,
'zack': 2000,
'zony': 30000,
'Fank': 5000000000
}
print(max(d))
>>>zony
#要求返回最大数值的名字
d = {
'Aevin': 10000,
'zack': 2000,
'zony': 30000,
'Fank': 5000000000
}
def index(key):
return d[key]
print(max(d,key=index))
>>>Fank
'''max\min 如果传了key参数，就是返回什么值就按照什么值比较'''
用匿名函数表达：
d = {
'Aevin': 10000,
'zack': 2000,
'zony': 30000,
'Fank': 5000000000
}
print(max(d, key=lambda key:d[key]))
>>>Fank
- filter
用于过滤序列中元素，参数有两个，一个函数 一个可迭代对象，函数作为过滤条件
筛选列表大于20的数字
传统做法：
l = [1, 10, 20, 55, 66, 77]
l1=[] # 定义一个空列表
for i in l:
if i >20:
l1.append(i)
print(l1)
>>>[55, 66, 77]
匿名函数表达：
l = [1, 10, 20, 55, 66, 77]
def index(x):
return x > 20
res=list(filter(lambda x:x>20,l))
print(res)
>>> [55, 66, 77]