主要内容:
1. 匿名函数lambda(): lambda表示的是匿名函数. 不需要用def来声明, ⼀句话就可以声明出一个函数.
a: 语法:lambda 参数:返回值 (不能完成复杂的操作.)
a = lambda n : n* n print(a(5)) #结果25 一行搞定一个函数. 但是, 不能完成复杂的函数操作 print(a.__name__) #查看函数的函数名
b.__name__可以查看函数的名(当函数名难用肉眼看到时)
def func(n):
return n * n
print(func(3))
a = func
a(3)
print(a.__name__) # 查看函数的函数名
2. 排序函数:sorted()
a: 语法: sorted(Iterable, key=None, reverse=False)
iterable: 可迭代对象
key = 函数: 排序规则,在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数,根据函数的运算结果进行排序.
reverse:是否是倒叙,ture,倒叙; false:正序
lst = [2,4,23,1,4,57,89,34] lst.sort() #升序 print(lst) ll = sorted(lst,reverse=True) #倒叙,.内置函数,返给你一个新列表,新列表是被排序的. print(ll)
b,例题.根据字符串中a的个数进行排序
和函数组合使用
lst = ["大阳哥a", "尼古拉斯aa", "赵四aaa", "刘能a", "广坤aaaaaa", "谢大脚a"]
def func(s):
return s.count('a')
ll = sorted(lst,key=func) #将可迭代对象中的每一个元素传递给函数的参数,根据函数的运算结果进行排序
print(ll)
和lambda组合使用
lst = ["大阳哥a", "尼古拉斯aa", "赵四aaa", "刘能a", "广坤aaaaaa", "谢大脚a"]
ll = sorted(lst, key=lambda s:s.count('a'))
print(ll)
c,例题2:对年龄进行排序
lst = [{'id':1, 'name':'alex', 'age':18},{'id':2, 'name':'taibai', 'age':58},
{'id':3, 'name':'wusir', 'age':38},{'id':4, 'name':'ritian', 'age':48},
{'id':5, 'name':'女神', 'age':18} ]
ll = sorted(lst,key=lambda dic:dic['age']> 30,reverse=True) #不写reverse默认是升序,谢了reverse=ture是倒叙.
print(ll)
3. 筛选函数filter()
a: 语法:filter(function, iterable)
第一个参数. 函数. 将第二个参数中的每一个元素传给函数. 函数如果返回True, 留下该元素.
b. 例题:筛选列表中的所有奇数
def func(i):
return i % 2 == 1 #判断是奇数
lst = [1,2,3,4,5,6,7,8,9]
ll = filter(func, lst)
# print('__iter__'in dir(ll)) #ture
# print('__next__'in dir(ll)) #ture 说明返回值是迭代器.
print(list(ll))
结合lambal函数
lst = [1,2,33,4,5,6,7,89] ll = filter(lambda i :i % 2 == 1,lst) print(list(ll)) #[1, 33, 5, 7, 89]
c. 例题2,筛选列表年龄大于34的学生信息
lst = [
{'id':1, 'name':'alex', 'age':18},
{'id':2, 'name':'taibai', 'age':58},
{'id':3, 'name':'wusir', 'age':38},
{'id':4, 'name':'ritian', 'age':48},
{'id':5, 'name':'女神', 'age':18}
]
ll = filter(lambda dic: dic['age']>34,lst)
print(list(ll))
结果:
[{'id': 2, 'name': 'taibai', 'age': 58}, {'id': 3, 'name': 'wusir', 'age': 38}, {'id': 4, 'name': 'ritian', 'age': 48}]
4. 映射函数:map()
a:语法:map(function,iterable) 把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器
b:例题1,计算列表中每个元素的平方,返回新列表.
lst = [1,2,3,4,3,3,45,34,2,4,24,90] ll = map(lambda i : i * i,lst) #把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器 print(list(ll)) #[1, 4, 9, 16, 9, 9, 2025, 1156, 4, 16, 576, 8100]
c:可以计算两个列表中相同位置的数据的和
lst1 = [1,3,5,7,9] lst2 = [0,2,4,6,8] ll = map(lambda x, y:x + y,lst1,lst2) #lambda参数可以有多个,多个参数之间用,号隔开. print(list(ll))
5. 递归
a: 在函数中调用函数本身,就是递归.
def func():
print('haokun')
func()
func()
b: 在python中递归的最大深度997,递归的的深度可以改变,但是不一定能达到你所设定的值.
def func(count):
print('好困'+str(count))
count = count + 1
func(count)
func(1)
调整递归的深度
import sys
sys.setrecursionlimit(10000) # 可以调整递归深度. 但是不一定能跑到这里
def func(count):
print("我是谁,我在哪里"+str(count))
func(count+1)
func(1)
c: 递归的应用:遍历树形结构
import os
filePath = "d:sylarpython_workspace"
def read(filePath, n):
it = os.listdir(filePath) # 打开文件夹
for el in it:
# 拿到路径
fp = os.path.join(filePath, el) # 获取到绝对路径
if os.path.isdir(fp): # 判断是否是文件夹
print(" "*n,el)
read(fp, n+1) # 又是文件夹. 继续读取内部的内容 递归入口
else:
print(" "*n,el) # 递归出口
read(filePath, 0)
6. 二分法查找:
有三种方法:纯算法,递归,切割
a: 纯算法:
lst = [1,3,5,7,9,11,13,15,16]
left = 0
right = len(lst) - 1
n = 13
count = 1
while left < right:
middle = (left + right)//2
if n > lst[middle]:
left = middle + 1
elif n < lst[middle]:
right = middle - 1
else:
print('找到了')
print(middle)
print("计算%s次" % count)
break
count = count + 1
else:
print('不存在')
b: 递归
lst = [1,3,5,7,9,11,13,15,16]
def binary_search(left,right,n):
middle = (left + right)//2
if left > right:
return -1 #递归出口
if n > lst[middle]:
left = middle + 1
elif n < lst[middle]:
right = middle - 1
else:
return middle
return binary_search(left, right, n)
print(binary_search(0,len(lst)-1,13))
c: 切割
lst = [1,3,5,7,9,11,13,15,16]
def binary_search(lst, n):
left = 0
right = len(lst) - 1
middle = (left + right) // 2
if right <= 0:
print("没找到")
return
if n > lst[middle]:
lst = lst[middle+1:]
elif n < lst[middle]:
lst = lst[:middle]
else:
print("找到了")
return
binary_search(lst, n)
binary_search(lst, 13)