python成长之路装饰,简学生成式
分类:编程应用

Python成长之路_装饰器,python成长之路装饰

一、初入装饰器

1、首先呢我们有这么一段代码,这段代码假如是N个业务部门的函数

图片 11 def f1(aaa): 2 print('我是F1业务') 3 if aaa == 'f1': 4 return 'ok' 5 6 def f2(aaa): 7 print('我是F2业务') 8 if aaa == 'f2': 9 return 'ok'

政工代码

此处呢也正是当大家调用上面的函数的时候,传入值给aaa,当aaa的值等于f1依旧f2就回来ok

2、公司有N个业务部门,1个基础平台部门,基础平台负责提供底层的功能,如:数据库操作、redis调用、监控API等功能。业务部门使用基础功能时,只需调用基础平台提供的功能即可。那么我们业务部门调用功能的时候只需要。
f1(值)
f2(值)
3、公司的运行正在有条不稳的进行,然而有一天呢,你的老大说,我发现了一个问题就是呢业务部调用基础平台的功能的时候没有验证这样不好所以呢老大就把工作交给了,要求增加验证功能并且业务部门在调用功能的方式不能变
Low A,这个A呢他是这么做的
他呢跟各个做基础功能的人协调,要求在自己的代码上加入验证模块,那么这样呢整个的基础平台就不需要更改,结果,Low A当天就被开除了……
Low B,这个B呢一看A都被开除了不行上面的方法不行哪就换一个
 1 def f1(aaa):
 2     #验证代码
 3     #验证代码
 4     print('我是F1业务')
 5     if aaa == 'f1':
 6         return 'ok'
 7 
 8 def f2(aaa):
 9     #验证代码
10     #验证代码
11     print('我是F2业务')
12     if aaa == 'f2':
13         return 'ok'

LowB

 

这厮呢在每种功效前边参加了求证代码,然后过了二日Low B也被裁掉了

最后极度把职业付出了Low C

Low C啊总括了七个Low的训诫他是那样干的

图片 2 1 #证实函数 2 def verify(): 3 # 验证1 4 # 验证2 5 # 验证3 6 pass 7 8 def f1(aaa): 9 verify(): 10 print('我是F1业务') 11 if aaa == 'f1': 12 return 'ok' 13 14 def f2(aaa): 15 verify(): 16 print('我是F2业务') 17 if aaa == 'f2': 18 return 'ok' Lowc

 

他呢把验证功能的,写成了一个函数然后,每个业务模块来去调用

老大看见了LowC的实现方式,嘴角露出了一丝微笑,并且与LowC聊了个天

 

老大说:

写代码要依据开采密闭原则,即使在这些原则是用的面向对象开采,不过也适用于函数式编制程序,轻巧的话,它规定已经落实的功用代码不相同意被修改,但能够被扩充,即:

  • 查封:已兑现的成效代码块
  • 开放:对增加开拓

如果将绽开密闭原则应用在上述供给中,那么就差别意在函数 f1 、f2的中间开展改造代码,CEO就给了Low C贰个贯彻方案:

装饰器(单层装饰器)

图片 3 1 def out(main): 2 def wra(): 3 # 验证1 4 # 验证2 5 # 验证3 6 return xxx 7 return wra 8 9 @out 10 def f1(aaa): 11 print('作者是F1业务') 12 if aaa == 'f1': 13 return 'ok' 14 15 @out 16 def f2(aaa): 17 print('作者是F2业务') 18 if aaa == 'f2': 19 return 'ok' 单层装饰器

 

简学Python第四章__装饰器、迭代器、列表生成式,简学生成式

二、好,传说(这么些传说是盗窃银角大王的)到此结束大家开头来看上边的代码

(1)首先我们要知道当函数不加括号我们的函数是不被执行的,它会返回这个函数的内存地址

def aaa():
    print("ok")

print(aaa)

<function aaa at 0x0000000000B6AC80>

(2)然后大家来解释一下@out

@out就等于f1 = out(f1)

怎么着意思呢@out是python语法中的二个简写,他的用途就是针对性装饰器来去做的,大家看下边包车型大巴例证,将@out替换来

f1 = out(f1)

 

