今日内容概要

• 
  

  多层语法糖内部实质

  
  


• 
  

  有参装饰器

  
  


• 
  

  递归函数

  
  


• 
  

  算法之二分法

  
  

 

今日内容详细

一、多层语法糖内部实质

"""语法糖会将紧挨着的被装饰对象的名字当做参数自动传入装饰器函数中""" 比如举个例子来解释一下这段化的意思：
   判断下面七句print执行的顺序即可搞懂多层语法糖的用法
   多层语法糖如何解读：装饰顺序由下往上 遇到最后一个才会是使用与函数名相同的变量名传给装饰器函数调用
def outter1(func1):
   print('加载了outter1')
   def wrapper1(*args, **kwargs):
       print('执行了wrapper1')
       res1 = func1(*args, **kwargs)
       return res1
   return wrapper1
​
def outter2(func2):
   print('加载了outter2')
   def wrapper2(*args, **kwargs):
       print('执行了wrapper2')
       res2 = func2(*args, **kwargs)
       return res2
   return wrapper2
​
def outter3(func3):
   print('加载了outter3')
   def wrapper3(*args, **kwargs):
       print('执行了wrapper3')
       res3 = func3(*args, **kwargs)
       return res3
   return wrapper3
​
​
@outter1
@outter2
@outter3
def index():
   print('from index')
   
   

二、有参装饰器

def outer(source_data):
   def login_auth(func_name):
       def inner(*args,**kwargs):
           username =input('username>>>>:').strip()
           password =input('password>>>>>:').strip()
# 思路：1.判断用户数据 数据的来源可以有很多 比如全局字典 全局列表 文本文件 数据库等
2.因为数据的来源不同 那么问题来了相应的处理方式也是不同的 那么对应的代码编写也是不一样的
3.根据不同的参数提示 需要匹配不同的流程 这里我可以联想到用分支结构处理
            if source_data =='1':
      print('使用字典的方式处理数据')
            elif source_data =='2':
                   print('使用列表的方式处理数据')
            elif source_data == '3':
               print('使用文件操作处理数据')
             else：
                print('其他操作情况')
               res = func_name(*args,**kwargs)
              return res
       return inner
   return login_auth
'''''''
函数名加括号 执行优先级最高
​
@outer('3')
  左侧是@outer是语法糖结构 右侧outer('3')是函数名加括号结构
   根据函数名加括号执行优先级最高，所以先执行函数调用 outer('3') 返回值是login_auth
   在执行语法糖结构 @login_auth
   由此发现还是一个普通的装饰器
有参装饰器目的仅仅是给装饰器传递额外的参数 原因是在其他函数形参中都不能动了 都不能添加了，所以只能新定义一个函数 专门添加额外的参数

三、递归函数

# 本质：递归函数也称为函数的递归
 函数在运行过程中直接或间接的调用了自身
 大白话：自己调用了自己
def index():
   print('from index')
   index()
index()   # 会报错 maximum recursion depth exceeded while calling a Python object
""""""  表示：最大递归深度超出限制了 python解释器自带的应急机制
在有些编程语言中 甚至没有遇警机制 代码执行真的会一直到计算机崩溃为止
​
​
间接调用自己
def index():
   print('from index')
   func()
def func():
   print('from func')
   index()

func()
""'""'
maximum recursion depth exceeded while calling a Python object
   这对python最大递归深度 回答 997 998 1000都可以
   官方给出的是1000
   
   import sys
   print(sys.getrecursionlimit())  # 获取默认的最大递归深度 # 1000
   sys.setrecursionlimit(2000)  # 还可以改最大递归深度
   比如：
   count = 1
   def index():
       print('from index')
       global count
       print(count)
       count += 1
       index()
    index()
   
   """"""
   函数的递归不应该是无限循环的过程 真正的递归函数应该满足两个要求：
   1.每次递归 复杂度必须降低(下一次递归要比上一次递归简单)
   大白话就是说越往下递归应该离解决问题的答案越近
   2.必须是有要有明确的结束条件
   
   

   
   
​
​
​

四、 递归函数的应用

需求：我们想知道坐在第一排的某个学生年龄过程：
我们问他多大了 他没有直接告知我们 说比后面那个同学大两岁
  后面的同学说比他后面的大两岁
   问到最后一排时 终于开口说是18岁
   知道租后一排的年龄回推即可知道第一排那个同学的年龄
   递推：是指一层层往下推
   回溯：根据最后的结果去推结论
   
