总结：
今日内容：
函数递归 ******
算法之二分法
生成式 *****
匿名函数 ***
常用的内置函数 ****
一：函数递归（函数不能无限制的递归下去，无任何意义）
了解：在python中最大递归深度为1000，或者988左右，是python自己处理好的，最大递归深度也可更改
概念：函数在调用阶段直接或间接的又调用自身
递归分为两个阶段：
1，回溯：由未知条件向已知条件推导的过程，是重复的问题复杂度越来越低的过程
2，递推：一次次往回推导的过程
今日内容：
函数递归 ******
算法之二分法
生成式 *****
匿名函数 ***
常用的内置函数 ****
一：函数递归（函数不能无限制的递归下去，无任何意义）
了解：在python中最大递归深度为1000，或者988左右，是python自己处理好的，最大递归深度也可更改
概念：函数在调用阶段直接或间接的又调用自身
递归分为两个阶段：
1，回溯：由未知条件向已知条件推导的过程，是重复的问题复杂度越来越低的过程
2，递推：一次次往回推导的过程
总结：递归函数不要考虑循环多少次，只需要把握结束条件
即必须要有结束条件
即必须要有结束条件
案列：
l = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12]]]]]]]]]]]]
# 将列表中的数字依次打印出来(循环的层数是你必须要考虑的点)
def get_num(l):
for i in l:#循环取出列表中中的值
# print(i,type(i)) #此时的i 为两个值，1和列表，因为大列表中包含1和一个列表，共两个元素
if type(i) is int: # 若循环得到的i为 int 类型 则打印
print(i)
else: # 如果不是则继续调用函数 **************************
get_num(i) # 此时函数括号中的实参为一个列表 ，此列表i中又包含一个字符和一个列表 ***********************
get_num(l) 结果为：1 2 3 4 5 6 7 8 9 10 11 12
l = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12]]]]]]]]]]]]
# 将列表中的数字依次打印出来(循环的层数是你必须要考虑的点)
def get_num(l):
for i in l:#循环取出列表中中的值
# print(i,type(i)) #此时的i 为两个值，1和列表，因为大列表中包含1和一个列表，共两个元素
if type(i) is int: # 若循环得到的i为 int 类型 则打印
print(i)
else: # 如果不是则继续调用函数 **************************
get_num(i) # 此时函数括号中的实参为一个列表 ，此列表i中又包含一个字符和一个列表 ***********************
get_num(l) 结果为：1 2 3 4 5 6 7 8 9 10 11 12
案列总结：l，列表中包含一个int的字符和一个列表，共两个 ‘元素’
通过for循环得到的结果 也是一个int型字符 和一个列表
然后判断的到的字符的类型，如果为int型，就是结果，复杂度又少了一层
依次类推，最后循环取出所有符合要求的值
注意：else 后面的代码，
get_num(i) 此时函数括号中的实参为一个列表 ，此列表i中又包含一个字符和一个列表
解题思路：1，对容器进行for循环取值，理清取出来的值是什么，和是什么类型，
2，提出条件，即判断条件语句，执行满足条件的代码
3，不满足条件，拿到不满足条件，对其进行分析类型和，让后传参给函数，继续执行
间接或直接的调用自身
通过for循环得到的结果 也是一个int型字符 和一个列表
然后判断的到的字符的类型，如果为int型，就是结果，复杂度又少了一层
依次类推，最后循环取出所有符合要求的值
注意：else 后面的代码，
get_num(i) 此时函数括号中的实参为一个列表 ，此列表i中又包含一个字符和一个列表
解题思路：1，对容器进行for循环取值，理清取出来的值是什么，和是什么类型，
2，提出条件，即判断条件语句，执行满足条件的代码
3，不满足条件，拿到不满足条件，对其进行分析类型和，让后传参给函数，继续执行
间接或直接的调用自身
二：函数之二分法：（解决问题的高效的方法）
容器里面的数字必须有大小数字
（提高效率，减低取值或者操作的次数，快速达到想要的结果）
案例：
判断或取值的列子
target_num = 45
l = [1,2,3,4,5,6,7,8,9,22,12,34,45,56,67,78,]
l.sort(reverse=False) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 22, 34, 45, 56, 67, 78]
def get_num(l,target_num): #注意传的参数
if not l:
print('列表不存在')
return
# 获取列表中间的索引
msg_index = len(l)//2 #整除 例子：r = [1,2.3,4,5] print(len(r)//2) =》2
# 判断target_num 的值和列表中间索引对应值的大小
if target_num >l[msg_index]:
#将列表进行切片，切取列表右半部分
num_rigit = l[msg_index + 1:] #注意要加一 索引右边开始一直到最后，即列表后半段
#再次递归调用get_num
get_num(num_rigit,target_num) #再次调用 注意括号中的是列表和你给的参数
elif target_num < l[msg_index]: #前半段列表
# 切取列表左半部分
num_left = l[0:msg_index]
# 递归调用
get_num(num_left,target_num)
else:
print('找到了！',target_num) #注意在这里是变量名，不加双引号
get_num(l,target_num)
判断或取值的列子
target_num = 45
l = [1,2,3,4,5,6,7,8,9,22,12,34,45,56,67,78,]
l.sort(reverse=False) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 22, 34, 45, 56, 67, 78]
def get_num(l,target_num): #注意传的参数
if not l:
print('列表不存在')
return
# 获取列表中间的索引
msg_index = len(l)//2 #整除 例子：r = [1,2.3,4,5] print(len(r)//2) =》2
# 判断target_num 的值和列表中间索引对应值的大小
if target_num >l[msg_index]:
#将列表进行切片，切取列表右半部分
num_rigit = l[msg_index + 1:] #注意要加一 索引右边开始一直到最后，即列表后半段
#再次递归调用get_num
get_num(num_rigit,target_num) #再次调用 注意括号中的是列表和你给的参数
elif target_num < l[msg_index]: #前半段列表
# 切取列表左半部分
num_left = l[0:msg_index]
# 递归调用
get_num(num_left,target_num)
else:
print('找到了！',target_num) #注意在这里是变量名，不加双引号
get_num(l,target_num)
三：三元表达式：
值1 if 条件 else 值2
条件成立 值1
条件不成立 值2
案列：
x = 22222
y = 111111
res = x if x > y else y
# 如果if后面的条件成立返回if前面的值 否则返回else后面的值
print(res)
列表生成式：
l = ['w1_sg','www_sg','sd','w12']
res = [name for name in l if name.endswith('_sg') ] # 后面不支持再加else的情况
print(res)
先for 循环依次取出列表里的每一个元素
然后交由if判断 条件成立才会交给for前面的代码
如果条件不成立 当前的元素就直接舍弃
res = ['%s_DSB'%name for name in l] 增加
字典生成式 注意
....l1 = ['jason','123','read']
d = {i:j for i,j in enumerate(l1) if j != '123'}
print(d) # {0: 'jason', 2: 'read'}
案列：
res = {i for i in range(10) if i != 4}
print(res) #{0, 1, 2, 3, 5, 6, 7, 8, 9}
四：匿名函数
没有名字的函数
特点：临时存在用完就没了
关键字：(lambda 参数1，参数2:返回值)(参值1，参值2)
注意：：（冒号）左边的相当于函数的形参
：（冒号） 右边相当于函数的返回值
匿名函数通常不会单独使用，是配合内置函数一起使用的
案例：res = (lambda x,y:x+y)(1,2)
print(res) 答案为 3
五：常用内置函数
map zip filter sorted reduce
map 映射
l = [1,2,3,4,5,6]
print(list(map(lambda x:x+5,l ))) 基于for循环 #[6, 7, 8, 9, 10, 11] l是列表名
zip 拉链 基于for循环
有多少拉多少与之都匹配的
l1 = [1,2,]
l2 = ['jason','egon','tank']
l3 = ['a','b','c']
print(list(zip(l1,l2,l3))) #[(1, 'jason', 'a'), (2, 'egon', 'b')]
filter 过滤
l4 = [1,2,3,4,5,6]
print(list(filter(lambda x:x == 3, l4) # 基于for循环 过滤掉不是3的字符
sorted 反转
l5 = ['jason','egon','nick','tank']
print(sorted(l5,reverse=True)) # 反转降序，按首字母 ['tank', 'nick', 'jason', 'egon']
reduce ************************
案列：
from functools import reduce
值1 if 条件 else 值2
条件成立 值1
条件不成立 值2
案列：
x = 22222
y = 111111
res = x if x > y else y
# 如果if后面的条件成立返回if前面的值 否则返回else后面的值
print(res)
列表生成式：
l = ['w1_sg','www_sg','sd','w12']
res = [name for name in l if name.endswith('_sg') ] # 后面不支持再加else的情况
print(res)
先for 循环依次取出列表里的每一个元素
然后交由if判断 条件成立才会交给for前面的代码
如果条件不成立 当前的元素就直接舍弃
res = ['%s_DSB'%name for name in l] 增加
字典生成式 注意
....l1 = ['jason','123','read']
d = {i:j for i,j in enumerate(l1) if j != '123'}
print(d) # {0: 'jason', 2: 'read'}
案列：
res = {i for i in range(10) if i != 4}
print(res) #{0, 1, 2, 3, 5, 6, 7, 8, 9}
四：匿名函数
没有名字的函数
特点：临时存在用完就没了
关键字：(lambda 参数1，参数2:返回值)(参值1，参值2)
注意：：（冒号）左边的相当于函数的形参
：（冒号） 右边相当于函数的返回值
匿名函数通常不会单独使用，是配合内置函数一起使用的
案例：res = (lambda x,y:x+y)(1,2)
print(res) 答案为 3
五：常用内置函数
map zip filter sorted reduce
map 映射
l = [1,2,3,4,5,6]
print(list(map(lambda x:x+5,l ))) 基于for循环 #[6, 7, 8, 9, 10, 11] l是列表名
zip 拉链 基于for循环
有多少拉多少与之都匹配的
l1 = [1,2,]
l2 = ['jason','egon','tank']
l3 = ['a','b','c']
print(list(zip(l1,l2,l3))) #[(1, 'jason', 'a'), (2, 'egon', 'b')]
filter 过滤
l4 = [1,2,3,4,5,6]
print(list(filter(lambda x:x == 3, l4) # 基于for循环 过滤掉不是3的字符
sorted 反转
l5 = ['jason','egon','nick','tank']
print(sorted(l5,reverse=True)) # 反转降序，按首字母 ['tank', 'nick', 'jason', 'egon']
reduce ************************
案列：
from functools import reduce
l = [1,2,3,4]
print(reduce(lambda x,y:x+y,l,)) #12 为初始值 ，即第一个参数次 结果位22
如果初始值不存在，则按照下面的规律：
第一次先获取两个元素相加
之后每次获取一个与上一次相加的结果再相加 此题为 10
print(reduce(lambda x,y:x+y,l,)) #12 为初始值 ，即第一个参数次 结果位22
如果初始值不存在，则按照下面的规律：
第一次先获取两个元素相加
之后每次获取一个与上一次相加的结果再相加 此题为 10
补充（了解）
一：递归深度：
# import sys
# print(sys.getrecursionlimit()) # 不是很精确 获取递归深度
# sys.setrecursionlimit(2000) 更改递归深度
二：注释方式：
# def index():
# pass # 第一种顶替方式(推荐使用pass)
# ... # 第二种顶替方式
一：递归深度：
# import sys
# print(sys.getrecursionlimit()) # 不是很精确 获取递归深度
# sys.setrecursionlimit(2000) 更改递归深度
二：注释方式：
# def index():
# pass # 第一种顶替方式(推荐使用pass)
# ... # 第二种顶替方式
1,排序：reverse=True 为倒序 即降序
reverse=Flase 为顺序 即升序
l.sort(reverse=True) 把列表中的字符按降序排
2，字符编码对应关系：
a-z 97 122
A-Z 65 90
print(chr(97)) 为 a
3,单词：iterable 可迭代
filter 过滤
reverse=Flase 为顺序 即升序
l.sort(reverse=True) 把列表中的字符按降序排
2，字符编码对应关系：
a-z 97 122
A-Z 65 90
print(chr(97)) 为 a
3,单词：iterable 可迭代
filter 过滤