图片 4 1 def out(main): 2 def wra(aaa): 3 print('小编进去了') 4 ccc = main(aaa) 5 return ccc 6 return wra 7 8 def f1(aaa): 9 print('作者是F1业务') 10 if aaa == 'f1': 11 return 'ok' 12 13 f1 = out(f1) 14 15 s1 = 'f1' 16 17 ff1 = f1(s1) 18 print(ff1)

转换后

 

 

(3)我们来解释下out函数,对于out来说他首先接收一个值,从上面可以看出他接收的值是f1,f2的内存地址,然后接收后将值返回给函数wra,注意的是f1,f2都没加括号所以都没执行,返回wra的时候也没加括号所以也没执行,那么到了这里这个函数就先暂停我们结合者调用来看下面的图:

第一步:请务必分开wra不等于f1而是main等于f1!!下面的f1就等于wra的意思是执行f1函数就等于执行wra函数

 

第二步:

最后呢我们通过python语法塘,将f1 = out(f1) 变成@out就变成了之前我们看到的代码

图片 5 1 def out(main): 2 def wra(aaa): 3 print('小编进去了') 4 ccc = main(aaa) 5 return ccc 6 return wra 7 8 @out 9 def f1(aaa): 10 print('我是F1业务') 11 if aaa == 'f1': 12 return 'ok' 13 14 15 s1 = 'f1' 16 ff1 = f1(s1) 17 print(ff1) 完整单层装饰器

 

友谊提示:

在此请将之前的练习一下并且熟知其中的原理再进行下面的学习,大神除外

(4)装饰器装上含有参数的函数,有同学可能测试了一下说,我把函数f1的参数变成了多个,装饰器就报错了,那是怎么回事呢,原因很简单,因为wra首先他只能接收一个参数,并且ccc = main(aaa)也只接收了一个参数

def out(main):
    def wra(aaa):
        print('我进去了')
        ccc = main(aaa)
        return ccc
    return wra

既是知道了原由那么大家就给她改改数码珍宝超进化…:

图片 6 1 def out(main): #那边就十分的少解释了跟下边一样 2 def wra(*aaa,**aa): #这里呢产生了什么是还是不是足以收起各类的参数了 3 print('小编进来了') 4 ccc = main(*aaa,**aa) #这里吧也得以给f1种种参数 5 return ccc 6 return wra 7 8 @out 9 def f1(*af1): 10 print('我是F1业务') 11 print(af1[0]) #给我们测量检验用的 12 print(af1[1]) 13 if af1[0] == 'f1': 14 return 'ok' 15 16 s1 = 'f1' 17 ff1 = f1(s1,'笔者是参数2') #传播了七个值s1和自个儿是参数2' 18 print(ff1) #运营一下看看吧呵呵 装饰参数函数的装饰器

 

 

Python第四章__装饰器、迭代器

款待到场Linux_Python学习群

 图片 7 群号:478616847

 

 

目录:

  • 列表生成式

  • **生成器**

  • 迭代器

  • 单层装饰器(无参)

  • 多层装饰器(有参)

  • 冒泡算法

  • 代码开垦标准

 

三、装饰器的巅峰进化(多层装饰器)逻辑相比绕

有一天,变态的老大又找到了Low C说你的装饰器练习的咋样了,Low C说:经过老大的调教,我已经练习的差不多了,这个时候老大阴阴的呵呵一笑,好,这样我呢又有个需求要你给我改改,我现在呢想在验证之后呢添加一个欢迎功能,这个功能呢,我们业务线的功能想要添加就添加先要不添加就不添加,要记住封闭原则哦0.0……….
第二天Low C找到了老大说,大哥啊您晚上还是来我家教教我吧,真心的不知道啊0.0,,,于是老大就去了Low C的家里经过一场风云(此次省略一万个字)0.0老大提供了另外的参考代码:
 1 def ds():
 2     print('ok我是欢迎信息1')
 3 
 4 def ss():
 5     print('ok我是欢迎信息2')
 6 
 7 
 8 def fill(*ill):
 9     def out(main):
10         def wra(*waa,**wad):
11             ill[0]()
12             ill[1]()
13             ccc = main(waa[0])
14             return ccc
15         return wra
16     return out
17 
18 
19 @fill(ds,ss)
20 def f1(aaa):
21     print('我是F1业务')
22     if aaa == 'f1':
23         return 'ok'
24 
25 
26 c1 = f1('f1')
27 print(c1)

相当的代码

 

