今日主要内容:
1. lambda 匿名函数
lambda 参数: 返回值
-------------------------------------
def square(x):
return x**2 ret = square
print(ret)
-------------------------------------
zrf = lambda x : x**2 #匿名函数 lambda 参数: 返回值
print(zrf)
ret = zrf(10)
print(ret) -------------------------------------
#给函数传递两个参数a,b 返回a+b的结果
s = lambda a, b: a + b ret = s(3, 7)
print(ret) ----------------难题---------------------
def add(a, b):
return a + b
def test():
for r_i in range(4):
yield r_i
g = test()
for n in [3, 8]:
g = (add(n, i) for i in g) #在未被调用时只记录公式,被调用时套入公式, g = 8
n = 6
print(list(g))
def num():
return [lambda x: x + i for i in range(4)] #闭包. i在循环中没被调用,只记录公式,当函数调用时,i=3,x+i 共循环4次,所有公式中i都等于3 print([i(2) for i in num()])
2. sorted 排序
sorted(Iterable, key=None, reverse=False) #可迭代对象后面两个默认值
sorted(可迭代对象,key=函数,是否倒序)
sorted流程:把可迭代对象的每一个元素传递给函数,函数返回一个数字,根据数字进行排序
-------------------------------------
lst = [1, 2, 22. 5, 10, 92, 88]
lst2 = sorted(lst) #排序功能
lst3 = sorted(lst, reverse=True)
print(lst2)
-------------------------------------
lst = ['王昭君', '李白', '司马懿', '大乔', '诸葛亮', '周瑜']
def func(name):
return len(name) l1 = sorted(lst, key=func)
print(l1) a = lambda name: len(name)
l1 = sorted(lst, key=a)
print(l1) l1 = sorted(lst,key=lambda name: len(name))
print(l1)
-------------------------------------
lst = [{"id": 1, "name": 'alex', "age": 18},
{"id": 2, "name": 'wusir', "age": 16},
{"id": 3, "name": 'taibai', "age": 17}]
# 按照年龄对学⽣信息进⾏排序
# def func(info):
return info["age"] # l1 = sorted(lst, key=func)
# print(l1)
l1 = sorted(lst, key= lambda info: info['age'])
print(l1)
-------------------------------------
#按照姓名首字母排序
lst = [{"id": 1, "name": 'alex', "age": 18},
{"id": 2, "name": 'wusir', "age": 16},
{"id": 3, "name": 'taibai', "age": 17}] l2 = sorted(lst, key=lambda dic: ascii(dic['name'][0]))
print(l2) l3 = sorted(lst, key=lambda dic: ord(dic['name'][0]))
print(l3) -------------------------------------
3. filter 筛选
filter(函数,可迭代对象)
执行流程:
把可迭代对象中的每一个元素拿出来, 放到func中运行.返回True/False. 根据返回的True和False来决定这个数据是否保留
#保留列表中大于18的数
lst = [22, 25, 12, 16, 28]
f = filter(lambda age: age > 18, lst)
for el in f:
print(el)
print(list(f))
print(sorted(f)) #对结果排序 #筛选年龄大于18且为偶数的年龄
lst = [23, 28, 16, 17, 22, 24]
f = filter(lambda age: age > 18 and age % 2 == 0, lst) # f是可迭代对象
print(list(f))
f2 = filter(lambda age: age % 2 == 0, filter(lambda age: age>18, lst))
print(list(f2))
-------------------------------------
#筛选年龄大于18且为偶数,并排序
lst = [22, 25, 12, 16, 28]
print(list(sorted(filter(lambda age: age % 2 == 0,filter(lambda age: age > 18, lst)))))
4. map 映射
map(函数,可迭代对象) #结构和filter一样,但可以返回值
执行流程:
把可迭代对象中的每一个元素拿出来, 放到func中运行.返回数据就是结果
lst = [2, 3, 7]
m = map(lambda x: x**2, lst)
print(list(m))
--------------------------------
#求lst1 和lst2中相同索引的数字和组成的列表
lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 3, 4, 5, 6]
print(list(map(lambda x, y: x + y,lst1, lst2))) 5. 递归(难点)
优点:简单易写,用于遍历树形结构
缺点:资源消耗大,效率低,需要不停调用函数,开辟空间 自己调用自己
递归的入口
递归的出口: return
递归的循环条件：动
循环树形结构: def func():
print('你好啊')
func() #递归的入口 func() #调用函数
-----------------------------------
# 用递归实现1-100:
def func(index):
print(index)
if index == 100: return
func(index + 1) func(1)
-----------------------------------
def func(index):
print(index) #占用1个空间
func(index + 1) func(1) #占用1个空间
#递归深度1000,但是实际到不了1000, 在997-998之间
-----------------------------------
import sys
sys.setrecursionlimit(5000) #设置递归的最大深度,一般不要改
def func(index):
print(index) #占用1个空间
func(index + 1) func(1) #占用1个空间 打印路径下所有文件名:
打印路径下的所有文件名
import os
def func(file_path, layer):
lst = os.listdir(file_path)
for file in lst:
full_path = os.path.join(file_path, file)
if os.path.isdir(full_path):
print('\t'*layer, file)
func(full_path, layer + 1)
else:
print('\t'*layer, file)
else:
return
func('D:\python_work', 0)
6. 二分法查找
优点:查找效率高
缺点:必须是有序序列 用二分法判断数字是否在列表中:
#判断输入的数字是否在列表中
lst = [1, 8, 16, 32, 55, 78, 425, 21, 5, 52, 11]
lst = sorted(lst) #必须是有序数列
n = int(input('请输入一个数:'))
left = 0
right = len(lst) - 1 while left <= right:
mid = (left + right) // 2 #索引只能是整数
if n > lst[mid]:
left = mid + 1
elif n < lst[mid]:
right = mid - 1
else:
print('在列表中,位置是%s' % mid)
break
else:
print('这个数不在此列表中')
用递归法查找数字是否在列表中,方法一:
def func(n, lst):
left = 0
right = len(lst) - 1
if left <= right:
mid = (left + right) // 2
if n < lst[mid]:
new_list = lst[:mid]
return func(n, new_list)
elif n > lst[mid]:
new_list = lst[mid + 1:]
return func(n, new_list)
else:
print('在列表中')
return True
else:
print('不在列表中')
return False lst = [1, 8, 16, 32, 55, 78, 425, 21, 5, 52, 11]
lst = sorted(lst)
ret = func(8, lst)
print(ret)
用递归法判断数字是否在列表中,方法二:
def func(n, lst, left=0, right=None):
if right == None:
right = len(lst) - 1
if left <= right:
mid = (left + right) //2
if n < lst[mid]:
right = mid - 1
elif n > lst[mid]:
left = mid + 1
else:
return True
return func(n, lst, left, right)
else:
return False lst = [1, 1, 1, 1, 2, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 7, 8, 8, 9, 16, 32, 44, 55, 78, 89]
ret = func(0,lst)
print(ret)