# 如何编写代码完成
# 目标人物的年龄 = 后一排的年龄 +2
# 后一排的年龄 = 后后一排年龄 +2
# 后后一排的年龄 = 后后后一排的年龄 + 2
# 最后一排的年龄 = 18
 # 将年龄问题编程代码函数
# age(5) = age(4) +2
# age(4) = age(3) +2
# age(3) = age(2) +2
# age(2) = age(1) +2
# age(1) = 18
​
将以上代码封装成函数
def get_age(n):
   if n == 1:
       return 18  # 有明确的结束条件
    return get_age(n-1) +2
print(get_age(4))
""注意:对于递归函数千万不要想的太复杂 只要记住嵌套图即可 有结果就是由内而外一层层的剥开
   

五、递归函数练习

l1 = [1,[2,[3,[4,[5,[6,[7,[8,[9]]]]]]]]]
""需求：循环打印出列表中每一个数字
# 写代码之前一定要先理清思路
​
完整思路：
1.for循环大列表
2.判断元素是否是数字 如果是则打印
3.如果不是则for循环
4.判断元素是否是数字 如果是则打印
5.如果不是则for循环
6.判断元素是否是数字 如果是则打印
7.如果不是则for循环
注意：重复做一些事情 但是每次都比上一次简单一些 >>>>>联想到递归函数
def get_num(l):
   for i in l:  # 因为for自带结束条件 并且每次传入的数据都比上一次简单
       if isinstance(i,int):  # 判断某个数据是否属于某个类型
           print(i)
        else:
           get_num(i)
get_num(l1)
​
​
​

六、算法之二分法

# 什么是算法?
算法其实就是解决问题的有效方法
eg:比如打开易拉罐的问题
    方法1:使用金属撬棍
       方法2:直接手扣
       方法3:一阳指戳
      ...
 """
算法比较偏向于学术研究 很枯燥 并且产出很少
甚至只有非常大的互联网公司才会有算法部分
算法工程师薪资待遇很高 但是产出很少
有时候甚至几年都没有任何的成果 有点类似于研究所!!!
"""
​
# 算法之二分法
二分法是算法里面最入门的一个 主要是感受算法的魅力所在
 # Author:Jason
"""二分法使用有前提: 数据集必须有先后顺序(升序 降序)"""
l1 = [13,21,35,46,52,67,76,87,99,123,213,321,432,564,612]
# 查找一个数 123
"""
二分法原理
  获取数据集中间的元素 比对大小
      如果中间的元素大于目标数据 那么保留数据集的左边一半
      如果中间的元素小于目标数据 那么保留数据集的右边一半
  然后针对剩下的数据集再二分
      如果中间的元素大于目标数据 那么保留数据集的左边一半
      如果中间的元素小于目标数据 那么保留数据集的右边一半
  ...
"""
def get_target(l1,target_num):
   # 最后需要考虑找不到的情况 l1不可能无限制二分
   if len(l1) == 0:
       print('不好意思 真的没有 找不到')
       return
   # 1.获取中间元素的索引值(只能是整数)
   middle_index = len(l1) // 2
   # 2.判断中间索引对应的数据与目标数据的大小
   if target_num > l1[middle_index]:
       # 3.保留数据集右侧
       l1_left = l1[middle_index+1:]
       # 3.1.对右侧继续二分 重复执行相同代码 并且复杂度降低
       print(l1_left)
       get_target(l1_left,target_num)
   elif target_num <l1[middle_index]:
       # 4.保留数据集左侧
       l1_right = l1[:middle_index]
       print(l1_right)
       # 4.1.对右侧继续二分 重复执行相同代码 并且复杂度降低
       get_target(l1_right,target_num)
   else:
       print('找到了',target_num)
# get_target(l1,432)
# get_target(l1,22)
get_target(l1,13)
"""
二分法的缺陷
  1.如果要找的元素就在数据集的开头 二分更加复杂
  2.数据集必须有顺序
目前没有最完美的算法 都有相应的限制条件
"""
"""
以后面试的时候 可能会让你手用python写一些算法
  二分法 快排 插入 冒泡 堆排序
      上述知识面试之前临时抱佛脚即可 平时无需过多研究
"""