1.生成器
def func():
yield
g=func()
next(g)
x=yield
2.三元表达式
res=x if 条件 else y
3.列表推导式，字典生成式，生成器表达式
l=[表达式 for i in 可迭代对象 if 条件]
g=（表达式 for i in 可迭代对象 if 条件）
d={k:v for i in 可迭代对象 if 条件}
4.max,zip
max(可迭代对象)
生成器=zip(可迭代对象1，可迭代对象2)
g=zip('hello',[1,2,3])
#print(g)
print(list(g))
01 什么是函数递归
1.什么是函数递归
函数递归调用（是一种特殊的嵌套调用）：在调用一个函数的过程中，又直接或间接地调用了该函数本身
递归必须要有两个明确的阶段：
递推：一层一层递归调用下去，强调每进入下一层递归问题的规模都必须有所减少
回溯：递归必须要有一个明确的结束条件，在满足条件时结束递推，开始一层一层回溯
递归的精髓在于通过不断地重复逼近一个最终的结果
2.为什么要用函数递归
3.如何用
import sys
print(sys.getrecursionlimit()) #查看默认值 1000
sys.setrecursionlimit(3000) #修改默认值为3000
def foo(n):
print('from foo',n)
foo(n+1)
foo(0) #默认值 为1000 所以解释器运行到997（逼近1000），由于自我保护机制将进行报错
报错提醒：RecursionError: maximum recursion depth exceeded while calling a Python object
########################################
常规版本：
# age(5) = age(4) + 2
# age(4) = age(3) + 2
# age(3) = age(2) + 2
# age(2) = age(1) + 2
# age(1) = 26
# age(n) = age(n-1) + 2 #n > 1
# age(1) = 26 #n = 1
##################
递归版本
# def age(n):
# if n == 1:
# return 26
# return age(n-1) + 2
#
# print(age(5))
###########################
# l=[1,[2,[3,[4,[5,[6,[7,[8,[9,]]]]]]]]]
# def tell(l):# for item in l:
# if type(item) is list:
# #继续进入下一层递归
# tell(item)
# else:
# print(item)
#
# tell(l)
#################################
有一个从小到大排列的整型数字列表
nums=[1,3,7,11,22,34,55,78,111,115,137,149,246,371]
#10 in nums
for item in nums:
if item == 10:
print('find it')
break
else:
print('not exists')
##################################
nums=[1,3,7,11,22,34,55,78,111,115,137,149,246,371]def search(search_num,nums):
#print(nums)
if len(nums) == 0:
print('not exists')
return
mid_index=len(nums) // 2
if search_num > nums[mid_index]:
# in the right
nums=nums[mid_index+1:]
search(search_num,nums)
elif search_num < nums[mid_index]:
# in the left
nums=nums[:mid_index]
search(search_num,nums)
else:
print('find it')
search(31,nums)
02 匿名函数
有名函数：基于函数名重复使用
def func():
print('from func')
func()
func()
func()
匿名函数：没有绑定名字的下场是用一次就回收了
常规版本：
def func(x,y): #func=函数的内存地址
return x+y
匿名函数版本：
res=(lambda x,y:x+y)(1,2) #x+y 相当于return x+y
print(res)
结果：3
###############################
max:求最大值
min:求最小值
map:映射
filter:过滤
sorted:排序
max的工作原理
1.首先将可迭代对象变成迭代器对象
2.res=next（可迭代对象），将res当作参数传给Key指定的函数，然后将该函数的返回值当作判断依据
#max min map filter sorted
# salaries={
# 'egon':3000,
# 'alex':100000000,
# 'wupeiqi':10000,
# 'yuanhao':2000
# }
return salaries[k]
print(max(salaries,key=func)) #next(iter_s)
#'egon',v1=func('egon')
#'alex',v2=func('alex')1#'wupeiqi',v3=func('wueiqi')
#'yuanhao',v4=func('yuanhao')
结果：alex
###############################
# salaries={
# 'egon':3000,
# 'alex':100000000,
# 'wupeiqi':10000,
# 'yuanhao':2000
# }
print(max(salaries,key=lambda k:salaries[k])) #next(iter_s),key为salaries的比较依据（可更改）
print(min(salaries,key=lambda k:salaries[k])) #next(iter_s)
################################################
# salaries={
# 'egon':3000,
# 'alex':100000000,
# 'wupeiqi':10000,
# 'yuanhao':2000
# }
#
# print(sorted(salaries,key=lambda k:salaries[k],reverse=True))
##########################
map的工作原理
1.首先将可迭代对象变成迭代器对象
2.res=next（可迭代器对象），将res当作参数传给第一个参数指定的函数，然后将该函数的返回值当作map的结果之一
names=['张明言',‘刘华强’,‘小苹果’,‘大基佬’]
# aaa=map(lambda x:x+"_SB",names)
# print(aaa)
# print(list(aaa))
# print([name+"_SB" for name in names])
# filter的工作原理
#1 首先将可迭代对象变成迭代器对象
#2 res=next(可迭代器对象),将res当作参数传给第一个参数指定的函数,然后filter会判断函数的返回值的真假,如果为真则留下res
# names=['alexSB','egon','wxxSB','OLDBOYSB']
# print([name for name in names if name.endswith('SB')])
# aaa=filter(lambda x:x.endswith('SB'),names)
# print(aaa)
# print(list(aaa))