#encoding=utf-8
import time

def cost_time(func):
    def infunc(*args,**kwargs):
        start = time.time()
        result = func(*args,**kwargs)
        end = time.time()
        print(f"耗时:{end-start}")
        return result
    return infunc

class CaheDecorator():
    __cache={} #类属性，用作所有实例的共享缓存
    def __init__ (self ,func):
        self.func = func
    def __call__ (self, *args, **kwargs):
        #如果缓存中有对应的方法名，则直接返回对应的返回值
        if self.func.__name__ in CaheDecorator.__cache:
            return CaheDecorator.__cache[self.func.__name__]
        # 如果缓存中没有对应的方法名，则进行计算，并将结果缓存
        else:
            result = self.func(*args,**kwargs)
            CaheDecorator.__cache[self.func.__name__] = result
            print(self.__cache)
            return result


@cost_time  #func1_long_time = cost_time(func1_long_time)
@CaheDecorator  #func1_long_time=CaheDecorator(func1_long_time)
def func1_long_time():
    """模拟耗时较长，每次执行返回结果都一样的情况"""
    print("start func1")
    time.sleep(3)
    print("end func1")
    return 999

if __name__ == '__main__':
    r1 = func1_long_time()
    r2 = func1_long_time()
    print(r1)
    print(r2)

这段代码的运行顺序是怎么样的？

time

(func):
    (*args**kwargs):
        start = time.time()
        result = func(*args**kwargs)
        end = time.time()
        (end-start)
        result
    infunc

CaheDecorator():
    __cache={} (func):
        .func = func
    (*args**kwargs):
        .func.CaheDecorator.__cache:
            CaheDecorator.__cache[.func.]
        :
            result = .func(*args**kwargs)
            CaheDecorator.__cache[.func.] = result
            (.__cache)
            result


():
    ()
    time.sleep()
    ()
    __name__ == :
    r1 = func1_long_time()
    r2 = func1_long_time()
    (r1)
    (r2)

这段代码他的运行顺序是怎么样的？

a.sort()

last=a[-1]

for i in range(len(a)-2,-1,-1):

    if last==a[i]:

        del a[i]

    else:

        last=a[i]

print(a)

老师这段代码不理解，能解释一下吗

写一个函数, 输入一个字符串, 返回倒序排列的结果:用递归怎么写啊

def string_reverse5(text='abcdef'):

    if len(text)<=1:

        return text

    else:

        return string_reverse5(text[1:]+text[0])

报错

[Previous line repeated 996 more times]

RecursionError: maximum recursion depth exceeded

老师, 我想问下, 为什么你敲的代码里的冒号符号都有方框?

sorted使用key参数的是时候，在这个代码场景下，是第一次给custom_sorted传递的是stu1和stu2，然后第二次比较传递的是stu1和stu2中比较大一个（stu1）和stu3吗，这一块理解上不是特别清晰，能帮看下吗

# coding=utf-8
import time
# 用函数装饰器,完成缓存
def Cachedecorater(func):
    def infunc(*args,**kwargs):
        cache={}
        if func.__name__ in cache:
            return cache[func.__name__]
        else:
            result = func(*args,**kwargs)
            cache[func.__name__] = result
            return result
    return infunc

# 用类装饰器,完成计时
class Timedecorater():
    def __init__(self,func):
        self.func = func
    def __call__(self, *args, **kwargs):
        start = time.time()
        result = self.func(*args,**kwargs)
        end = time.time()
        print(f"耗时: {end-start}")
        return result

@Timedecorater
@Cachedecorater
def fun1_long_time():
    """模拟耗时较长,但每次返回的结果又一样的情况"""
    print("fun1 start...")
    time.sleep(3)
    print("fun1 end...")
    return 999

if __name__ == '__main__':
    r1 = fun1_long_time()
    r2 = fun1_long_time()
    print(r1)
    print(r2)

老师,我这用了相反的装饰器,就是缓存功能用的是函数定义的,计时是用的类装饰器, 但是结果,计时功能是正常的,而缓存功能却没有体现. 就是测试两次,耗时一样,是我缓存装饰器哪里写错了

老师,直接打印这个列表怎么是这个, 这个Stu_list列表里装不应该就是sorted函数将年龄排好序的结果么?

def outer():
   print("outer")
   a = 20
   def inner():
       print("inner")
       nonlocal a
       print(f'a={a}')
   return inner


a = outer()
a()

问：a = outer()为什么只执行outer方法？

a()是执行了inner方法吗？

老师.+和+不都是能获取多个字符串吗 抛去贪婪与非贪婪这两个模式 是不是这两个随便用哪个都行

自定义方法中：sort方法是怎么根据返回-1和返回0、返回1来排序的

没有缓存是什么原因

inn=outer()这个是把outer()函数的返回值赋给inn吗？

inn()是不是就相当于调用内部函数inner()?

为什么 ret = re.match("[A-Z][a-z]*","M")可以匹配上，不是最少有两个字母吗