一、递归函数

1、递归的定义

函数的递归调用：是函数嵌套调用的一种特殊形式
具体是指：
在调用一个函数的过程中又直接或者间接地调用到本身

1.1 直接调用本身

  1. def f1():
  2.     print('是我是我还是我')
  3.     f1()
  4. f1()

1.2 间接接调用本身

  1. def f1():
  2.     print('===>f1')
  3.     f2()
  5. def f2():
  6.     print('===>f2')
  7.     f1()
  9. f1()

一段代码的循环运行的方案有两种
方式一：while、for循环
while True:
print(1111)
print(2222)
print(3333)

方式二：递归的本质就是循环：
def f1():
print(1111)
print(2222)
print(3333)
f1()
f1()

2、需要强调的的一点是：

递归调用不应该无限地调用下去，必须在满足某种条件下结束递归调用

  1. n=0
  2. while n < 10:
  3.     print(n)
  4.     n+=1
  7. def f1(n):
  8.     if n == 10:
  9.         return
  10.     print(n)
  11.     n+=1
  12.     f1(n)
  14. f1(0)

3、递归的两个阶段

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

  1. age(5) = age(4) + 10
  2. age(4) = age(3) + 10
  3. age(3) = age(2) + 10
  4. age(2) = age(1) + 10
  5. age(1) = 18
  7. def age(n):
  8.     if n == 1:
  9.         return 18
  10.     return age(n-1) + 10
  13. res=age(5)
  14. print(res)

4、递归的应用

  1. l=[1,2,[3,[4,[5,[6,[7,[8,[9,10,11,[12,[13,]]]]]]]]]]
  3. def f1(list1):
  4.     for x in list1:
  5.         if type(x) is list:
  6.             # 如果是列表，应该再循环、再判断,即重新运行本身的代码
  7.             f1(x)
  8.         else:
  9.             print(x)
  11. f1(l)

二、二分法

算法：是高效解决问题的办法
算法之二分法

需求：有一个按照从小到大顺序排列的数字列表
需要从该数字列表中找到我们想要的那个一个数字
如何做更高效？？？

nums=[-3,4,7,10,13,21,43,77,89]
find_num=10

nums=[-3,4,13,10,-2,7,89]
nums.sort()
print(nums)

方案一：整体遍历效率太低

  1. nums=[-3,4,7,10,13,21,43,77,89]
  2. find_num=10
  4. for num in nums:
  5.     if num == find_num:
  6.         print('find it')
  7.         break

方案二：二分法
# def binary_search(find_num,列表):
# mid_val=找列表中间的值
# if find_num > mid_val:
# # 接下来的查找应该是在列表的右半部分
# 列表=列表切片右半部分
# binary_search(find_num,列表)
# elif find_num < mid_val:
# # 接下来的查找应该是在列表的左半部分
# 列表=列表切片左半部分
# binary_search(find_num,列表)
# else:
# print(‘find it’)

  1. nums=[-3,4,7,10,13,21,43,77,89]
  2. find_num=8
  3. def binary_search(find_num,l):
  4.     print(l)
  5.     if len(l) == 0:
  6.         print('找的值不存在')
  7.         return
  8.     mid_index=len(l) // 2
  10.     if find_num > l[mid_index]:
  11.         # 接下来的查找应该是在列表的右半部分
  12.         l=l[mid_index+1:]
  13.         binary_search(find_num,l)
  14.     elif find_num < l[mid_index]:
  15.         # 接下来的查找应该是在列表的左半部分
  16.         l=l[:mid_index]
  17.         binary_search(find_num,l)
  18.     else:
  19.         print('find it')
  21. binary_search(find_num,nums)

三、面相过程编程思想

编程思想/范式

面向过程的编程思想：
核心是”过程”二字，过程即流程，指的是做事的步骤：先什么、再什么、后干什么
基于该思想编写程序就好比在设计一条流水线

优点：复杂的问题流程化、进而简单化
缺点：扩展性非常差

