初设大蟒蛇之Python函数篇,python学习系列之pyth

作者: 网络编程  发布:2019-09-03

python学习种类之python装饰器基础(1)

创建装饰器

 

# basic.py

#首先定义一个装饰器auth:

#一般装饰器
def auth(func):
    def inner():
        print 'before'
        func()
        print 'after'
    return inner

#带1个参数的装饰器
def auth_arg(func):
    def inner(arg):
        print 'before'
        func(arg)
        print 'after'
    return inner

#带多个参数的装饰器
def auth_args(func):
    def inner(*arg, **kwargs):
        print 'before'
        func(*arg,**kwargs)
        print 'after'
    return inner   


@auth
def f1():
    print 'f1'

@auth
def f2():
    print 'f2'

@auth
def f3():
    print 'f3'

#使用带1个参数的装饰器
@auth_arg
def f4(arg):
    print 'f4',arg

#使用带多个参数的装饰器   
@auth_args
def f5(arg1,arg2,arg3,arg4):
    print 'f5',arg1,arg2,arg3,arg4

 

 

2.另叁个py文件调用那一个装饰器

 

#test.py

#coding:utf-8
#!/usr/bin/env python

import basic

basic.f1()
basic.f2()
basic.f3()

#使用带1个参数的装饰器
basic.f4('123')
#使用带多个参数的装饰器
basic.f5('a','b','c','d')

 

3.尾声效果:

 

$python test.py

before
f1
after
before
f2
after
before
f3
after
before
f4 123
after
before
f5 a b c d

 

after

4.总结

经过地点多少个例证,大家发掘,使用动态参数是比较平价万能的,可适用参数不牢固的情景,因而该basic.py脚本能够改写为:

 

# basic.py


#动态参数的装饰器
def auth(func):
    def inner(*arg, **kwargs):
        print 'before'
        func(*arg,**kwargs)
        print 'after'
    return inner   


@auth
def f1():
    print 'f1'

@auth
def f2():
    print 'f2'

@auth
def f3():
    print 'f3'

@auth
def f4(arg):
    print 'f4',arg

@auth
def f5(arg1,arg2,arg3,arg4):
    print 'f5',arg1,arg2,arg3,arg4

 

 

 

) 创设装饰器 # basic.py#首先定义八个装饰器auth:#诚如装饰器def auth(func): def inner(): print before func() print af...

初设大游蛇之Python函数篇

 

1、内嵌函数:

内嵌函数,看名就会猜到其意义,就是在一个早已定义的函数内部再定义三个函数,如下轻松的内嵌函数:

#!/usr/bin/env python

 

def func_out():            ###外界函数

print "This is func_out"

def func_in(): ###个中函数

print "This is func_in"

return func_in() ###瞩目,此处重返内部函数值

print func_out()

 

出口结果:

[student@localhost day3]$ python 1.py

This is func_out ###表面函数输出

This is func_in ###个中函数输出

None                   ###鉴于此时调用的再次来到值为内部函数的再次回到值,但内部函 数无再次来到值,所以输出为None

 

对于内嵌函数,它的功效域只限于外界函数,在大局中除去外部函数,其余地点都不能调用该内嵌函数,不然会产生非常,如下例:

 图片 1

#!/usr/bin/env python

 

def func_out():

print "This is func_out"

def func_in():

print "This is func_in"

return func_in          ###只顾,此处再次回到四个函数对象,约等于在那之中等学校函授数 func_in的函数体

print func_out()

 

输出结果:

[student@localhost day3]$ python 1.py    

This is func_out

<function func_in at 0x7f1306295a28>    ###只顾此输出,由于在整段程序中没有调用内部函数,所以并未有内部函数的出口结果,可是有重临值,再次回到值为二个函数对象,也正是里面函数的地点。

 

对此内嵌函数,在实质受愚中使用或许比较普遍,上面包车型地铁例子只是贰个简约的内嵌函数结构,并从未对其进展传参,假如对内嵌函数进行传参,则会用到python中自带的一类函数--装饰器

 

2、函数装饰器

2.1对此函数装饰器,先分别观望下边两段程序的不相同,上面包车型客车五个函数用来总括函数的周转时刻,大家用sleep函数来模拟程序运行时间:

