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('\t'*n+i) #5 是的话，打印文件夹名字（非全路径）
66             # 文件夹名字（非全路径）前面加上\t制表符-缩进
67             #指定文件夹下一级子文件夹前面缩进是0-不缩进-顶格打印
68             #指定文件夹下二级子文件夹前面缩进是1，依次类推。。。
69             recursion_folder(full_path,n+1) #6 递归入口 函数内自己调用函数自己
70             #递归函数参数1：一级子文件夹的全路径（路径前缀+一级子文件夹名字）
71             #递归参数2：文件夹层级+1（每次递归调用一次，层级就+1）
72             #递归函数：不断在变的是子文件夹的全路径和缩进层级（递归的本质就是要找出不断在变的是什么）--关键点
73         else: #5 如果全路径不是文件夹，就是文件
74             print('\t'*n+i)#6 打印文件名字（非全路径）
75             # 文件名字（非全路径）前面加上\t制表符-缩进
76             # 指定文件夹下一级子文件前面缩进是0-不缩进-顶格打印
77             # 指定文件夹下二级子文件前面缩进是1，依次类推。。。
78             # 注意点：这里隐含一个return  递归的出口
79 
80 # path1 = r'D:\Program\JetBrains\PycharmProjects\xq_py\全栈16\001'
81 path1 = r'..\..\001'   #指定文件夹的相对路径
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 递归+左右边界位置变动')