面向过程的编程思想应用场景解析：
1、不是所有的软件都需要频繁更迭：比如编写脚本
2、即便是一个软件需要频繁更迭，也不并不代表这个软件所有的组成部分都需要一起更迭

四、匿名函数

1、def用于定义有名函数

func=函数的内存地址
def func(x,y):
return x+y

print(func)

2、lamdab用于定义匿名函数

print(lambda x,y:x+y)

3、调用匿名函数

方式一：
res=(lambda x,y:x+y)(1,2)
print(res)

方式二：
func=lambda x,y:x+y
res=func(1,2)
print(res)

4、匿名用于临时调用一次的场景：

更多的是将匿名与其他函数配合使用

5、应用场景

  1. salaries={
  2.     'siry':3000,
  3.     'tom':7000,
  4.     'lili':10000,
  5.     'jack':2000
  6. }
  7. #需求1：找出薪资最高的那个人=》lili
  8. res=max([3,200,11,300,399])
  9. print(res)
  11. res=max(salaries)
  12. print(res)
  1. salaries={
  2.     'siry':3000,
  3.     'tom':7000,
  4.     'lili':10000,
  5.     'jack':2000
  6. }
  7. # 迭代出的内容    比较的值
  8. # 'siry'         3000
  9. # 'tom'          7000
  10. # 'lili'         10000
  11. # 'jack'         2000
  13. # def func(k):
  14. #     return salaries[k]
  16. # ========================max的应用
  17. res=max(salaries,key=func) # 返回值=func('siry')
  18. print(res)
  20. # res=max(salaries,key=lambda k:salaries[k])
  21. # print(res)
  23. # ========================min的应用
  24. # res=min(salaries,key=lambda k:salaries[k])
  25. # print(res)
  1. # ========================sorted排序
  2. salaries={
  3.     'siry':3000,
  4.     'tom':7000,
  5.     'lili':10000,
  6.     'jack':2000
  7. }
  8. res=sorted(salaries,key=lambda k:salaries[k],reverse=True)
  9. print(res)

========================map的应用(了解)

  1. l=['alex','lxx','wxx','薛贤妻']
  2. new_l=(name+'_dsb' for name in l)
  3. print(new_l)
  5. res=map(lambda name:name+'_dsb',l)
  6. print(res) # 生成器

========================filter的应用（了解）

  1. l=['alex_sb','lxx_sb','wxx','薛贤妻']
  2. res=(name for name in l if name.endswith('sb'))
  3. print(res)
  5. res=filter(lambda name:name.endswith('sb'),l)
  6. print(res)

========================reduce的应用(了解)

  1. from functools import reduce
  2. res=reduce(lambda x,y:x+y,[1,2,3],10) # 16
  3. print(res)
  5. res=reduce(lambda x,y:x+y,['a','b','c']) # 'a','b'
  6. print(res)

五、函数的类型提示

  1.            str  int   ('play','music')
  2. def register(name:str,age:int,hobbbies:tuple)->int:
  3.  print(name)
  4.  print(age)
  5.  print(hobbbies)
  6.  return 111
  8. # register(1,'aaa',[1,])
  9. res=register('egon',18,('play','music'))
  1. def register(name:str='egon',age:int=18,hobbbies:tuple=(1,2))->int:
  2.  print(name)
  3.  print(age)
  4.  print(hobbbies)
  5.  return 111
  7. # register(1,'aaa',[1,])
  8. # res=register('egon',18,('play','music'))
  9. res=register()
  1. def register(name:"必须传入名字傻叉",age:1111111,hobbbies:"必须传入爱好元组")->"返回的是整型":
  2.  print(name)
  3.  print(age)
  4.  print(hobbbies)
  5.  return 111
  7. # register(1,'aaa',[1,])
  8. # res=register('egon',18,('play','music'))
  9. # res=register('egon',19,(1,2,3))
  11. print(register.__annotations__)