一:平常对函数举办调用  

  1 #!/usr/bin/env python

  2

  3 import time ###参与时间函数模块

  4 import datetime

  5

  6 def func_test(func):

  7 #    print "This is func_test"

  8     def func_time(*arg,**kwargs):

  9         print '[%s]' % time.ctime()     ###输出当前时光

 10         start_time = datetime.datetime.now() ###对调用函数前对时间进行总计

 11         func(*arg,**kwargs) ###调用函数

 12         end_time = datetime.datetime.now() ###对调用完函数实行时间总计

 13         cost_time = end_time - start_time ###测算函数运维时刻

 14         print '[%s]' % time.ctime() ###输出当前天子

 15         print 'running [%d] mins' % cost_time.total_seconds()    ###将运转时刻用秒输 出

 16     return func_time

 17

 18

 19 def func_test_1():                   ###测量试验函数

 20     time.sleep(3)  ###暂停3秒

 21

 22 f=func_test(func_test_1)  ###对函数举办调用

 23 f()

出口结果:

[student@localhost day3]$ python 3.py

[Mon Jun 20 21:25:40 2016]

[Mon Jun 20 21:25:43 2016]

This function running [3] mins

 

二:  利用装饰器对函数举行调用

  1 #!/usr/bin/env python

  2

  3 import time

  4 import datetime

  5

  6 def func_test(func):

  7 #   print "This is func_test"

  8     def func_time(*arg,**kwargs):

  9         print '[%s]' % time.ctime()

 10         start_time = datetime.datetime.now()

 11         func(*arg,**kwargs)

 12         end_time = datetime.datetime.now()

 13         cost_time = end_time - start_time

 14         print '[%s]' % time.ctime()

 15         print 'This function running [%d] mins' % cost_time.total_seconds()

 16     return func_time

 17

 18 @func_test ###装饰器调用

 19 def func_test_1():

 20     time.sleep(3)

 21

 22 func_test_1()

运作结果:

[student@localhost day3]$ python 3.py

[Mon Jun 20 21:33:20 2016]

[Mon Jun 20 21:33:23 2016]

This function running [3] mins

 

对此地点的多少个例证,我们能够看到使用装饰器i对函数实行调用和平时调用,产生的结果是同一的,而在第叁个例子中,@func_test 作为装饰器函数,该装饰器的成效也正是:func_test_1=func_test(func_test_1),可是,注意在行使装饰器函数时,所供给装饰的函数必定要紧跟在该函数后,在地点的举例中,也等于func_test_1()那么些须求装饰的函数必需紧跟在@func_test后,假诺中间插入别的代码,则有十分的大希望会现身非常报错,举个例子:

 18 @func_test

 19 print 'hello '

 20 def func_test_1():

 21     time.sleep(3)

2.1 大家在上头的函数中,装饰函数中插入一条无关语句,则会发出上边包车型地铁结果:

[student@localhost day3]$ python 3.py

  File "3.py", line 19

    print 'hello '

        ^

SyntaxError: invalid syntax

发出该特别,因为装饰器不可能读取装饰函数,才会提醒如下错误。

2.2 另外,装饰器也得以像函数一样“聚积”起来,如下例如:

@func_test_2

@func_test_1

def func(arg1,arg2,...):

pass

 

该“重叠”装饰器也就是:

def func(arg1,arg2,...):

pass

func = func_test_2(func_test_1(func))

还会有,装饰器也能够蕴含参数,比方:

@func_test_2(arg)

@func_test_1

def func():

pass

等价于:func = func_test_2(arg) (func_test_1(func))

 

对此地点的例证,大家大致可以领略装饰器的法力,装饰器实际上也正是一类函数,他们得以承受函数对象,简化大家对内嵌函数的调用,我们能够用装饰器来拓宽:引进日志、扩充计时逻辑来检测质量、给函数出席专门的学问的技术。

 

