3525:上台阶

总时间范围: 
1000ms

内部存储器限制: 
65536kB

描述
阶梯有n(100 > n >
0)阶台阶,上楼时可以一步上1阶,也能够一步上2阶,也得以一步上3阶,编制程序计算共有多少种分裂的走法。

输入
输入的每一行包罗一组测试数据,即为台阶数n。最后一行为0,表示测试甘休。

输出
每一行输出对应一行输入的结果,即为走法的多少。

样例输入
1
2
3
4
0

样例输出
1
2
4
7

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<queue>
 4 #include<cmath>
 5 using namespace std;
 6 int tot=0;
 7 int find(int n)
 8 {
 9     if(n==1)return 1;
10     else if(n==2) return 2;
11     else if(n==3) return 4;
12     else return find(n-3)+find(n-2)+find(n-1);
13 }
14 int main() {
15     int a,b;
16     while(cin>>a)
17     {
18         if(a==0)break;
19         else 
20         cout<<find(a)<<endl;
21     }
22     return 0;
23 }

 

图片 1图片 2

壹 、简单的装饰器

 1  统计多少个函数被我装饰了
 2 l=[]
 3 def wrapper(fun):
 4     l.append(fun)#统计当前程序中有多少个函数被装饰了
 5     def inner(*args,**kwargs):
 6         # l.append(fun)#统计本次程序执行有多少个带装饰器的函数被调用了
 7         ret = fun(*args,**kwargs)
 8         return ret
 9     return inner
10 
11 @wrapper
12 def f1():
13     print('in f1')
14 
15 @wrapper
16 def f2():
17     print('in f2')
18 
19 @wrapper
20 def f3():
21     print('in f3')
22 print(l)

  装饰器的成效:在不改动原函数及其调用格局的情状下对原函数作用进行扩张

 1 def qqqxing(fun):
 2     def inner(*args,**kwargs):
 3         print('in qqxing: before')
 4         ret = fun(*args,**kwargs)
 5         print('in qqxing: after')
 6         return ret
 7     return inner
 8 
 9 def pipixia(fun):
10     def inner(*args,**kwargs):
11         print('in qqxing: before')
12         ret = fun(*args,**kwargs)
13         print('in qqxing: after')
14         return ret
15     return inner
16 @qqqxing
17 @pipixia
18 def dapangxie():
19     print('饿了吗')
20 dapangxie()
21 
22 '''
23 @qqqxing和@pipixia的执行顺序:先执行qqqxing里面的 print('in qqxing: before'),然后跳到了pipixia里面的
24         print('in qqxing: before')
25         ret = fun(*args,**kwargs)
26         print('in qqxing: after'),完了又回到了qqqxing里面的 print('in qqxing: after')。所以就如下面的运行结果截图一样
27 '''

2.对修改是查封的

 三 、装饰器的一定结构

图片 3图片 4

        用处:正是当加了不少装饰器的时候,以后突然又不想加装饰器了,想把装饰器给去掉了,不过那么多的代码,叁个贰个的去闲的费力,那么,咱们能够利用带参数的装饰器去装饰它,这就他就如1个开关一样,要的时候就调用了,不用的时候就去掉了。给装饰器里面传个参数,那么这么些语法糖也要带个括号。在语法糖的括号内传参。在那边,我们得以用三层嵌套,弄三个标识为去标识。如上面包车型地铁代码示例

1.为啥要运用装饰器呢?

 上例代码的运转结果截图

带再次回到值的装饰器

 1 # 带参数的装饰器:(相当于开关)为了给装饰器传参
 2 # F=True#为True时就把装饰器给加上了
 3 F=False#为False时就把装饰器给去掉了
 4 def outer(flag):
 5     def wrapper(func):
 6         def inner(*args,**kwargs):
 7             if flag:
 8                 print('before')
 9                 ret=func(*args,**kwargs)
10                 print('after')
11             else:
12                 ret = func(*args, **kwargs)
13             return ret
14         return inner
15     return wrapper
16 
17 @outer(F)#@wrapper
18 def hahaha():
19     print('hahaha')
20 
21 @outer(F)
22 def shuangwaiwai():
23     print('shuangwaiwai')
24 
25 hahaha()
26 shuangwaiwai()

图片 5图片 6

 

 1 import time
 2 def timer(func):
 3     def inner(*args,**kwargs):
 4         start = time.time()
 5         re = func(*args,**kwargs)
 6         end=time.time()
 7         print(end - start)
 8         return re
 9     return inner
10 
11 @timer   #==> func1 = timer(func1)
12 def jjj(a):
13     print('in jjj and get a:%s'%(a))
14     return 'fun2 over'
15 
16 jjj('aaaaaa')
17 print(jjj('aaaaaa'))

图片 7图片 8

图片 9图片 10

 

原函数带多少个参数的装饰器

给装饰器加参数

图片 11原函数带2个参数的装饰器

六 、总计多少个函数被点缀了的小应用

带参数的装饰器:就是给装饰器传参

 

View Code

  装饰器的真面目:就是三个闭包函数

图片 12

那就是说大家先来看八个不难的装饰器:完成计算每种函数的实行时间的机能

图片 13图片 14

图片 15图片 16

三个装饰器装饰三个函数

差不多的装饰器

总计多少个函数被点缀了

 五 、四个装饰器装饰1个函数

装饰器——-语法糖

 四 、带参数的装饰器

 1 import time 
 2 def  wrapper(func):
 3         def inner():
 4               start=time.time()
 5               func()
 6               end=time.time()
 7               print(end-start)
 8         return inner 
 9     
10 def  hahaha():
11         time.sleep(1)
12         print('aaaaa')
13 hahaha=wrapper(hahaha)
14 hahaha()    

地点的效应有点不简介,不到家,下边就推荐了语法糖。

 1 import time
 2 def wrapper(func):
 3         def inner():
 4                start=time.time()
 5                func()
 6                end=time.time()
 7                print(end-start)
 8         return inner
 9 @wrapper
10 def  kkk():#相当于kkk=wrapper(kkk)
11     print('aaaaa')
12 kkk()             
 1 import time
 2 def wrapper(func):  # 装饰器
 3     def inner(*args, **kwargs):
 4         '''函数执行之前的内容扩展'''
 5         ret = func(*args, **kwargs)
 6          '''函数执行之前的内容扩展'''
 7         return ret
 8     return inner
 9 
10 @wrapper  # =====>aaa=timmer(aaa)
11 def aaa():
12     time.sleep(1)
13     print('fdfgdg')
14 aaa()

以上的装饰器都以不带参数的函数,未来装饰贰个带参数的该咋办呢?

贰 、开放封闭原则

 1 import time
 2 def timer(func):
 3     def inner(*args,**kwargs):
 4         start = time.time()
 5         re = func(*args,**kwargs)
 6         end=time.time()
 7         print(end- start)
 8         return re
 9     return inner
10 
11 @timer   #==> func1 = timer(func1)
12 def func1(a,b):
13     print('in func1')
14     print(a,b)
15 
16 @timer   #==> func1 = timer(func1)
17 def func2(a):
18     print('in func2 and get a:%s'%(a))
19     return 'fun2 over'
20 
21 func1(1,2)
22 print(func2('aaaaaa'))

 

图片 17图片 18

图片 19

1.对扩张是开放的