算法和函数框架的基础了解

今日内容

今日内容简介

• 多层语法糖内部本质
• 有参装饰器
• 递归函数
• 算法二分法
• 三元表达式
• 列表生成式

多层装饰器

1. 语法糖会将执行的函数作为被装饰的对象自动转入装饰器函数中
2. 在多层语法糖函数运行函数调用的值为顺序排序，对应函数不变，想反的是在调用函数语法糖输出值的时候由内到外输出

def outter1(func1):  #   先定义函数参数为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')
index()   ## 将index函数调用会发现函数的调用值为 
	# 执行了wrapper 1
    # 执行了wrapper 2
    # 执行力wrapper 3
在执行函数过程中先是加载outer3
————》加载outer2--->加载outer1---》执行outer函数func()res1[wrapper1]---->执行函数体代码[wrapper2]---->执行函数体代码[wrapper3]

有参装饰器

1. 在装饰器后的语法糖里面加入括号

• 比如@index('1'）优先执行函数体'1'

def outer(func):
    def inner(*args,**kwargs):
        username = input('username>>>:').strip()
        password=input('password>>>:').strip()
   if username == 'jason' and password == '10086':
    print('欢迎光临')
    res = func(*args,**kwargs)
    return res
return inner
@outer('1')
def index():
    print('i am black')       

递归函数

1. 本质上是函数的递归，在函数运行的过程中直接或者间接调用本身函数

直接调用本身
def index():
    print('这是函数本身')
    index()
index()
## 注意在无打断函数的情况下直接递归函数的上限在1000左右
#### 一定要注意无限调用如果运行解释器没有上限会出现cpu崩溃的情况
间接调用
def index():
    print('被间接调用的函数')
    func
def func():
    print('互相调用函数')
    index()
func()   # 调用func
 由于func是调用函数index的吗，没有打断依旧
* import sys
print(sys.getrecursionlimit())
用于查询调用上限
当然也可以通过sys.setrecursionlimit(2000) 进行修改

函数的递归不应该是无序循环 递归同样遵循两个要素

1. 每次递归复杂度降低
2. 必须要有明确结束条件

举例相比于上一次的递归必须一致
def func(x):
    if x == 2:   # 定义条件
        return 22   # 有明确的结束条件 
    return func(n-1)+2
print(func(3))
2. 循环打印内容
l1 = [A,S,SD,FQ,WEQ,F,XZ,AH,AJ,ASD,QD,]
def number(l)：
	for i in l:# 自带结束条件 并且每次传入的数据都比上一次简单
        if isinstance(i,int)：# 判断某个数据是否属于某个类型
        	print(i)
      	else：
        	number(i)
number(l1)

算法:二分法

1. 算法是一种解决问题的简易方法

2. 算法比较倾向于学术研究产出很少

3. 二分法是将数据分析的大数据进行细分拦腰切

4. 二分法原理
   获取数据集中间的元素 比对大小
   如果中间的元素大于目标数据 那么保留数据集的左边一半
   如果中间的元素小于目标数据 那么保留数据集的右边一半
   然后针对剩下的数据集再二分
   如果中间的元素大于目标数据 那么保留数据集的左边一半
   如果中间的元素小于目标数据 那么保留数据集的右边一半

l1 = [11,22,33,44,55,66,77,88,99,100]
def num(l1,num1):
    if len(l1) == 0:
        print('该目标不存在')
        return
    #  取中间值————————》
    middle_index = len(l1) // 2
    # 判断中间索引对应的数据和目标数据大小————》
    if num1 > l1[middle_index]:
        
   # 保留数据集右侧
		l1_left = l1[middle_index+1:]
    	print(l1_left)
        num(l1_left,num1)
    elif num1 < l1[:middle_index]:
    # 保留数据集左侧
    	l1_right = l1[:middle_index]
    	peint(li_right)
    # 对右侧继续二分重复执行相同代码，降低复杂程度
    	num(l1_right,num1)
    else:
        print('数据已经找到'，num1)
num(l1,33)

缺陷：1.寻找数据在数据集前端寻找会非常麻烦

2. 数据集必须有顺序，无序排列只会添加难度