哈哈看不懂了吧(大神除外)来吧我们分开来看就知道了

第一步:还是先解释一下装饰器fill请看图片,有一句话要牢记这个装饰器我就把它理解成调用,也就是把需要用的函数传入到装饰器做值,从而调用值来执行函数

 

第二步:

 

好到了那边我们应该清楚了呢,不清楚的留言,讲错了的请指教谢谢O(∩_∩)O~~,那么有些小同伙要问了,那尼玛不对啊,为毛作者把@fill(ds,ss)形成@fill(ss)就报错了啊?

我们解析一下主题素材,首要的案由呢就是def wra函数上面施行了 ill[1]报错了,因为此地*ill唯有叁个参数那么制止吗,看自己的终点大招:

图片 8 1 def ds(): 2 print('ok作者是款待新闻1') 3 def ss(): 4 print('ok笔者是接待新闻2') 5 6 def fill(*ill): 7 def out(main): 8 def wra(*waa,**wad):#那边加个判别不就完了么 O(∩_∩)O哈哈~ 9 if len(ill) != '0': 10 for i in range(0,len(ill)): 11 ill[i]() 12 ccc = main(waa[0]) 13 return ccc 14 return wra 15 return out 16 17 @fill(ss,ds) 18 def f1(aaa): 19 print('我是F1业务') 20 if aaa == 'f1': 21 return 'ok' 22 23 @fill() #您看这里没参数吧 24 def f2(aaa): 25 print('作者是F2业务') 26 if aaa == 'f2': 27 return 'ok' 28 29 c1 = f1('f1') 30 print(c1) 31 c2 = f2('f2') 32 print(c2) 终相当的大招-多层装饰器

 

#运行下试试吧

等等!最后老大和Low C成为了…此处省略一万个字

一、初入装饰器 1、首先呢 大家有那般一段 代码,这段代码假 如 是N个业务部门的函数 1 def f1...

