Python教程

python函数微讲解(四)

本文主要是介绍python函数微讲解(四),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

python函数微讲解(四)

1.多层装饰器

多层装饰器顾名思义就是有多个装饰器,具体代码如下:

def outer1(func_name):
    print('我是outer1')
    def inner1():
        print('我是inner1')
        res = func_name()
        return res
    return inner1
def outer2(func_name):
    print('我是outer2')
    def inner2():
        print('我是inner2')
        res2 = func_name()
        return res2
    return inner2
def outer3(func_name):
    print('我是outer3')
    def inner3():
        print('我是inner3')
        res3 = func_name()
        return res3
    return inner3
@outer1  # 这里定义一个变量名outer2,然后调用outer1函数,参数是inner2函数名,赋值给变量名outer2,然后执行outer1,返回inner1:outer2 = outer1(inner2) inner1
@outer2  # 这里定义一个变量名outer3,然后调用outer2函数,参数是inner3函数名,赋值给变量名outer3,然后执行outer2,返回inner2:outer3 = outer2(inner3) inner2
@outer3  # 这里定义一个变量名index,然后调用outer3函数,参数是下面的index函数名,赋值给变量名index,然后执行outer3,返回inner3:index = outer3(index) inner3
def index():
    print('我是index')

调用index函数输出为:

我是outer3
我是outer2
我是outer1
我是inner1
我是inner2
我是inner3
我是index

 

2.有参装饰器

def outer(guess):  # 在最外部再加一个函数,用于给判断条件传参
    def inner(func_name):  # 这里的参数不能动,因为这里接收的是被装饰对象的函数名
        def index(*args,**kwargs):  # 这里的参数不能动,因为这里接收的是被装饰对象的传参
            if guess == '1':
                print('我是1')
            elif guess == '2':
                print('我是2')
            elif guess == '3':
                print('我是3')
            else:
                pass
            res = func_name()
            return res
        return index
    return inner


@outer('2')  # 语法糖的函数名后面加括号,先执行函数,然后在执行语法糖,所以这句的意思就是先执行outer('2'),返回inner,然后在执行@inner
def home():
    print('我是home')

装饰器最多只有三层函数,三层的用到的也很少,它的用处就是给装饰器额外的值传参。

3.函数的递归

本质:函数在运行的过程中直接或间接的调用了自己

直接调用自己:

def index():
    print('123')
    index()

这就是一个自己调用自己的一个简单例子,不过这个代码运行的话会报:“maximum recursion depth exceeded while calling a Python object”这个错误,他的意思是说“调用Python对象时超出了最大递归深度”,这里就引出来一个知识点:最大递归深度

最大递归深度

这是python解释器自带的一种应急机制,保护CPU,有些编程语言是没有这种应急机制的,他会一直运行,一直到计算机崩溃为止。

最大递归深度我们是可以算出来是多少的:

count = 0
def index():
    print('123')
    global count
    count += 1
    print(count)
    index()

一般情况下都是997、998、1000,不同的电脑可能不同,官方的回答是1000,我们可以查一下:

import sys  # 导入包
print(sys.getrecursionlimit())  # 获取默认的最大递归深度  # 1000
sys.setrecursionlimit(1500)  # 还可以修改最大递归深度

间接调用自己:

def index():
    print('111')
    home()
def home():
    print('222')
    index()
index()

看似上述两个例子是递归函数,其实不然,递归函数不是无限循环的,应该满足两个要求:

1.每一次的递归复杂度要降低,也就是下一次要比上一次简单

2.必须要有明确的结束条件

满足这两个要求的才是递归函数,我们来看一个例子:

l1 = [1, [2, [3, [4, [5, [6, [7, [8, [9, ]]]]]]]]]
'''需求:循环打印出列表中每一个数字'''

def index(l):
    for i in l:
        if type(i) == int:  # 判断元素是否是整型,是的话就输出,不是的话就执行下面的语句
            print(i)
        else:
            index(i)  # 如果不是整型,再次调用函数并传参

 

4.算法之二分法

1.什么是算法?

算法就是解决问题的有效方法。算法比较偏向于学术研究,类似于研究所。

2.什么是二分法?

二分法一般用于寻找值,当一个数据集有很多的值,我们就可以用二分法,它有一个硬性要求,就是数据集必须是有序排列的,它的原理是,寻找中间的值,与自己想要寻找的值进行比较,大的话就取左边的,小的话就取右边的,然后接着取中间的,在判断,知道找到。

l = [11, 22, 33, 44, 55, 66, 77, 88, 99, 111, 222, 333, 666, 999]
# 寻找333
def index(a,number):
    number_center = len(a) // 2  # 先找到中间值
    if len(a) == 0:
        print('找不到了')
    if a[number_center] > number:  # 如果中间值大于我们要找的值
        left_number = a[:number_center]  # 就取左边的
        print(left_number)
        index(left_number,number)  # 然后再执行函数
    elif a[number_center] < number:  # 如果中间的值小于我们要找的值
        right_number = a[number_center:]  # 就取右边的
        print(right_number)
        index(right_number,number)  # 然后再执行函数
    else:
        print('找到了')

index(l,333)

这里是IT小白陆禄绯,欢迎各位大佬的指点!!!

 

这篇关于python函数微讲解(四)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!