2.3 对于装饰器来说,当函数使用装饰器时,原函数的元数据便会成为装饰器内部函数的元数据,请看上边的例证:

 18 @func_test

 19 def func_test_1():

 20     time.sleep(3)

 21

 22 func_test_1()

 23 print func_test_1.__name__      ###咱俩在上头的函数中参预那句程序,将func_test_1函数的函数名打开输出,检查评定那几个函数在使用装饰器实行调用后函数名(元数据)是不是发生变化。

出口结果:

 图片 2

在输出结果中大家得以观望,原函数的元数据已经棉被服装饰器函数改换。假如大家在应用装饰器函数时无需更动元数据时,大家要求进入另三个模块functools,具体如下:

 图片 3

如上海体育场所,大家投入functools模块,而且在装饰器中投入第9行代码,将盛传的函数元数据举办保存,而不开展改造,输出结果:

 图片 4

在上边的出口中,大家能够见到输出的函数名还是原先的函数名,元数据并从未举行改动。不过,这种艺术也就是改换了内嵌函数的元数据,大家再对源程序开展修改,如下:

 图片 5

大家在内嵌函数前边参与输出内嵌函数元数据代码,第18行,输出结果如下:

 图片 6

在上面输出的结果中,大家可以见见内嵌函数的元数据(函数名)被改动。

 

 

3、佚名函数lambda

3.1 在python中,大家能够使用二个佚名函数来对函数举办定义:

lambda [arg1 [,arg2,arg3...] : expression

 图片 7

在上航海用教室中,大家差不离的选取了lambda进行函数定义,可是,由于lambda创造了一个函数对象,自个儿并不开展封存,所以会平昔回到一个函数对象,这样我们须要对lambda重回对象开展封存,如上海体育场地中,用result实行封存函数对象,由于lambda成立函数中开创了五个参数,并且重临了x+y那些表达时的值,所以我们载调用时要求进行传参。

 图片 8

同一,lambda函数也足以拓宽岗位传参,也足以覆盖参数。

 图片 9

 3.2 lambda的作用域

有如普通函数一样,lambda函数也一样遵从一定的成效域范围

 图片 10

图片 11

 

对此功效域的限定,在地点两幅图中,大家得以见见,lambda函数的运用功能域和平凡函数一样。

 

4、生成器

4.1 在python中,生成器的效应类似于迭代器,然而生成器使用另一种方法来运转,当达到多少个实在的回到恐怕函数结束未有越来越多的重临值时,就能脱离(当调用next(),出现StopIteration分外时,就可以退出)。生成器在python中能够当做Infiniti迭代来使用,大家来看个例证:

 图片 12

 

在下图中,我们定义二个生成器,打字与印刷10以内的奇数:

 图片 13

在上头的例证中,利用for循环,相当于进行了往往next()操作。

生成器中,大家不只能够动用next()将生成器再次来到值进行输出,也足以对生成器举行send()传入数据,在使用send()传入参数时,暗中认可将盛传的参数举行next()操作,如下比如:

 图片 14

在上航海用体育场面中的例子中,我们对生成器传入参数,若是传入字符为’q’,则脱离。注意,在上边的次序中,recv = yield value 那句代码也正是,先对value实行一回中断,然后等待外部的参数字传送入,何况对recv举办赋值,在这里,由于由于第叁遍运营时并没有对外边诉求传入参数,所以大家在第一遍send传参时要求传入二个空值,不然会有非常。而当最终二次传入参数为’q’时,由于生成器在伸手完,私下认可进行next()输出时,函数已经脱离,所以,不能正常输出,所以在上头的例子中,输出结果会报出十二分。

 

大家来做二个简单易行的对话生成器:

  1 #!/usr/bin/env python

  2

  3 def gen():

  4     value = 0

  5     while True:

  6         recv = yield value

  7         if recv == 'hello':

  8             value = 'hello~~~~'

  9         elif recv == 'age':

 10             value = '18'

 11         else:

 12             value = 'what do say?'

 13         recv = value

 14

 15 g=gen()

 16 g.send(None)

 17 while True:

 18     text=raw_input("please input: ")

 19     if text == 'bye':

 20         print "bye~~~"

 21         break

 22     print g.send(text)

 

出口结果:

图片 15

本文由王中王开奖结果发布于网络编程,转载请注明出处:初设大蟒蛇之Python函数篇,python学习系列之pyth

关键词: