def func(x): #普通函数 return x*x ret1 = func(10) print(ret1) #100 #匿名函数 f = lambda x:x*x print(f(10)) #100 # 匿名函数写法： 匿名函数名=lambda 参数:返回值
'''''' ''' sorted（）函数 写法：sorted（iterable,key=func,reverse=False） 原理：把iterable中的每一个元素，依次作为参数，传递给自定义函数，返回值是数字-int，然后进行排序（默认升序） 比如：列表中是int，字符串等元素 列表中是字典--学生信息（按照学生的年龄进行排序） 列表中是元组--字典的value进行排序 dic.items() sort（）和sorted()的区别 1、前者是列表的内置函数，排序后，将列表本身修改了 写法：li1.sort() 2、后者可以用于iterable，排序后，产生一个新的排序后的列表，原列表本身没有修改 写法：li2 = sorted(li1) ''' #1列表的排序 li1 = [1,3,2] li2 = sorted(li1) # li2 = sorted(li1,key=None,reverse=False) #和上面行等效 print(li2) #[1, 2, 3] print('----------------------1 列表的排序') #2字典的排序 #01 按照字典的key进行排序 dic1 = {'1':'jack','3':'jack3','2':'jack2'} dic2 = sorted(dic1) #将字典的key进行排序 print(dic2) #['1', '2', '3'] print('----------------------2-1 字典的排序 字典的key排序') #02 按照字典的value进行排序 dic1 = {'1':'jack','3':'jack2','2':'jack3'} print(dic1.items()) #dict_items([('1', 'jack'), ('3', 'jack3'), ('2', 'jack2')]) #将字典通过items()转换成列表嵌套元组的形式，将元组作为整体传递到自定义函数的参数中 li2 = sorted(dic1.items(),key=lambda x:x[1]) #将列表中的元组，按照元组的第2项（字典的value）进行排序 print(li2) #[('1', 'jack'), ('3', 'jack2'), ('2', 'jack3')] dic3 = {} for i in li2: dic3[i[0]] = i[1] print(dic3) #{'1': 'jack', '3': 'jack2', '2': 'jack3'} #将字典的value进行排序 print('----------------------2-2 字典的排序 字典的value排序') #03 按照列表的元素长度来排序 li3 = ['jack','tom','james'] li4 = sorted(li3,key=lambda x:len(x)) print(li4) #['tom', 'jack', 'james'] print('----------------------3-1 按照列表的元素长度来排序 sorted+lambda') #04 按照学生的年龄来排序（列表中嵌套字典） li4 = [{'name':'jack','age':18}, {'name': 'tom', 'age': 15}, {'name': 'bob', 'age': 19}] li5 = sorted(li4,key=lambda dic:dic['age']) print(li5) #[{'name': 'tom', 'age': 15}, {'name': 'jack', 'age': 18}, {'name': 'bob', 'age': 19}] #分析：列表中嵌套字典，字典是作为一个元素，整体传递给自定义函数的参数的
'''''' ''' filter函数 1、写法 filter(func,iterable) 2、原理 将iterable中的每一个元素，作为参数传递给自定义函数，返回值是True或者False，保留True ''' #1筛选偶数 li1 = [1,2,3,4,5,6] li2 = filter(lambda x:x%2==0,li1) print(li2) #迭代器 print(list(li2)) #[2, 4, 6] 将迭代器转换成列表 print('-------------------------1 filter') #2筛选学生信息，将大于18岁的筛选出来 li2 = [{'name': 'jack', 'age': 18}, {'name': 'tom', 'age': 15}, {'name': 'bob', 'age': 19}] li3 = filter(lambda dic:dic['age']>18,li2) print(li3) #迭代器 print(list(li3)) #[{'name': 'bob', 'age': 19}] 将迭代器转换成列表 print('-------------------------2 filter')
''''' ''' map函数 1、写法 map(func,iterable) 参数1：自定义函数或者匿名函数 参数2：Iterable 返回值：Iterator-迭代器 2、原理 将iterable中的元素，作为参数依次传递入自定义函数，计算返回值，返回迭代器-iterator ''' #1 计算列表中的每个元素平方，返回新列表 li1 = [1,2,3] li2 = map(lambda x:x*x,li1) print(li2) #迭代器 print(list(li2)) #[1, 4, 9] 将迭代器转换成列表 print('------------------------1 map') #2 计算两个列表相同位置的元素之后 li3 = [1,3,5] li4 = [2,4,6] li5 = map(lambda x,y:x+y,li3,li4) print(li5) print(list(li5)) #[3, 7, 11] print('------------------------2 map')
1 '''''' 2 ''' 3 递归 4 1、递归的概念 5 函数自己调用自己，就叫递归 6 2、递归的深度 7 递归的深度最多是998 8 3、递归的本质 9 找到不断在变的东西，递归就写出来了 10 比如：每次递归调用都会新生产一个列表（列表的长度是之前的一半） 11 比如：每次递归调用，列表的左右边界位置都在变化（两者之差在减半） 12 ''' 13 14 def func(): 15 print('我要递归了') 16 func() #递归入口 不带参数 17 # func() #报错 18 #RecursionError: maximum recursion depth exceeded while calling a Python object 19 20 def func1(n): 21 print(n) 22 n += 1 23 func1(n) #递归入口，带参数，变动的是n 24 # func1(0) #报错 25 #RecursionError: maximum recursion depth exceeded while calling a Python object 26 27 #1 递归遍历文件夹 28 # 将指定文件夹的子文件夹及其子目录都列出来 29 ''' 30 递归遍历文件夹，伪代码思路 31 1、定义指定文件夹的相对路径（相对路径便于移植，在其他电脑上运行） 32 定义函数，参数是指定文件夹路径 33 2、列出指定文件夹下的一级子文件夹（不包含二级子文件夹和二级子文件）和一级子文件 34 3、遍历循环上述步骤2的列表 35 4、拼接一级子文件夹和一级子文件的全路径（相对路径） 36 5、判断全路径是否是文件夹 37 1、是文件夹，递归调用自己，传入参数全路径 38 2、不是文件夹，就是文件，打印文件的全路径 39 40 步骤： 41 1、先实现功能 42 2、再优化不同层级文件夹的缩进--注意点：每次递归调用一次，层级就+1 43 44 小结： 45 递归的本质和原理 46 1、递归的本质：不断在变的是子文件夹的全路径和层级 47 2、递归的本质就是要找出不断在变-每次都在变的是什么 48 3、递归的入口，递归就是函数内自己调用自己 49 形参是一样的，但是每次传递进来的实参是不一样的 50 （发现并找到每次传递进来的实参-不同的子文件夹全路径--就是递归的本质） 51 4、递归入口的参数2：每次递归调用一次，层级就+1 52 （也说明了文件夹层级每次递归都不一样） 53 ''' 54 import os 55 56 def recursion_folder(path1,n): 57 #参数1：指定文件夹的相对路径 58 #参数2：文件夹的层级 59 subfolder_li1 = os.listdir(path1) #['002', '003.py', '005.py', '__init__.py'] 60 #1 列出指定文件夹的一级子文件夹（不包含其二级子文件夹和子文件）和一级子文件，返回列表 61 for i in subfolder_li1: #2 遍历循环列表 62 full_path = os.path.join(path1,i) #3 拼接一级子文件夹和一级子文件的全路径(相对路径，路径+文件(夹)名字) 63 # print(full_path) 64 if os.path.isdir(full_path):#4 判断全路径是否是文件夹 65 print(' '*n+i) #5 是的话，打印文件夹名字（非全路径） 66 # 文件夹名字（非全路径）前面加上 制表符-缩进 67 #指定文件夹下一级子文件夹前面缩进是0-不缩进-顶格打印 68 #指定文件夹下二级子文件夹前面缩进是1，依次类推。。。 69 recursion_folder(full_path,n+1) #6 递归入口 函数内自己调用函数自己 70 #递归函数参数1：一级子文件夹的全路径（路径前缀+一级子文件夹名字） 71 #递归参数2：文件夹层级+1（每次递归调用一次，层级就+1） 72 #递归函数：不断在变的是子文件夹的全路径和缩进层级（递归的本质就是要找出不断在变的是什么）--关键点 73 else: #5 如果全路径不是文件夹，就是文件 74 print(' '*n+i)#6 打印文件名字（非全路径） 75 # 文件名字（非全路径）前面加上 制表符-缩进 76 # 指定文件夹下一级子文件前面缩进是0-不缩进-顶格打印 77 # 指定文件夹下二级子文件前面缩进是1，依次类推。。。 78 # 注意点：这里隐含一个return 递归的出口 79 80 # path1 = r'D:ProgramJetBrainsPycharmProjectsxq_py全栈16 01' 81 path1 = r'.... 01' #指定文件夹的相对路径 82 #.当前目录 ..上级目录 ....上上级目录 推荐相对目录 83 n=0 #定义缩进层级 84 recursion_folder(path1,n) #调函数 85 86 #指定文件夹的目录结构和层级打印 87 # 002 88 # 003 89 # 004.py 90 # __init__.py 91 # 003.py 92 # __init__.py 93 # 003.py 94 # 005.py 95 # __init__.py
1 ''''' 2 ''' 3 二分法 4 1、核心思想 5 掐头去尾取中间（中位数） 6 2、前置条件 7 已经完成了排序（升序或者降序） 8 9 二分法查找： 10 方法1：循环+左右边界位置变动（两者之差减半） 11 --可以知道目标数在列表中的位置 12 方法2：递归+新产生列表（新列表长度减半） 13 --无法知道目标数在列表中的位置 14 方法3：递归+左右边界位置变动（两者之差减半） 15 ''' 16 17 # 方法1：循环 + 左右边界位置变动（两者之差减半） 18 # --可以知道目标数在列表中的位置 19 def find(n1,li1): 20 left = 0 21 right = len(li1)-1 22 while left <= right: 23 mid = (left+right)//2 #左右边界在变动，中位数就在变动 24 if n1 < li1[mid]: 25 right = mid - 1 26 elif n1 > li1[mid]: 27 left = mid + 1 28 else: 29 index1 = li1.index(n1) 30 print('%s 找到了，目标数在列表的下标是 %s' % (n1,index1)) 31 break #跳出整个循环 32 else: 33 print('目标数 %s 没找到' % n1) 34 n1 = 3 35 li1 = [1,2,3,4,5] 36 find(n1,li1) 37 #3 找到了，目标数在列表的下标是 2 38 print('------------------------1 循环') 39 40 # 方法2：递归 + 新产生列表（新列表长度减半） 41 # --无法知道目标数在列表中的位置，因为每次都新产生一个列表 42 def recursion1(n2,li2): 43 left = 0 44 right = len(li2) - 1 45 if left <= right: 46 mid = (left+right)//2 47 if n2 < li2[mid]: 48 li21 = li2[:mid-1] 49 return recursion1(n2,li21) #注意点1：必须加上return 递归入口 50 elif n2 > li2[mid]: 51 li21 = li2[mid+1:] 52 return recursion1(n2, li21) 53 else: 54 print('目标数 %s 找到了' % (n2)) 55 else: 56 print('目标数 %s 没找到' % n2) 57 #隐含一个return None 递归出口 58 n2 = 4 59 li2 = [1,2,3,4,5] 60 recursion1(n2,li2) 61 print('------------------------2 递归+ 新产生列表') 62 63 # 方法3：递归 + 左右边界位置变动（两者之差减半） 64 def recursion2(n3,li3,left,right): 65 if left <= right: 66 mid = (left+right)//2 67 if n3 < li3[mid]: #注意点1：这里小于号坐标是目标数，而不是left 68 right = mid -1 69 return recursion2(n3,li3,left,right) #注意点：return加上 70 elif n3 > li3[mid]: 71 left = mid + 1 72 return recursion2(n3, li3, left, right) 73 else: 74 index1 = li3.index(n3) 75 print('%s 找到了，目标数在列表的下标是 %s' % (n3, index1)) 76 return True 77 else: 78 print('目标数 %s 没找到' % n3) 79 return False 80 n3 = 5 81 li3 = [1,2,3,4,5] 82 left = 0 83 right = len(li1)-1 84 recursion2(n3,li3,left,right) 85 #5 找到了，目标数在列表的下标是 4 86 print('------------------------3 递归+左右边界位置变动')