python函数基础算法简介

目录

• 一.多层语法糖本质
• 二.有参装饰器
• 三.递归函数
  • 3.1正确编写方式
• 四.算法之二分法

一.多层语法糖本质

""" 语法糖会将紧挨着的被装饰对象名字当参数自动传入装饰器函数中"""

def outter(func_name):
    print('加载outter')
    def wrapper(*args, **kwargs):
        print('执行了wrapper')
        res = func_name(*args, **kwargs)
        return res
    return wrapper

def outter1(fun_name1):
    print('加载了outter1')
    def wrapper1(*args, **kwargs):
        print('执行了wrapper1')
        res1 = fun_name1(*args, **kwargs)
        return res1
    return wrapper1

def outter2(fun_name2):
    print('执行了outter2')
    def wrapper2(*args, **kwargs):
        print('执行了wrapper2')
        res2 = fun_name2(*args, **kwargs)
        return res2
    return wrapper2
@outter
@outter1
@outter2
def index():
    print('from index')
index()
结果：
执行了outter2
加载了outter1
加载outter
执行了wrapper
执行了wrapper1
执行了wrapper2
from index

二.有参装饰器

一个模板
def outer(source_data):
    def login_autn(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_autn
@outer('3')   #函数名+括号执行优先级别最高
def user():
    print('我随便写的')
user()
结果：
username>>:thn   #加密无判断
password>>:123   #加密无判断
使用某些方式处理
我随便写的

三.递归函数

递归函数的本质：自己直接或者简介的调用了自己本身
"""直接调用本身"""

def index():
    print('我自己')
    index()
index()
结果是997~1000个‘我自己’加报错
997~1000就是python中最大递归深度
"""可以调"""

"""间接调用本身"""

def index():
   print('你好')
   func()
def func():
   print('我不好')
   index()
func()
结果同理：我调用的是func所以‘我不好’开头交叉出现1000个左右的 ‘我不好’and‘你好’等

3.1正确编写方式

几排保龄球的数量
第一排 = 第二排+3
第二排 = 第三排+3
第三排 = 第四排+3
第四排 = 10
函数形式
line_up(4) = list_up(2)+3
line_up(3) = line_up(3)+3
line_up(2) = line_up(4)+3
line_up(1) = 10
def line_up(a):
    if a == 1:
        return 10
    return line_up((a-1))+3
print(line_up(4))
结果：19
结果是由内而外

四.算法之二分法

算法：有效解决办法的各种方法
二分法 : 一定要有先后顺序排列
简单来说就是一大串串数字从中间要某一个值，进行一大串数字的一分为2，然后进行判断左侧还是右侧大小，如果若没有就在重复的切割直到找到你那个值为止

l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]
"""我需要后边还可以继续延伸"""
我需要17
def get_target(l1,target_num):
    # 找不到的情况下是不会一直重复下去的
    if len(l1) == 0:
        print('没有')
        return
    # 获取中间的索引值（只能为整数）
    middle_index = len(l1) // 2
    # 判断中间索引值对应数据的大小
    if target_num > l1[middle_index]:
        # 保留数据的右边
        l1_left = l1[middle_index+1:]
        # 对右侧进行切割 重复代码 复杂度降低
        print(l1_left)
        get_target(l1_left, target_num)
    elif target_num < l1[middle_index]:
        # 保留左侧数据
        l1_right = l1[:middle_index]
        print(l1_right)
        # 重复右侧切割 重复代码 再次降低复杂
        get_target(l1_right, target_num)
    else:
        print('找到了', target_num)
get_target(l1,17)
结果是：
[12, 13, 14, 15, 16, 17, 18, 19, 20, 21]
找到了 17