一.lamda匿名函数
定义:为了解决一些简单的需求而设计的函数.
语法:函数名=lambda 参数 : 返回值
1,函数的声明
def func(n):
'''
此函数接收一个参数n
计算n的n次方
:param n: 传递进来的n
:return: n的n次方
shijian
zuozhe
'''
return n**n
r = func(3) # 函数的调用
print(r)
#print(func.__name__) #查看函数名
#print(func.__doc__) #查看注释文档
例一:
a = lambda n: n**n # 匿名函数, 一般不会用来做复杂的操作
r=a
print(r)
例二
# 写一个lambda 计算字符串长度并返回 # len()
a = lambda s: len(s)
例三:
# 写一个lambda 给函数传递两个参数, a, b 计算a+b的结果
a = lambda m, n: m + n
注意:
1. 函数的参数有多个,多个参数之间用逗号隔开
2. 匿名函数不管有多复杂,只能写一行,且逻辑结束后直接返回数据
3.返回值和正常的函数一样,可以是任意数据类型
二:排序函数sorted()
语法:sorted(Iterable, key=None, reverse=False)
Iterable: 可迭代对象
key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每⼀个元素传递给这个函
数的参数. 根据函数运算的结果进⾏排序
reverse: 是否是倒叙. True: 倒叙, False: 正序
例一
list=[1,5,3,4,6]
lst=sorted(list)
print(lst)
print(list)
例二
dic={1:'A',3:'c',2:'b'}
print(sorted(dic))
例三和函数一起使用
lst=["麻花藤","冈本次郎","中央情报局","狐仙"]
def func(s):
return len(s)
print(sorted(lst,key=func))
例四 和函数组合使用
lst=["麻花藤","冈本次郎","中央情报局","狐仙"]
def func(s):
return len(s)
print(sorted(lst, key= lambda s:len(s)))
例五:
lst=[{"id":1,"name":'alex',"age":18},
{"id":2,"name":"wusir","age":16},
{"id":3,"name":"taibai","age":17}
]
print(sorted(lst,key=lambda e:e["age"]))
三fitter()筛选函数
语法: filter(function. Iterable)
function: ⽤来筛选的函数. 在filter中会⾃动的把iterable中的元素传递给function. 然后
根据function返回的True或者False来判断是否保留此项数据
Iterable: 可迭代对象
例一
lst=[1,2,3,4,5,6,7,8,9,10]
ll=filter(lambda x: x%2==0,lst)
print(ll)
print(list(ll))
例二
lst=[{"id":1,"name":'alex',"age":18},
{"id":2,"name":"wusir","age":16},
{"id":3,"name":"taibai","age":17}
]
fl =filter(lambda e: e[age]>16,lst)
print(list(f1))
例三
c=lambda a,b: a+b
r=c(3,4)
print(r)
例四
lst=["麻花藤","冈本次郎","中央情报局","狐仙"]
ll=lambda s: len(s)
r=ll
print(r)
例五
lst=["精卫填海","放羊的星星","年轮","灵魂摆渡","蜗居","第八号当铺","惊魂"]
f=filter(lambda s: len(s)>2,lst)
print(f)
print("__iter__" in dir(f))
for i in f:
print(i)
例六
lst=[{"id":1,"name":'alex',"age":18},
{"id":2,"name":"wusir","age":16},
{"id":3,"name":"taibai","age":34},
{"id": 3, "name": "太白", "age": 49},
{"id": 3, "name": "太黑", "age": 26},
{"id": 3, "name": "骚逼", "age": 17}
]
f2=filter(lambda e:e["age"]>=30,lst)
print(f2)
print("__iter__" in dir(f2))
for j in f2:
print(j)
四map函数(映射函数)
语法: map(function, iterable) 可以对可迭代对象中的每一个元素进行映射,分别取执行function
例一:计算列表中每个元素的平方返回新列表
lst=[2,3,4,5,6,7]
m=map(lambda s:s**2,lst)
print("__iter__" in dir(m))
for i in m:
print(i)
n=filter(lambda x:x**2,lst)
for j in n:
print(j)
例二:查找是否在列表里面
用户:alex
密码:456
lst=["alex_123", "alex_456", "wusir_123", "wusir_456", "alex_789"]
m=list(map(lambda s:"yes" if s=="alex_456" else "false" ,lst))
print(m)
m=list(map(lambda s:s.split("_")[0]=="alex" and s.split("_")[1] =="123" ,lst))
print(m)
print("__iter__" in dir(list))
例三:计算两个列表相同位置的数据的和 lst1 = [1, 2, 3, 4, 5] lst2 = [2, 4, 6, 8, 10] print(list(map(lambda x, y: x+y, lst1, lst2)))
五;递归:在函数中调用函数本身,就是递归(python中最大递归深度998)
例一
def func():
print("我是谁")
func()
func()
def foo(n):
print(n)
n += 1
foo(n)
foo(1)
递归的应⽤:
我们可以使用递归来遍历各种树形结构, 比如我们的文件夹系统.
可以使用递归来遍历该文件夹中的所有文件
def func(path, ceng): # path: d:/a
lst = os.listdir(path)
for el in lst: # 哈哈
# el 文件名
rp = os.path.join(path, el) # d:/a/哈哈
if os.path.isdir(rp):
print(" "*ceng, el, sep="")
func(rp, ceng+1)
else:
print(" "*ceng,el, sep="")
func("e:/哈哈", 0)
lst = os.listdir(path) # 打开一个文件夹. 获取到文件夹内的所有内容 ["a","b"]
for el in lst: # 当前文件夹内的所有的文件名(包括文件夹名字)
# 拼接文件的真实路径
file_real_path = os.path.join(path, el)
# 判断这个路径是文件还是文件夹
if os.path.isdir(file_real_path):
# 递归的入口
print(el)
func(file_real_path) # 重新执行刚才的操作
else: # 不是文件夹, 是文件
# 递归的出口
print(el)
六. 二分查找
二分查找. 每次能够排除掉⼀半的数据. 查找的效率非常⾼. 但是局限性比较大. 必须是有
序序列才可以使用二分查找
要求: 查找的序列必须是有序序列.
判断n是否在lst中出现,如果出现请返回n所在的位置
1.二分法查找-----非递归算法
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
n = 567
left = 0
right = len(lst) - 1
count = 1
while left <= right:
middle = (left + right) // 2
if n < lst[middle]:
right = middle - 1
elif n > lst[middle]:
left = middle + 1
else:
print(count)
print(middle)
break
count = count + 1
else:
print("不存在")
2. 普通递归版本⼆分法
def binary_search(n, left, right):
if left <= right:
middle = (left+right) // 2
if n < lst[middle]:
right = middle - 1
elif n > lst[middle]:
left = middle + 1
else:
return middle
return binary_search(n, left, right)
# 这个return必须要加. 否则接收到的永远是None.
else:
return -1
print(binary_search(567, 0, len(lst)-1))
3. 另类⼆分法, 很难计算位置.
def binary_search(ls, target):
left = 0
right = len(ls) - 1
if left > right:
print("不在这⾥")
middle = (left + right) // 2
if target < ls[middle]:
return binary_search(ls[:middle], target)
elif target > ls[middle]:
return binary_search(ls[middle+1:], target)
else:
print("在这⾥")
binary_search(lst, 567)