整理-----内置函数
内置函数
#作用域相关 print(globals()) print(locals())
#生成器/迭代器 l = [11,22,33,44] it = iter(l) #<list_iterator object at 0x01EA2910> 将列表变成迭代器 print(it) print(next(it)) print(next(it)) print(next(it)) print(next(it)) print(next(it)) #取到这里会报错,因为没有那个多值,报StopIteration
lamda匿名函数
lambda表示的是匿名函数. 不需要用def来声明, 一句话就可以声明出一个函数
语法:
函数名 = lambda 参数: 返回值
语法:
函数名 = lambda 参数: 返回值
注意:
1. 函数的参数可以有多个. 多个参数之间用逗号隔开
2. 匿名函数不管多复杂. 只能写一行, 且逻辑结束后直接返回数据
3. 返回值和正常的函数一样, 可以是任意数据类型匿名函数并不是说一定没有名字. 这里前面的变量就是这个函数名. 说他是匿名原因是我们通过func.__name__查看的时候是没有名字的. 统一都叫lambda. 在调用的时候没有什么特别之处.
1. 函数的参数可以有多个. 多个参数之间用逗号隔开
2. 匿名函数不管多复杂. 只能写一行, 且逻辑结束后直接返回数据
3. 返回值和正常的函数一样, 可以是任意数据类型匿名函数并不是说一定没有名字. 这里前面的变量就是这个函数名. 说他是匿名原因是我们通过func.__name__查看的时候是没有名字的. 统一都叫lambda. 在调用的时候没有什么特别之处.
像正常的函数调用即可
#返回多个值 def func(x,y): return x,y #这里返回的是一个元祖 #等同于 a = lambda x,y : (x,y)
这里如果写成a = lambda x,y : x,y,会报错,因lambda类似看成一个元祖,以逗号分隔,会把lambda x,y : x当一个值,y当一个值,然后y没有定义,所以报错,这里把要返回的值用括号括起来,形成一个元祖
#传两个参数,返回最大值 a = lambda x,y :max(x,y) print(a(4,5)) #传多个值 a = lambda *args :max(args) print(a(4,5,6,34,434,656,23,54,6,2,8,9))
排序函数
sorted()
排序函数.
语法: sorted(Iterable, key=None, reverse=False)
Iterable: 可迭代对象
key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函
数的参数. 根据函数运算的结果进行排序
reverse: 是否是倒叙. True: 倒叙, False: 正序
#sorted排序 l = ["3663","88888","44","333",'55',"2222","777"] ll = sorted(l) print(ll) # ['2222', '333', '3663', '44', '55', '777', '88888']
#需要根据字符串长度排序 def func(n): '''定义排序的方式,这里按字符串的长度''' return len(n)
#key:排序方式,sorted函数会把可迭代对象中的每一个元素拿出来交给后面的key, #后面的key计算出一个数字,作为当前这个元素的权重,整个函数会根据权重排序 ll = sorted(l,key=func) print(ll) # ['44', '55', '333', '777', '3663', '2222', '88888']
#倒序 reverse=True, reverse=False是正序 ll = sorted(l,key=func,reverse=True) print(ll) # ['88888', '3663', '2222', '333', '777', '44', '55']
使用lambda定义函数
#使用lambda定义函数 l = [{"name":"aaa",'age':34}, {"name":"ccc",'age':30}, {"name":"eee",'age':37}, {"name":"bbb",'age':35}] ll = sorted(l,key=lambda dic:dic["age"])
#lambda函数拆开看就是def fun(dic):
# return dic["age"] print(ll)
# [{'name': 'ccc', 'age': 30}, {'name': 'aaa', 'age': 34}, {'name': 'bbb', 'age': 35}, {'name': 'eee', 'age': 37}]
ll = sorted(l,key=lambda dic:dic["age"],reverse=True) #反序
print(ll) #[{'name': 'eee', 'age': 37}, {'name': 'bbb', 'age': 35}, {'name': 'aaa', 'age': 34}, {'name': 'ccc', 'age': 30}]
filter 过滤
筛选函数
语法: filter(function. Iterable)
function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后
根据function返回的True或者False来判断是否保留此项数据
Iterable: 可迭代对象
#filter l = ['aa',"anc",'ccc','aef','ddd','eee'] def func(e): '''当第一个是a返回F,不是a返回T''' if e[0] == 'a': return False #不想要的 else: return True f = filter(func,l) print(f) # <filter object at 0x006B40B0> print("__iter__" in dir(f)) # True 说明是可迭代对象 for i in f: print(i) ''' ccc ddd eee ''' #用lambda写 f = filter(lambda e:e[0] != "a",l) #lambda 返回为真的内容 print("__iter__" in dir(f)) # True 说明是可迭代对象 for j in f: print(j) ''' ccc ddd eee'''
过滤出某个范围内的数据
dic = [{"name":"aaa",'age':34},
{"name":"ccc",'age':30},
{"name":"eee",'age':37},
{"name":"bbb",'age':35}]
#过滤出年龄大于34
f = filter(lambda e :e["age"] > 34,dic)
print(type(f)) #<class 'filter'>
print(list(f)) #[{'name': 'eee', 'age': 37}, {'name': 'bbb', 'age': 35}]
map()
映射函数
语法: map(function, iterable) 可以对可迭代对象中的每一个元素进行映射. 分别取执行
function
计算列表中每个元素的平方 ,返回新列表
#map映射 #计算列表中元素的平方 l1 = [1,2,3,4] a = map(lambda x:x**2,l1) print(list(a)) # [1, 4, 9, 16] #计算两个列表中相同位置元素的和 l1 = [1,2,3,4] l2 = [5,6,7,8] a = map(lambda x,y:x + y,l1,l2) print(list(a)) # [6, 8, 10, 12]
有水桶相应,某个列表少了,多了,都以少的为准
递归
在函数中调用函数本身. 就是递归
通过递归遍历某个文件夹下的内容
def func(): print("我是谁") func() func()
在python中递归的深度最⼤到998
def foo(n): print(n) n += 1 foo(n) foo(1)
递归的应用
我们可以使用递归来遍历各种树形结构, 比如我们的⽂件夹系统. 可以使⽤递归来遍历该
文件夹中的所有文件
#递归文件夹,函数内部调用外面的函数 import os def func(filepath,n): #打开指定文件夹 files = os.listdir(filepath) #获取到每一个文件名 for file in files: #获取到绝对路径,加⼊⽂件夹 获取到⽂件夹+⽂件 file_path = os.path.join(filepath,file) #判断是否是文件夹 if os.path.isdir(file_path): print("\t"*n,"\033[31;1m{0}{1}\033[0m".format(file_path,":")) func(file_path,n + 1) else: print("\t"*n,file_path) func(r"C:\Users\ZYP\PycharmProjects\day20",0)
二分法
二分查找. 每次能够排除掉一半的数据. 查找的效率非常高. 但是局限性比较大. 必须是有
序序列才可以使用二分查找
要求: 查找的序列必须是有序序列.
#二分法普通版 #必须是有序的 l = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789] value = 101 left_index = 0 right_index = len(l) - 1 while right_index >= left_index: mid = (left_index + right_index) // 2 if l[mid] > value: right_index = mid - 1 elif l[mid] < value: left_index = mid + 1 else: l[mid]== value print("找到了") break else: print("没有找到")
二分法递归版
#二分法,递归版 l = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789] def func(n,left_index,right_index): if right_index >= left_index: #计算中间索引的值 mid = (left_index + right_index) // 2 if l[mid] > n: #改变边界值 right_index = mid - 1 #调用func继续往里面找 func(n,left_index,right_index) if l[mid] < n: left_index = mid + 1 func(n, left_index, right_index) if l[mid] == n: print("找到了") return 1 else: print("没有找到") return -1 n = 70 ret = func(n,0,len(l) - 1) print(ret) # None
这里有个深坑,当找到了或者我们没有找到,返回值为1或者-1,但实际打印的时候都是None,
这是因为函数返回值只返回给他的调用者,这里有多层递归,所以是无法返回给最外层的调用者
修改如下:
l = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789] def func(n,left_index,right_index): if right_index >= left_index: #计算中间索引的值 mid = (left_index + right_index) // 2 if l[mid] > n: #改变边界值 right_index = mid - 1 #调用func继续往里面找 return func(n,left_index,right_index) if l[mid] < n: left_index = mid + 1 return func(n, left_index, right_index) if l[mid] == n: print("找到了") return 1 else: print("没有找到") return -1 n = 70 ret = func(n,0,len(l) - 1) print(ret) # -1
二分法,不要求返回索引,很难判断位置
#二分法,不要求返回索引,判断是否存在就行 l = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789] def func(l,n): left = 0 right = len(l) - 1 if left > right: print("不存在") mid = (left + right) // 2 if l[mid] > n: return func(l[:mid - 1],n) if l[mid] < n: return func(l[mid + 1:],n) else: print("在这里") print(func(l,77))
查找最快,最省内存的方法,一次查找
#查找最快的方法,时间复杂度和空间复杂度最低 l = [9,6,7,8] l = sorted(l) #生成一个全0的列表,长度为列表最大值加1 l1 = [0 for n in range(l[-1] + 1)] print(l1) #[0, 0, 0, 0, 0, 0, 0, 0, 0, 0] #将存在l中的值,对应的l1列表的位置改为1 for i in l: l1[i] = 1 print(l1) #[0, 0, 0, 0, 0, 0, 1, 1, 1, 1] #判断8是否在 if l1[8] == 1: print("在")
