import time

def timer(func):
    def wrapper(*arguments,**keyword_arguments): # 参数有无与多少不确定, 关键字参数有无与多少不确定
        start=time.time()
        ret=func(*arguments,**keyword_arguments) # 与前文类似, 参数有无与多少不确定
        end=time.time()
        print('FuncName:{};\nResult:{}\nTime Spent:\t{}s'.format(getattr(func,'__name__'),ret,end-start),file=open('D:\跑速情况.txt','a'))
        # 可以先dir(func) 查出func有__name__这个attr, 于是用函数getattr(funcName, funcAttrName)
        return ret # 很关键, 因为func有返回值所以要写ret(其实没有返回值也写一下没什么问题)
    return wrapper # 装饰器本质: ret内层函数

# 注意: 带参数的装饰器指的是装饰器有参数, 就是最外层的timer(func,args),
## 被装饰函数有参数, 直接在内部处理就可以, ret=func(*arguments,**keyword_arguments)

@timer
def m1_feibonaqi(n,visited=[]): # 改进版递归型斐波那契, 区分于远坂sb无脑递归型在于加入visited使得不用重复计算
    if n==1 or n==2:
        return 1
    else:
        if bool(visited)==0:
            ori_visited=[1,1].extend([None for each in range(3,n+1)])
            visited=ori_visited
        else:
            if visited[n-2]==None:
                tail=m1_feibonaqi(n-2)
                visited[n-2]=tail
            if visited[n-1]==None:
                head=m1_feibonaqi(n-1)
                visited[n-1]=head
            return visited[n-1]+visited[n-2]
        return m1_feibonaqi(n-1)+m1_feibonaqi(n-2)

@timer
def m1_feibonaqi(n): # sb无脑递归型, 可以拿来测下栈帧深度
    if n==1 or n==2:
        return 1
    else:
        return m1_feibonaqi(n-1)+m1_feibonaqi(n-2)

@timer
def m2_feibonaqi(n): # 正常型斐波那契
    if n==1 or n==2:
        return 1
    else:
        f1,f2=1,1
        head,tail=f2,f1
        cnt=2
        while cnt<n:
            cnt+=1
            next_val=head+tail
            head,tail=next_val,head
        return next_val

@timer
def m3_feibonaqi(n,visited=[]): # 改进版递归型斐波那契, 区分于远坂sb无脑递归型在于加入visited使得不用重复计算
    if n==1 or n==2:
        return 1
    else:
        if bool(visited)==0:
            ori_visited=[1,1].extend([None for each in range(3,n+1)])
            visited=ori_visited
        else:
            if visited[n-2]==None:
                tail=m1_feibonaqi(n-2,visited)
                visited[n-2]=tail
            if visited[n-1]==None:
                head=m1_feibonaqi(n-1,visited)
                visited[n-1]=head
            return visited[n-1]+visited[n-2]
        return m3_feibonaqi(n-1,visited)+m3_feibonaqi(n-2,visited)


m1_feibonaqi(10) # 这个只能跑20以内的
print('----分界线12----',file=open('D:\跑速情况.txt','a'))
m2_feibonaqi(10**5) # 这个可以跑10万以内的
print('----分界线23----',file=open('D:\跑速情况.txt','a'))
m3_feibonaqi(10) # 这个也同样只能跑20以内的

## 实际上m1和m3跑出来结果是一样的(^7$7^), 难受~

# 函数实体的存在是既定的, 不依赖于特定函数名.
import copy

def greet(name):
    return 'Nice to meet you, '+name

print(greet)
# out: <function greet at 0x00000259C5FAD1E0>
## 函数实体已建立, 是<function greet at 0x00000259C5FAD1E0>
## 此时, greet仅仅是一个变量名, 一个函数指针, 它指向的函数对象是<function greet at 0x00000259C5FAD1E0>

sayNiceToMeetYou=greet
# python默认是浅复制, 事实上sayNiceToMeetYou与greet指向同一个对象, 该对象类型是函数

print(id(sayNiceToMeetYou),id(greet))
## out: 1980378239456 1980378239456, 符合假设

del greet

print(sayNiceToMeetYou('lkr')) 
# out: Nice to meet you, lkr, 说明仅仅删除指针, 函数实体并没有被删除

## 正戏开始

def decorator(func):
    def wrapper_who_return_funcPtr():
        # 返回参数列表: `https://web.archive.org/web/20210512042121/https://www.cnblogs.com/snow-backup/p/11077917.html`
        # inspect库: `https://web.archive.org/web/20220605125226/https://docs.python.org/3/library/inspect.html`
        print('before {} works.'.format(decorator.__code__.co_varnames[0]))
        func()
        print('After {} works.'.format(decorator.__code__.co_varnames[0]))
    return wrapper_who_return_funcPtr

decorator(sayNiceToMeetYou)

# d_sayNiceToMeetYou=copy.deepcopy(sayNiceToMeetYou)
# # print(id(sayNiceToMeetYou),id(d_sayNiceToMeetYou))
## out: 2303771464160 2303771464160, 没有新对象生成, 难道深拷贝也出了问题吗?
## 答案找到了: `https://web.archive.org/web/20220525023657/https://docs.python.org/3.7/library/copy.html` 搜索"It does “copy” functions and classes (shallow and deeply), by returning the original object unchanged"

import copy
# l for list

l1,l2=[1,2,3],[1,2,3]
print('l1:{};\tl2:{}'.format(id(l1),id(l2))) 
l12=[l1,l2]

d_l12=copy.deepcopy(l12)

print('l12:{};\td_l12:{}'.format(id(l12),id(d_l12))) # deepcopy外壳实现了深拷贝
print('l1:{};\tl12元素0:{};\td_l12元素0:{}'.format(id(l1),id(l12[0]),id(d_l12[0]))) # deepcopy内部元素同样也实现了深拷贝:l12的元素0就是l1对象本身; 而d_l12元素0不是l1对象
# 由于l2也是同样的情况, 所以就不演示了

# cc for copy_copy obj

cc_l12=copy.copy(l12)

print('l12:{};\tcc_l12:{}'.format(id(l12),id(cc_l12))) # 对l12可变对象: copy.copy外壳实现了深拷贝
print('l1:{};\tl12元素0:{};\tcc_l12元素0:{}'.format(id(l1),id(l12[0]),id(cc_l12[0]))) #  copy.copy内部元素仅仅实现了浅拷贝:l12的元素0就是l1对象本身; 而cc_l12元素0也是l1对象本身

# t for tuple
t12=(l1,l2)
cc_t12=copy.copy(t12)
print('t12:{};\tcc_t12:{}'.format(id(l12),id(cc_l12))) # 对t12可变对象: copy.copy外壳仅实现浅拷贝
print('l1:{};\tt12元素0:{};\tcc_t12元素0:{}'.format(id(l1),id(l12[0]),id(cc_l12[0]))) #  copy.copy内部元素也仅仅实现了浅拷贝:t12的元素0就是l1对象本身; 而cc_t12元素0也是l1对象本身