python的递归，闭包，装饰器，以及继承类的方法

1夜的终章1

已于 2025-04-02 15:12:56 修改

阅读量372

点赞数

文章标签： python 开发语言

于 2020-12-07 00:04:20 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_45668674/article/details/110789627

版权

本文探讨了Python中装饰器的应用，包括带参数及无参数的装饰器使用方法，并详细解析了类方法重写时如何正确调用父类方法的不同方式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

递归

递归就是自己调用自己，最经典的递归案例是青蛙跳台阶问题(斐波那契)

def jumping_stairs(stairs_num):
    """
    青蛙跳台阶/斐波那契
    :param stairs_num: 台阶数
    :return: 
    """
    if stairs_num <= 3:
        return stairs_num
    return jumping_stairs(stairs_num - 1) + jumping_stairs(stairs_num - 2)

闭包

函数嵌套
内部函数必须使用了外部函数的变量或者参数
外部函数返回内部函数的引用(也就是函数名) 这个使用了外部函数变量的内部函数称为闭包

装饰器

装饰器实质上也是一个闭包函数，也就是说，他也是一个函数嵌套。可以在不改变原函数的情况下，对已有函数进行额外的功能扩展。
装饰器就是特殊的闭包函数(特殊在外面函数的参数为一个函数的引用，也是就是外面的大函数传递的是被装饰函数的引用。这个函数的引用会在里面函数调用)

被装饰的函数带参数(很简单，内函数和被装饰的函数带相同的参数即可)

# 不带返回值的
import time
def showtime(func):
    def wrapper(a, b):
        start_time = time.time()
        func(a,b)
        end_time = time.time()
        print('spend is {}'.format(end_time - start_time))

    return wrapper

@showtime #add = showtime(add)      add() = showtime(add)()  
def add(a, b):
    print(a+b)
    time.sleep(1)

@showtime #sub = showtime(sub)      sub() = showtime(sub)()
def sub(a,b):
    print(a-b)
    time.sleep(1)

add(5,4)
sub(3,2)


# 带返回值的

import time
def showtime(func):
    def wrapper(a, b):
        start_time = time.time()
        func(a,b)
        end_time = time.time()
        print('spend is {}'.format(end_time - start_time))
        return '被装饰函数的返回值 {}'.format(end_time - start_time)
    return wrapper

@showtime #   add = showtime(add)     add() = showtime(add)()
def add(a, b):
    print("a+b", a+b)
    time.sleep(1)

@showtime #   sub = showtime(sub)     sub() = showtime(sub)()
def sub(a,b):
    print("a-b", a-b)
    time.sleep(1)

print(add(5,4))
print(sub(3,1))

被装饰的函数不带参数(内函数和被装饰的函数均不带参数即可)

import time
def showtime(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print('spend is {}'.format(end_time - start_time))

    return wrapper

@showtime  #foo = showtime(foo)   foo() = showtime(foo)()
def foo():
    print('foo..')
    time.sleep(3)

@showtime #doo = showtime(doo)     doo() = showtime(doo)()
def doo():
    print('doo..')
    time.sleep(2)

foo()
doo()

装饰器函数带参数（三层嵌套即可）

import time
def time_logger(flag = 0):
    def showtime(func):
        def wrapper(a, b):
            start_time = time.time()
            func(a,b)
            end_time = time.time()
            print('spend is {}'.format(end_time - start_time))

            if flag:
                print('将此操作保留至日志')

        return wrapper

    return showtime

@time_logger(2)  #得到闭包函数showtime,add = showtime(add)
def add(a, b):
    print(a+b)
    time.sleep(1)

add(3,4)

类继承之后重写方法时，继承父类的方法里面的内容

总的来说有三种方法
方法 1
父类名.init(self, 父类同类参数)
父类名.method(self, 父类同类参数)
父类名.init(self, 参数) 父类名； ()中一定有 self +参数

方法2
super(子类名，self).init(父类同类参数)
super(子类名，self).method(父类同类参数)
super(子类名,self).init(参数) 子类名；（）中参数一定没self

方法3
super().init(父类同类参数)
super().method(父类同类参数)
super().init(参数) （）中参数一定没self

方法1

没有参数

class TestClass1():
    def __init__(self):
        print("我是父类__init方法__里面的动作")



class TestClass2(TestClass1):
    def __init__(self):
        super(TestClass2, self).__init__()
        print("我是子类__init__重写后自己实现的动作")

a = TestClass2()

一个参数

class TestClass1():
    def __init__(self, arg):
        print(arg)
        print("我是父类__init方法__里面的动作")

class TestClass2(TestClass1):
    def __init__(self, arg):
        super(TestClass2, self).__init__(arg)
        print(arg)
        print("我是子类__init__重写后自己实现的动作")

a = TestClass2("参数")

两个参数

class TestClass1():
    def __init__(self, arg, arg2):
        print(arg)
        print("我是父类__init方法__里面的动作")



class TestClass2(TestClass1):
    def __init__(self, arg, arg2):
        super(TestClass2, self).__init__(arg, arg2)
        print(arg)
        print("我是子类__init__重写后自己实现的动作")

a = TestClass2("参数", "参数2")

方法2

无参数

class TestClass1():
    def __init__(self):
        print("我是父类__init方法__里面的动作")

class TestClass2(TestClass1):
    def __init__(self):
        TestClass1.__init__(self)
        print("我是子类__init__重写后自己实现的动作")

a = TestClass2()

一个参数

class TestClass1():
    def __init__(self, arg):
        print(arg)
        print("我是父类__init方法__里面的动作")



class TestClass2(TestClass1):
    def __init__(self, arg):
        TestClass1.__init__(self, arg)
        print(arg)
        print("我是子类__init__重写后自己实现的动作")

a = TestClass2("参数")

两个参数

class TestClass1():
    def __init__(self, arg, arg2):
        print(arg)
        print("我是父类__init方法__里面的动作")



class TestClass2(TestClass1):
    def __init__(self, arg, arg2):
        TestClass1.__init__(self, arg, arg2)
        print(arg)
        print("我是子类__init__重写后自己实现的动作")

a = TestClass2("参数", "参数2")

方法三

无参数

class TestClass1():
    def __init__(self):
        print("我是父类__init方法__里面的动作")

class TestClass2(TestClass1):
    def __init__(self):
        super().__init__()
        print("我是子类__init__重写后自己实现的动作")
a = TestClass2()

一个参数

class TestClass1():
    def __init__(self, arg):
        print("我是父类__init方法__里面的动作", arg)

class TestClass2(TestClass1):
    def __init__(self, arg):
        super().__init__(arg)
        print("我是子类__init__重写后自己实现的动作", arg)
a = TestClass2("arg")