python装饰器和递归函数
多层装饰器
'语法糖会将紧挨着的被装饰对象的名字当做参数自动传入装饰器函数中'
#代码示例：
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')
#输出结果：
加载了outter3
加载了outter2
加载了outter1
执行了wrapper1
执行了wrapper2
执行了wrapper3
from index
#小结：
多层装饰器在装饰的时候，它的顺序是由下往上，而在执行的时候，它的顺序由上到下
有参装饰器
参考代码一
def auth(db_type):
def deco(func): # 不能动 只能接收一个被装饰对象名字
def wrapper(*args, **kwargs): # 不能动 是专门用来给被装饰的对象传参的
name = input('your name>>>: ').strip()
pwd = input('your password>>>: ').strip()
# 校验用户数据 数据的来源可以有很多 比如全局字典 全局列表 文本文件 数据库
# 数据的来源不同 处理方式就不同 对应的代码编写就不一样
# 分支结构处理 然后根据不同的参数提示 匹配不同的流程
if db_type == 'file':
print('基于文件的验证')
if name == 'jason' and pwd == '123':
res = func(*args, **kwargs) # index(1,2)
return res
else:
print('user or password error')
elif db_type == 'mysql':
print('基于mysql的验证')
elif db_type == 'ldap':
print('基于ldap的验证')
else:
print('不支持该db_type')
return wrapper
return deco
@auth(db_type='file') # @deco # index=deco(index) # index=wrapper
def index(x, y):
print('index->>%s:%s' % (x, y))
@auth(db_type='mysql') # @deco # home=deco(home) # home=wrapper
def home(name):
print('home->>%s' % name)
@auth(db_type='ldap') # 账号密码的来源是ldap
def transfer():
print('transfer')
# index(1, 2)
# home('egon')
# transfer()
参考代码二
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
发现最后还是一个普通的装饰器
有参装饰器目的仅仅是给装饰器传递额外的参数
装饰器最多就三层嵌套
并且三层嵌套的结构使用频率不高(最多是使用别人写好的有参装饰器)
from functools import wraps
@wraps(func_name)
"""
@outer('3')
def index():
print('from index')
有参装饰器模板
def 有参装饰器(x,y,z):
def outter(func):
def wrapper(*args, **kwargs):
res = func(*args, **kwargs)
return res
return wrapper
return outter
@有参装饰器(1,y=2,z=3)
def 被装饰对象():
pass
递归函数
"""
函数的递归不应该是无限循环的过程 真正的递归函数应该要满足两个要求
1.每次递归 复杂度必须降低(下一次递归要比上一次递归解答)
大白话 越往下递归应该离解决问题的答案越近
2.必须要有明确的结束条件
"""直接或间接调用函数本身，则该函数称为递归函数
#代码示例：
def fact(n):
if n == 1:
return 1
return n * fact(n - 1)
print(fact(5)) # 输出结果: 120
print(fact(1)) # 输出结果: 1
"""
maximum recursion depth exceeded while calling a Python object
最大递归深度超出限制了 python解释器自带的应急机制
在有些编程语言中 甚至没有遇警机制 代码执行真的一致到计算机崩溃为止
"""
import sys
print(sys.getrecursionlimit()) # 获取默认的最大递归深度 # 1000
sys.setrecursionlimit(2000) # 还可以修改最大递归深度
"""
maximum recursion depth exceeded while calling a Python object
这对python最大递归深度
回答997 998 1000都可以
官方给出的是1000
"""
#函数的递归不应该是无限循环的过程 真正的递归函数应该要满足两个要求
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循环
ps:重复做一些事情 但是每次都比上一次简单一些 >>>: 递归函数
"""
def get_num(l):
for i in l: # 自带结束条件 并且每次传入的数据都比上一次简单
if isinstance(i,int): # 判断某个数据是否属于某个类型
print(i)
else:
get_num(i)
get_num(l1)
递归练习二
#代码示例：
def fact(n):
if n == 1:
return 1
return n * fact(n - 1)
print(fact(5)) # 输出结果: 120
面就是一个递归函数.
如果我们计算fact(5), 可以根据函数定义看到计算过程如下:
==> fact(5)
==> 5 * fact(4)
==> 5 * (4 * fact(3))
==> 5 * (4 * (3 * fact(2)))
==> 5 * (4 * (3 * (2 * fact(1))))
==> 5 * (4 * (3 * (2 * 1)))
==> 5 * (4 * (3 * 2))
==> 5 * (4 * 6)
==> 5 * 24
==> 120
'''使用递归函数的优点是逻辑简单清晰
缺点是过深的调用会导致栈溢出(即比较占用内存空间)'''
算法之二分法
# 什么是算法?
算法其实就是解决问题的有效方法
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写一些算法
二分法 快排 插入 冒泡 堆排序
上述知识面试之前临时抱佛脚即可 平时无需过多研究
"""
#代码示例：
nums = [1, 2, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 10, 11, 11, 11,
11, 12, 13, 13, 15, 16, 16, 20, 21, 21, 23, 24, 26,
26, 27, 28, 28, 31, 33, 33, 34, 35, 38, 38, 39, 40,
42, 43, 45, 45, 46, 46, 47, 47, 51, 52, 52, 53, 53,
55, 55, 56, 56, 57, 57, 57, 58, 59, 61, 62, 64, 66,
66, 67, 68, 69, 69, 71, 72, 72, 74, 74, 75, 76, 78,
78, 79, 79, 79, 79, 80, 82, 85, 88, 89, 90, 90, 91,
91, 91, 94, 99, 99]
def find(nums,number):
mid = len(nums) // 2
if len(nums) == 0:
print("没找到")
return
elif number > nums[mid]:
nums_left = nums[mid+1:]
print(nums_left)
find(nums_left,number)
elif number < nums[mid]:
nums_right = nums[:mid]
print(nums_right)
find(nums_right, number)
else:
print("找到了")
find(nums,66)
浙公网安备 33010602011771号