多层装饰器
语法糖会将紧挨着的被装饰对象的名字当做参数自动传入装饰器函数中
# 判断七句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()
# 校验用户数据 数据的来源可以有很多 比如全局字典 全局列表 文本文件 数据库
# 数据的来源不同 处理方式就不同 对应的代码编写就不一样
# 分支结构处理 然后根据不同的参数提示 匹配不同的流程
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('3') 返回值是login_auth
在执行语法糖结构 @login_auth
发现最后还是一个普通的装饰器
有参装饰器目的仅仅是给装饰器传递额外的参数
"""
@outer('3')
def index():
print('from index')
递归函数
本质:递归函数也称为函数的递归
函数在运行过程中直接或者间接的调用了自身
- 直接调用自己
def index():
print('from index')
index()
index()
maximum recursion depth exceeded while calling a Python object
最大递归深度超出限制了 python解释器自带的应急机制
2. 间接调用自己
def index():
print('from index')
func()
def func():
print('from func')
index()
func()
maximum recursion depth exceeded while calling a Python object
这对python最大递归深度
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 = [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写一些算法
二分法 快排 插入 冒泡 堆排序
上述知识面试之前临时抱佛脚即可 平时无需过多研究
"""