递归，二分法，生成式

函数的递归

递归：直接或者间接的调用其他函数

分为两种调用方式：

直接调用本身

def f1():
    print('是我是我还是我')
    f1()
f1()

间接调用本身

def f1():
	print('===>f1')
    f2()
def f2():
	print('===>f2')
    f1()
    
f1()

一段代码的循环运行的方案有两种

# 方式一：while 循环、for循环
while True:
    print(1111)
    print(2222)
    print(3333)
# 方式二：# 递归的本质就是循环
def f1():
    print(1111)
    print(2222)
    print(3333)
    f1()

f1()

#递归不应该无限地调用下去，必须在满足某种条件下结束递归调用
n=0
while n<10:
    print(n)
    n+=1
    
递归方式：
def f1(n):
    if n==10:
        return
    n+=1
    f1(n)
    
f1(0)

递归的两个阶段

回溯：一层一层调用下去

递推：满足某种结束条件，结束递归调用，然后一层一层返回

age(5)=age(4)+10
age(4)=age(3)+10
age(3)=age(2)+10
age(2)=age(1)+10
age(1)=18

def age(n):
    if n==1:
        return 18
    return age(n-1)+10

res=age(5)
print(res)

递归的应用

l=[1,2[3,4[5,6[7,8[9,10,11[12,]]]]]]

def f1(list1):
    for x in list1:
        if type(x) is list:
            # 如果是列表本身，应该在循环，再判断，即重新运行代码本身
            f1()
        else:
            print(x)
            
f1(l)

算法之二分法

二分法的使用场景：让你在一个列表中查找某个数字是不是存在

l = [11, 2, 3, 43, 55, 67, 23, 45, 45, 88, 99, 66,]

查找66这个数字是否在列表l中

思路：遍历列表l一个一个去比较，如果比较到了，就是找到了，否则，就是没找到

    for i in l:
        if i == 66:
            print('找到了')

二分法的原理：1. 列表必须先排序(从小到大，从大到小)，2. 折半查找

l = [11, 2, 3, 43, 55, 67, 23, 45, 45, 88, 99, 66,]
# 1. 排序
l.sort()
# 2. 去列表的中间那个值，然后给66比较
target_num = 200
def my_half(l,target_num):
    if len(l) == 0:
        print('没找到')
        return
    # 3. 取的就是中间的那个索引
    middle_index = len(l) // 2 # 向下取整 5 // 2 == 2  6 // 2 == 3
    if target_num > l[middle_index]:
        l_right = l[middle_index+1:]  #
        print(l_right)
        my_half(l_right, target_num)

    elif target_num < l[middle_index]:
        l_left = l[:middle_index]
        print(l_left)
        my_half(l_left, target_num)
    else:
        print('找到了')

my_half(l, target_num)

三元表达式

# 写一个比较两个数大小的函数，返回大的
def my_max(a, b):
    if a >b:
        return a
    else
    	return b
    
# 对于只有二选一的情况，我们推荐使用三元表达式
"""
	语法结构:
		res = 条件成立之后的结果 if 条件 else 条件不成立之后的结果
"""

def my_max(a, b):
    return a if a > b else b
res = my_max(1, 2)

# res = '不出去玩' if '下雨' else '出去玩'
# print(res)

# res = '扯淡' if 2 > 10 else 10
# print(res)

"""还支持嵌套"""
## 不推荐写太多的嵌套，一般两层就够了，超过两层了，建议不这样写，面试的时候：成数非常多
res = 2 if 2 > 10 else ( 10 if False else (100 if 10 > 5 else (2 if False else 1)))
print(res)

列表生成式

# 列表生产式
l=['egon_dsb','liu_dsb','wxx_dsb'] #需求：把 名字带有dsb的都提取出来
new_l=[]
for name in l :
    if name.endswith('dsb'):
        new_l.append(name)
print(new_l)

#修改后
new_l=[name for name in l if name.endswith('dsb')]
print(new_l)

其他生成式

l1 = ['name', 'age', 'gender']
l2 = ['oscat', 18, 'male']

# d= {'name':oscat, age:18, 'gender':'male'}

# d = {}
# for i in range(len(l1)):
#     d[l1[i]] = l2[i]
#
# print(d) # {'name': 'oscat', 'age': 18, 'gender': 'male'}

"""
补充一个方法：enumarate
"""

# for i, j in enumerate(l1):
#     # (0, 'name')
#     # (1, 'age')
#     # (2, 'gender')
#     print(i, j)

d = {l1[i]:l2[i] for i, j in enumerate(l1)}
print(d) # 0: 'name', 1: 'age', 2: 'gender'}

"""没有元组生成式"""
s = {i for i, j in enumerate(l1)} # 生成器
print(s)

t = (i for i, j in enumerate(l1))
print(t)