一、列表生成式(列表推导式

  列表生成式List Comprehensions,是Python内置的特别轻便却壮大的能够用来成立list的生成式。

  首先来上个必要,作者有一个列表 [1,2,3,4,5,6,7,8,9,10],未来有那般个要求,要里面包车型客车要素自乘,想想看要怎么落到实处

  版本一,通过for循环,重新赋值(占内部存款和储蓄器空间)

图片 91 a = [1,2,3,4,5,6,7,8,9,10] 2 b = [] 3 for i in a: 4 b.append(i*i) 5 a = b 6 print(a) 版本一

  版本二,通过for循环修改原值(代码太多)

图片 101 a = [1,2,3,4,5,6,7,8,9,10] 2 for indexs,i in enumerate(a): 3 a[indexs] *= i 4 print(a) 版本二

  版本三,借助map和lambda(代码也不在少数)

图片 111 a = [1,2,3,4,5,6,7,8,9,10] 2 a = map(lambda x:x*x,a) 3 print(list(a)) 版本三

  列表生成式(Python的高档个性),一句话就可以完结地方的效果,在列表生成式中大家可以加if决断,也能够加几个for循环,四个for循环,我们就把它

  想成for循环嵌套,况兼实际结果也是for循环嵌套的结果

图片 12 1 a = [i*i for i in range(1,11)] 2 print(a) 3 4 #加if判断 5 a = [i*i for i in range(1,11) if i%2 == 1 ] 6 print(a) 7 8 #多层for循环 9 a = [a+b+c for a in "abc" for b in "ABC" for c in "123"] 10 print(a) 11 12 13 #多层for循环深入分析 14 s = [] 15 for a in "abc" : 16 for b in "ABC": 17 for c in "123": 18 s.append(a+b+c) 19 print(s) 列表生成式

 

二、生成器

  生成器也叫轻巧生成器,它是足以总结有效的开创下迭代器的工具,并且经过yield语句,当每一次对有yield语句函数使用next()的时候

  生成器会从yield截止的职责一而再开首

  生成器的特点:

  1、生成器是用一般的函数语法定义的迭代器

  2、通过next()语句调用,生成器函数将从yield语句处继续实施

  3、节省空间,生成器只是钦定的计量格局,在不调解的时候不会扭转全数的值 

  4、通过生成器的这种能够重复从yield语句处再一次实践的特点,大家得以做到协同程序(上面例子表明)

  协同程序:协同程序是足以运作的单独函数调用,能够暂停大概挂起,并从程序离开的地点三番五次也许另行开头。

 

  第多个简易生成器

  下边包车型客车代码首如若概念多少个函数,这些函数接收多少个数字的参数,然后通过list(range(num))生成一个列表。并for循环那个列表

  每一次循环都触发 yield i ,当第一回巡回触发yield i 则程序会停下到此地还要产生一个值,等待下一步激活,那么通过__next__()和next()

  就去到yield 重回的值,并且从甘休的职务继续实践,知道再境遇yield,只怕举行到位。

   1 def Out_num(num): 2 for i in list(range(num)): 3 yield i 4 5 Builder = Out_num(5) 6 7 #再次来到的不是三个数字而是贰个迭代器 8 print(Builder) 9 10 #取值情势 11 print("笔者是由此__next__()取值:",Builder.__next__()) 12 print("小编是透过next()取值:",next(Builder)) 13 14 #for循环取值 15 print("作者是透过for循环取值↓") 16 for i in Builder: 17 print(i) 生成器

  要注意的少数是经过__next__()和next()取值时当生成器中从不值而你取值则程序会报错,通过for循环取值时不设有那些主题素材的!

图片 13 1 >>> def Out_num(num): 2 ... for i in list(range(num)): 3 ... yield i 4 ... 5 >>> Builder = Out_num(3) 6 7 >>> Builder.__next__() 8 0 9 >>> Builder.__next__() 10 1 11 >>> Builder.__next__() 12 2 13 >>> Builder.__next__() 14 Traceback (most recent call last): 15 File "<stdin>", line 1, in <module> 16 StopIteration 生成器报错

 

  协同程序与send()

  我们精通了协同程序就是前后相继能够暂停恐怕挂起,并且能够从程序离开的地点继续恐怕再一次开端

  上面包车型地铁例子是个吃包子与做包子的模拟程序,通过yield让consumer函数暂停,并实行做馒头的操作,做完包子后通过send(),给yield赋值,

  并且继续试行consumer函数中的代码,而且大家能够通过send()传进来的值判别做什么操作,就象例子中“梅菜肉馅的馒头”一样,隔壁老王不吃而相邻老李爱吃。

图片 14 1 import time 2 def consumer(name): 3 print("%s 希图吃馒头啦!" %name) 4 while True: 5 baozi = yield 6 if baozi == "牛肉" or baozi == "咸菜": 7 print("%s馅的包子来了,%s爱吃,被[%s]吃了!" %(baozi,name,name)) 8 elif baozi == "咸菜肉" and name == "隔壁老李": 9 print("%s馅的包子来了,%s爱吃,被[%s]吃了!" %(baozi,name,name)) 10 else: 11 print("%s馅的馒头不可口,%s不吃!" %(baozi,name)) 12 13 def producer(): 14 c = consumer('隔壁老王') 15 c2 = consumer('隔壁老李') 16 c.__next__() 17 c2.__next__() 18 print("来客户了,大王初始做包子了!") 19 species = ["牛肉","素三鲜","酸菜","梅菜肉","韭菜"] 20 for i in species: 21 time.sleep(1) 22 print("---------------------分水线-------------------------") 23 print("做了%s馅的馒头"%i) 24 c.send(i) 25 c2.send(i) 26 producer() 协同程序(只吃好吃的馒头)

 

   生成器表达式

  在下面学习了列表生成式,和生成器,那么生成器表明式它和列表生成式的用法基本一致,其行事办法是历次管理二个对象,并不是一口气管理和组织整个数据结构,

  约等于回去的是五个可迭代的靶子,那样做的秘闻优点是能够节省大批量的内部存款和储蓄器,

  语法:(expr for iter_var in iterable) 或 (expr for iter_var in iterable if cond_expr)

图片 15 1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 #生成器表达式 5 c = (x for x in "ABCDEFG") 6 print(c) 7 #列表生成式 8 a = [i*i for i in range(1,11) if i%2 == 1 ] 9 print(a) 10 11 lists = ["user","pass","age","gender"] 12 s = {i:"" for i in lists } 13 print(s) 生成器表明式

 

三、迭代器

  什么是迭代器?一种是能够间接成效于for巡回的数据类型,另一种正是有一个next() 方法的靶子, 并非经过索引来计数,也就说生成器生成的正是迭代器,

  迭代器也是有点限制. 比如你无法向后运动,不可能回去起头, 也不能够复制四个迭代器,能够选拔isinstance()认清叁个对象是还是不是是可迭代:

图片 161 from collections import Iterable 2 print(isinstance([],Iterable)) 3 print(isinstance({},Iterable)) 4 print(isinstance((),Iterable)) 5 print(isinstance("abcd",Iterable)) 6 #数字不可能迭代 7 print(isinstance(100,Iterable)) 剖断目标是否可迭代

   生成器都以迭代器,然则就算 list dict str能够迭代,不过它们不是迭代器,通过iter()函数能够把可迭代的靶子形成迭代器

图片 171 from collections import Iterator 2 print(isinstance([],Iterator)) 3 print(isinstance({},Iterator)) 4 print(isinstance((),Iterator)) 5 print(isinstance("abcd",Iterator)) 6 7 print(isinstance((x for x in range(10)),Iterator)) 判定是或不是是迭代器

  你恐怕会问,为啥list、dict、str等数据类型不是Iterator(迭代器)?

  这是因为Python的Iterator对象表示的是八个数据流,Iterator对象能够被next()函数调用并持续重回下贰个数据,直到未有数据时抛出StopIteration错误。

  能够把这一个数据流看做是一个稳步体系,但大家却无法超前通晓系列的长度,只可以不断通过next()函数完结按需计算下一个数目,所以Iterator的估测计算是惰性

  的,独有在供给再次回到下一个数目时它才会一个钱打二十五个结。Iterator以至足以象征多个极致大的数据流,举例全部自然数。而利用list是永恒不恐怕存款和储蓄全部自然数的。

 

四、单层装饰器(无参)

  装饰器是函数式编制程序的显要!学好装饰器不只能让您的代码看上去,B格更加高,也能反映出手艺含量,更能落实支付密闭原则,装饰器的私行主要思想源自

  python 面向对象编制程序。所以装饰器是在函数调用之上的梳洗。也正是说装饰器的功效是在不动函数源码的前提上给函数加效果,抽象的知情正是把函数装饰起

  来,是函数实践前与实施后都能做不相同的操作!

   上故事有一家公司,策动面试新人,这几个部门的极度亲自当面试官,并且呢,给面试者出了那般一道题

  大家有如此一段代码,这段代码,这段代码假使是N个业务部门的工作的函数,这段代码的意味正是当大家调用下面的函数的时候,传入值给arg,

  当arg的值等于f1要么f2那么相应的函数就回到ok

图片 18 1 #!/usr/bin/env python 2 # -*- coding: utf-8 -*- 3 4 def f1(arg): 5 print('作者是F1业务') 6 if arg == 'f1': 7 return 'ok' 8 9 def f2(arg): 10 print('小编是F2业务') 11 if arg == 'f2': 12 return 'ok' 业务代码

  那么集团有N个业务部门,1个基础平台部门,基础平台承担提供底层的效力,如:数据库操作、redis调用、监察和控制API等效果。业务部门使用基础效能时,

  只需调用基础平台提供的意义就可以。那么大家业务部门调用作用的时候只须要:

    f1(值)

    f2(值)

  可是呢小编意识了三个主题素材正是业务部调用基础平台的功用的时候没有申明那样不佳,所以请各位面试者把验证成效足够,况且业务部门在调用功用的章程不能够变

  应聘者LowA

  他是那般做的,他说跟各样做基础意义的人和煦,需要在融洽专门的学业的代码上参加验证模块,那么这么呢整个的底蕴平台就不需求转移,结果,老大直接请他走了

  应聘者LowB

  那些LowB看到LowA间接被赶出去了,心里烦了低估,一样的题LowB把团结各类基础代码函数里面都抬高了证孙吴码,老大学一年级看,随便问了几句,也让他回到等音信了

图片 19 1 #!/usr/bin/env python 2 # -*- coding: utf-8 -*- 3 4 def f1(arg): 5 #说北齐码 6 #说北魏码 7 print('笔者是F1业务') 8 if arg == 'f1': 9 return 'ok' 10 11 def f2(arg): 12 #证汉代码 13 #说后周码 14 print('作者是F2业务') 15 if arg == 'f2': 16 return 'ok' LowB

  应聘者LowC

  他观察了那道题,他把验证代码单独写成多少个函数,然后在基础函数中调用那一个申明函数,老大看见了LowC的落到实处格局,嘴角露出了一丝微笑,并且与LowC聊了个天

图片 20 1 #!/usr/bin/env python 2 # -*- coding: utf-8 -*- 3 4 #验证函数 5 def verify(): 6 # 验证1 7 # 验证2 8 # 验证3 9 pass 10 11 def f1(arg): 12 verify() 13 print('我是F1业务') 14 if arg == 'f1': 15 return 'ok' 16 17 def f2(arg): 18 verify() 19 print('我是F2业务') 20 if arg == 'f2': 21 return 'ok' LowC

  老大说:

  写代码要依照开采密封原则,即使在那几个原则是用的面向对象开辟,不过也适用于函数式编制程序,轻易的话,它规定已经落到实处的功力代码不容许被改造,但能够被扩张,即:

  封闭:已落实的效应代码块

  开放:对扩打开垦

  假如将盛放密闭原则应用在上述必要中,那么就不允许在函数 f1 、f2的里边开展改变代码,老板就给了Low C七个落到实处方案并说什么日期看懂了如曾几何时候来上班薪水20K:

  ❤单层装饰器(无参)**

图片 21 1 #!/usr/bin/env python 2 # -*- coding: utf-8 -*- 3 4 #装饰器函数 5 def func(main): 6 def wra(*args,**kwargs): 7 #证孙吴码 8 return main(*args,**kwargs) 9 return wra 10 11 #python语法糖 @func => f1 = func(f1) 12 @func 13 def f1(arg): 14 print('笔者是F1业务') 15 if arg == 'f1': 16 return 'ok' 17 18 def f2(arg): 19 print('作者是F2业务') 20 if arg == 'f2': 21 return 'ok' 22 23 c = f1("f1") 24 print(c) 单层装饰器(无参装饰器)

 

  剖析 第一步:

    首先@func 是python装饰器的语法糖,那些讲话是投身被修饰函数的上方,当出现那么些讲话将在把它看成   f1 = func(f1) 

  公式  棉被服装饰函数= 装饰器函数 (被点缀函数) 能够见见棉被服装饰函数此时改为参数棉被服装饰器函数传了步入,所以装饰器函数

  (func)的参数main正是 棉被服装饰函数 f1,所以main = f1,并且大家在第三章知道了函数不加括号是不进行的,所以main

  就是函数 f1的内部存储器地址,且不会推行。

  第二步:

  return main(*args,**kwargs)

,第一步的时候大家得出了结论 main正是f1函数,所以 main(*args,**kwargs)

  ,便是实行了f1函数何况把 c = f1("f1") 中的参数“f1”传到的实在的函数 f1里也正是深卡其灰框圈起来的剧情,並且第三章大家也掌握了,

  传参的时候用 *args,**kwargs 便是把列表和字典分解(不明白请参照他事他说加以考察第三章解参)。

  最后:main(*args,**kwargs) 就是实践了f1函数,当f1函数试行到位后,就return “ok”,所以wra中的 return实际重回的正是

  f1函数再次回到的结果,那也等于c为何等于“ok”当然就是f1函数未有重回值也无所谓,因为暗许会再次来到None。到此无参装饰器剖析实现

  

五、多层装饰器(有参)

  咳咳,经过LowC的认真读书,他毕竟知道了无参装饰器的真意,于是成功的入职了铺面,可是随着岁月的推移,老大又找到了Low C说
  那样自身有个需求要你给自个儿改改,小编后天呢想在印证之后呢增多三个应接成效,那么些意义吗,大家业务线的成效想要增添就增多先要不
  增添就不加上,要铭记密封原则哦0.0……….

  第二天Low C找到了非常说,二哥啊您清晨依然来自身家庭教育教作者吗,真心的不驾驭呀0.0,,,于是丰富就去了Low C的家里经过一场风浪
   (此处省略三千0个字),最终极其提供了别的的仿效代码:

  ❤**多层装饰器(有参)**

图片 22 1 #!/usr/bin/env python 2 # -*- coding: utf-8 -*- 3 4 #迎接函数 5 def welcome(): 6 print("迎接访谈") 7 8 #装饰器函数 9 def fill(*func): 10 def single_func(main): 11 def wra(*args,**kwargs): 12 #证古时候码 13 if len(func) !=0: 14 for i in func: 15 i() 16 return main(*args,**kwargs) 17 return wra 18 return single_func 19 20 @fill(welcome)#python语法糖 @fill(welcome) => @single_func => f1 = func(f1) 21 def f1(arg): 22 print('小编是F1业务') 23 if arg == 'f1': 24 return '作者是f1 ok' 25 26 @fill() 27 def f2(arg): 28 print('笔者是F2业务') 29 if arg == 'f2': 30 return '笔者是f2 ok' 31 32 c = f1("f1") 33 print(c) 34 print("------------分水线----------") 35 c2 = f2("f2") 36 print(c2) 多层装饰器

   

  剖析:第一步

    函数(main = f1函数),也正是实行了f1,到此须求达成。

 

六、冒泡算法

  接下去学习一下冒泡排序,冒泡排序的注重思路正是从第贰个成分初始,剖断那么些因素与每四个因素的大大小小关系,当符合决断关系

  后就开展岗位沟通

图片 23 1 def bubble(lists): 2 count = len(lists) 3 for i in range(0, count-1): 4 for j in range(i + 1, count): 5 if lists[i] > lists[j]: 6 lists[i], lists[j] = lists[j], lists[i] 7 print("第%s次排序"%(i+1),lists) 8 return lists 9 10 print([5,2,9,1,7,6,8,3,4]) 11 print(bubble([5,2,9,1,7,6,8,3,4])) 冒泡排序

  上边的例证中有两层for循环,最内层for循环的遵循是相比第4个值与别的每一个值的尺寸,假诺大则替换个方式置,然后拿替换后的值接着、

  跟剩下的值进行比较,同理假若大则替换个方式置,当那贰遍巡回完毕后就用第三个值与第4个值后边的值进行相比,假诺大则替换个地点置,

  直到唯有最后五个值的时候排序就做到了,例子中的列表,让各类成分进行大小值的比较须要循环伍次也正是终极是末端八个成分相比

  就能够了。

  七、代码开采用国际标准和国外先进标准准

  随着Python在境内的开发进取,使用python编制程序语言的市肆更是多,在利用python进行支付的时候,不独有只是编辑代码时要细心标准

  何况随着程序的纷纷,在格式上也急需有正统,这样您的顺序在别人眼中的可读性会大大扩充,下边一同来探视编写代码时要留神的事体

  缩进

  在python代码中缩进的重大是不要置疑的,缩进错误会导致程序错误,並且好的缩进在代码可读性上也十分实用

  注释

  注释是前后相继非常主要的东西,不管是为着别的人阅读你的代码,仍旧为了你本身,因为日子久了比很多您和谐写的程序代码本人都会看不懂

  那个时候要快快明白自个儿的代码,注释就越是关键,所以你的每贰个函数,和前面会学到的类,以及类中的方法,都要给她们加上注释

  行的最大尺寸

  每行代码可能输出内容一经过长在体现上和精粹上都有异常的大的震慑,所以当一行代码只怕内容过长时提出选用  举行换号,推荐将长度限

  制在72字符。

  软件目录结构

  "设计项目目录结构",就和"代码编码风格"同样,属于个人风格难题。目录规范,能更加好的操纵程序结构,让程序有所越来越高的可读性,关于如

  何企业三个较好的Python工程目录结构,已经有部分拿走了共识的目录结构。在Stackoverflow的其一主题材料上,能看到我们对Python目录结

  构的切磋,所以一个程序的目录设计自身感到应该有以下设计,假诺你的等级次序名称叫foo,最终说一句,目录结构只是更加好的让程序有更加好的可读

  性和易维护性,所以目录结构并不是一尘不改变,领会里面的意思就能够。

  小编:新加坡小远
出处: 
本文版权归作者和今日头条共有,迎接转发,但未经小编同意必需在小说页面分明地方给出原来的小说连接,不然保留追究法律权利的职务。

Python第四章__装饰器、迭代器 应接出席Linux_Python学习群 群号:478616847 目录:...

本文由正版必中一肖图发布于编程应用,转载请注明出处:python成长之路装饰,简学生成式

上一篇:让你的生活更美好 下一篇:详解python编程数学,跟老齐学Python之啰嗦的除法
猜你喜欢
热门排行
精彩图文