python的装饰器记录，以及继承类的方法

被装饰的函数带参数

# 不带返回值的
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)
def add(a, b):
    print(a+b)
    time.sleep(1)

@showtime #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)
def add(a, b):
    print("a+b", a+b)
    time.sleep(1)

@showtime #   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)
def foo():
    print('foo..')
    time.sleep(3)

@showtime #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")