zoukankan      html  css  js  c++  java
  • 函数和装饰器

    函数定义

    在Python中,定义一个函数要使用def语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回。
    我们以自定义一个求绝对值的my_abs函数为例:

    def my_abs(x):
        if x >= 0:
            return x
        else:
            return -x

    请自行测试并调用my_abs看看返回结果是否正确。

    请注意,函数体内部的语句在执行时,一旦执行到return时,函数就执行完毕,并将结果返回。因此,函数内部通过条件判断和循环可以实现非常复杂的逻辑。

    如果没有return语句,函数执行完毕后也会返回结果,只是结果为None。

    return None可以简写为return。

    空函数

    如果想定义一个什么事也不做的空函数,可以用pass语句:

    def nop():
        pass

    pass语句什么都不做,那有什么用?实际上pass可以用来作为占位符,比如现在还没想好怎么写函数的代码,就可以先放一个pass,让代码能运行起来。

    pass还可以用在其他语句里,比如:

    if age >= 18:
        pass

    缺少了pass,代码运行就会有语法错误。

    函数作用域

    块级作用域

    if 1 == 1:
        name = "lzl"
    
    print(name)
    
    
    for i in range(10):
        age = i
    
    print(age)

    运行结果:

    lzl
    9

    代码执行成功,没有问题;在Java/C#中,执行上面的代码会提示name,age没有定义,而在Python中可以执行成功,这是因为在Python中是没有块级作用域的,代码块里的变量,外部可以调用,所以可运行成功;

    局部作用域

    def  func():
        name = "lzl"
    
    print(name)

    运行结果:

    Traceback (most recent call last):
      File "test.py", line 4, in <module>
        print(name)
    NameError: name 'name' is not defined
    

    运行报错,我相信这个大家都能理解,name变量只在func()函数内部中生效,所以在全局中是没法调用的;对上面代码做个简单调整,再看看结果如何?

    def  func():
        name = "lzl"
    
    func()          #执行函数
    print(name)

    运行结果:

    Traceback (most recent call last):
      File "test.py", line 5, in <module>
        print(name)
    NameError: name 'name' is not defined

    执行依然报错,还是回到刚才那句话:即使执行了一下函数,name的作用域也只是在函数内部,外部依然无法进行调用;

    作用域链

    name = "lzl"
    def f1():
        name = "Eric"
        def f2():
            name = "Snor"
            print(name)
        f2()
    f1()

    运行结果:

    Snor

    学过函数,肯定知道最后f1()执行完会输出Snor;我们先记住一个概念,Python中有作用域链,变量会由内到外找,先去自己作用域去找,自己没有再去上级去找,直到找不到报错

    终极版作用域

    name = "lzl"
    
    def f1():
        print(name)
    
    def f2():
        name = "eric"
        f1()
    
    f2()
    

    想想最后f2()执行结果是打印“lzl”呢,还是打印“eric”?记住自己的答案,现在先不把答案贴出来,先看看下面这段代码:

    name = "lzl"
    
    def f1():
        print(name)
    
    def f2():
        name = "eric"
        return f1
    
    ret = f2()
    ret()
    

    运行结果

    lzl

    执行结果为“lzl”,分析下上面的代码,f2()执行结果为函数f1的内存地址,即ret=f1;执行ret()等同于执行f1(),执行f1()时与f2()没有任何关系,name=“lzl”与f1()在一个作用域链,函数内部没有变量是会向外找,所以此时变量name值为“lzl”;理解了这个,那么刚才没给出答案的那个终极代码你也知道答案了

    name = "lzl"
    def f1():
        print(name)
    def f2():
        name = "eric"
        f1()
    f2()

    运行结果:

    lzl

    是的,输出的是“lzl”,记住在函数未执行之前,作用域已经形成了,作用域链也生成了.

    函数参数

    定义:

    定义函数的时候,我们把参数的名字和位置确定下来,函数的接口定义就完成了。对于函数的调用者来说,只需要知道如何传递正确的参数,以及函数将返回什么样的值就够了,函数内部的复杂逻辑被封装起来,调用者无需了解。
    Python的函数定义非常简单,但灵活度却非常大。除了正常定义的必选参数外,还可以使用默认参数、可变参数和关键字参数,使得函数定义出来的接口,不但能处理复杂的参数,还可以简化调用者的代码

    默认参数

    我们仍以具体的例子来说明如何定义函数的默认参数。先写一个计算x2的函数:

    def f1(x):
        return x * x
    
    ret = f1(5)
    print(ret)

    运行结果

    25

    当我们调用power函数时,必须传入有且仅有的一个参数x:
    现在,如果我们要计算x3怎么办?可以再定义一个power3函数,但是如果要计算x4、x5……怎么办?我们不可能定义无限多个函数。

    def power(x, n):
        s = 1
        while n > 0:
            n = n - 1
            s = s * x
        return s

    对于这个修改后的power函数,可以计算任意n次方:

    >>> power(5, 2)
    25
    >>> power(5, 3)
    125

    但是,旧的调用代码失败了,原因是我们增加了一个参数,导致旧的代码无法正常调用:

    >>> power(5)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: power() takes exactly 2 arguments (1 given)

    这个时候,默认参数就排上用场了。由于我们经常计算x2,所以,完全可以把第二个参数n的默认值设定为2:

    def power(x, n=2):
        s = 1
        while n > 0:
            n = n - 1
            s = s * x
        return s

    这样,当我们调用power(5)时,相当于调用power(5, 2):

    >>> power(5)
    25
    >>> power(5, 2)
    25

    而对于n > 2的其他情况,就必须明确地传入n,比如power(5, 3)。

    从上面的例子可以看出,默认参数可以简化函数的调用。设置默认参数时,有几点要注意:

    一是必选参数在前,默认参数在后,否则Python的解释器会报错(思考一下为什么默认参数不能放在必选参数前面);
    二是如何设置默认参数。
    当函数有多个参数时,把变化大的参数放前面,变化小的参数放后面。变化小的参数就可以作为默认参数。
    使用默认参数有什么好处?最大的好处是能降低调用函数的难度。

    可变参数

    在Python函数中,还可以定义可变参数。顾名思义,可变参数就是传入的参数个数是可变的,可以是1个、2个到任意个,还可以是0个。
    我们以数学题为例子,给定一组数字a,b,c……,请计算a2 + b2 + c2 + ……。
    要定义出这个函数,我们必须确定输入的参数。由于参数个数不确定,我们首先想到可以把a,b,c……作为一个list或tuple传进来,这样,函数可以定义如下:

    def calc(numbers):
        sum = 0
        for n in numbers:
            sum = sum + n * n
        return sum

    但是调用的时候,需要先组装出一个list或tuple:

    >>> calc([1, 2, 3])
    14
    >>> calc((1, 3, 5, 7))
    84

    如果利用可变参数,调用函数的方式可以简化成这样:

    >>> calc(1, 2, 3)
    14
    >>> calc(1, 3, 5, 7)
    84

    所以,我们把函数的参数改为可变参数:

    def calc(*numbers):
        sum = 0
        for n in numbers:
            sum = sum + n * n
        return sum

    定义可变参数和定义list或tuple参数相比,仅仅在参数前面加了一个*号。在函数内部,参数numbers接收到的是一个tuple,因此,函数代码完全不变。但是,调用该函数时,可以传入任意个参数,包括0个参数:

    >>> calc(1, 2)
    5
    >>> calc()
    0

    如果已经有一个list或者tuple,要调用一个可变参数怎么办?可以这样做:

    >>> nums = [1, 2, 3]
    >>> calc(nums[0], nums[1], nums[2])
    14

    这种写法当然是可行的,问题是太繁琐,所以Python允许你在list或tuple前面加一个*号,把list或tuple的元素变成可变参数传进去:

    >>> nums = [1, 2, 3]
    >>> calc(*nums)
    14

    这种写法相当有用,而且很常见。

    关键字参数

    可变参数允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。请看示例:

    def person(name, age, **kw):
        print 'name:', name, 'age:', age, 'other:', kw

    函数person除了必选参数name和age外,还接受关键字参数kw。在调用该函数时,可以只传入必选参数:

    >>> person('Michael', 30)
    name: Michael age: 30 other: {}

    也可以传入任意个数的关键字参数:

    >>> person('Bob', 35, city='Beijing')
    name: Bob age: 35 other: {'city': 'Beijing'}
    >>> person('Adam', 45, gender='M', job='Engineer')
    name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

    关键字参数有什么用?它可以扩展函数的功能。比如,在person函数里,我们保证能接收到name和age这两个参数,但是,如果调用者愿意提供更多的参数,我们也能收到。试想你正在做一个用户注册的功能,除了用户名和年龄是必填项外,其他都是可选项,利用关键字参数来定义这个函数就能满足注册的需求。

    和可变参数类似,也可以先组装出一个dict,然后,把该dict转换为关键字参数传进去:

    >>> kw = {'city': 'Beijing', 'job': 'Engineer'}
    >>> person('Jack', 24, city=kw['city'], job=kw['job'])
    name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

    当然,上面复杂的调用可以用简化的写法:

    >>> kw = {'city': 'Beijing', 'job': 'Engineer'}
    >>> person('Jack', 24, **kw)
    name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

    组合参数

    在Python中定义函数,可以用必选参数、默认参数、可变参数和关键字参数,这4种参数都可以一起使用,或者只用其中某些,但是请注意,参数定义的顺序必须是:必选参数、默认参数、可变参数和关键字参数。

    比如定义一个函数,包含上述4种参数:

    def func(a, b, c=0, *args, **kw):
        print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw

    在函数调用的时候,Python解释器自动按照参数位置和参数名把对应的参数传进去。

    >>> func(1, 2)
    a = 1 b = 2 c = 0 args = () kw = {}
    >>> func(1, 2, c=3)
    a = 1 b = 2 c = 3 args = () kw = {}
    >>> func(1, 2, 3, 'a', 'b')
    a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
    >>> func(1, 2, 3, 'a', 'b', x=99)
    a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}

    最神奇的是通过一个tuple和dict,你也可以调用该函数:

    >>> args = (1, 2, 3, 4)
    >>> kw = {'x': 99}
    >>> func(*args, **kwargs)
    a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}

    所以,对于任意函数,都可以通过类似func(args, *kw)的形式调用它,无论它的参数是如何定义的。

    小结

    Python的函数具有非常灵活的参数形态,既可以实现简单的调用,又可以传入非常复杂的参数。

    默认参数一定要用不可变对象,如果是可变对象,运行会有逻辑错误!

    要注意定义可变参数和关键字参数的语法:

    *args是可变参数,args接收的是一个tuple;

    **kwargs是关键字参数,kw接收的是一个dict。

    以及调用函数时如何传入可变参数和关键字参数的语法:

    可变参数既可以直接传入:func(1, 2, 3),又可以先组装list或tuple,再通过args传入:func((1, 2, 3));

    关键字参数既可以直接传入:func(a=1, b=2),又可以先组装dict,再通过**kw传入:func(**{'a': 1, 'b': 2})。

    使用args和*kwargs是Python的习惯写法,当然也可以用其他参数名,但最好使用习惯用法。

    高阶函数与函数返回值

    高阶函数

    • 高阶函数就是可以接收函数对象作为参数的函数

    函数返回值

    • 执行完函数之后返回的结果就是函数返回值
      对于函数的返回值可以用return进行返回,对返回值进行print就能拿到返回结果。
      函数是一个功能块,该功能是否成功执行,需要通过返回值来告诉调用者
      return值返回之后后面的代码将不再执行

    lambda与匿名函数

    lambda就是简单函数的表达式,也可以说它是一个匿名函数。然而在使用它或是阅读Lambda代码的时候,却显得并不那么容易。因为它匿名,因为它删减了一些必要的说明信息(比如方法名)。下面就来说说Lambda是如何进行转换和工作的吧。

    举个例子:

    def func(a):
        a += 1
        return a
    b = func(4)
    print(b)
    
    c = lambda d: d+1   ## 使用lambda就可以一行搞定
    f = c(4)
    print(f)

    Python中,也有几个定义好的全局函数方便使用的,filter, map, reduce

    >>> foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
    >>>
    >>> print filter(lambda x: x % 3 == 0, foo)
    [18, 9, 24, 12, 27]
    >>>
    >>> print map(lambda x: x * 2 + 10, foo)
    [14, 46, 28, 54, 44, 58, 26, 34, 64]
    >>>
    >>> print reduce(lambda x, y: x + y, foo)
    139

    上面例子中的map的作用,非常简单清晰。但是,Python是否非要使用lambda才能做到这样的简洁程度呢?在对象遍历处理方面,其实Python的for..in..if语法已经很强大,并且在易读上胜过了lambda。
    比如上面map的例子,可以写成:
    print [x * 2 + 10 for x in foo]
    非常的简洁,易懂。
    filter的例子可以写成:
    print [x for x in foo if x % 3 == 0]
    同样也是比lambda的方式更容易理解。
    通过此例子,我们发现,lambda的使用大量简化了代码,使代码简练清晰。但是值得注意的是,这会在一定程度上降低代码的可读性。如果不是非常熟悉python的人或许会对此感到不可理解。

    map

    遍历序列,对序列中每个元素进行操作,最终获取新的序列。

    #  每个元素增加y100
    li = [11, 22, 33]
    new_list = map(lambda a: a + 100, li)
    # 两个列表对应元素相加
    li = [11, 22, 33]
    sl = [1, 2, 3]
    new_list = map(lambda a, b: a + b, li, sl)

    filter

    对于序列中的元素进行筛选,最终获取符合条件的序列

    # 获取列表中大于12的所有元素集合
    
    li = [11, 22, 33]
    
    new_list = filter(lambda arg: arg > 22, li)
    
    #filter第一个参数为空,将获取原来序列
    

    reduce

    对于序列内所有元素进行累计操作

    #获取数列所有元素的和
    li = [11, 22, 33]
    
    result = reduce(lambda arg1, arg2: arg1 + arg2, li)
    
    # reduce的第一个参数,函数必须要有两个参数
    # reduce的第二个参数,要循环的序列
    # reduce的第三个参数,初始值

    lambda小结

    lambda 定义了一个匿名函数
    lambda 并不会带来程序运行效率的提高,只会使代码更简洁
    如果可以使用for…in…if来完成的,坚决不用lambda。
    如果使用lambda,lambda内不要包含循环,如果有,我宁愿定义函数来完成,使代码获得可重用性和更好的可读性
    总结:lambda 是为了减少单行函数的定义而存在的。

    装饰器

    格式

    def timer(func):
        def inner(*args,**kwargs):
            '''执行函数之前要做的'''
            re = func(*args,**kwargs)
            '''执行函数之后要做的'''
            return re
        return inner

    装饰器原理

    • 装饰器是函数,只不过该函数可以具有特殊的含义,装饰器用来装饰函数或类,使用装饰器可以在函数执行前和执行后添加相应操作。
    def wrapper(func):
        def result():
            print 'before'
            func()
            print 'after'
        return result
    
    @wrapper
    def foo():
        print 'foo'

    带参数的装饰器

    #!/usr/bin/env python
    #coding:utf-8
    
    def Before(request,kargs):
        print 'before'
    
    def After(request,kargs):
        print 'after'
    
    
    def Filter(before_func,after_func):
        def outer(main_func):
            def wrapper(request,kargs):
    
                before_result = before_func(request,kargs)
                if(before_result != None):
                    return before_result;
    
                main_result = main_func(request,kargs)
                if(main_result != None):
                    return main_result;
    
                after_result = after_func(request,kargs)
                if(after_result != None):
                    return after_result;
    
            return wrapper
        return outer
    
    @Filter(Before, After)
    def Index(request,kargs):
        print 'index'
    
    
    if __name__ == '__main__':
        Index(1,2)

    装饰器应用

    import functools
    
    
    def wrapper(func):
        @functools.wraps(func)
        def wrapper():
            print 'before'
            func()
            print 'after'
        return wrapper
    
    @wrapper
    def foo():
        print 'foo'

    装饰器小结

    可以装饰具有处理n个参数的函数的装饰器
    一个函数可以被多个装饰器装饰
    装饰器内的函数代指了原函数,注意其只是代指而非相等,原函数的元信息没有被赋值到装饰器函数内部。例如:函数的注释信息
    如果使用@functools.wraps装饰装饰器内的函数,那么就会代指元信息和函数。
    装饰器的本质:一个闭包函数
    装饰器的功能:在不修改原函数及其调用方式的情况下对原函数功能进行扩展

    # 无元信息
    def outer(func):
        def inner(*args, **kwargs):
            print(inner.__doc__)  # None
            return func()
        return inner
    
    @outer
    def function():
        """
        asdfasd
        :return:
        """
        print('func')
    
    
    # 含元信息
    def outer(func):
        @functools.wraps(func)
        def inner(*args, **kwargs):
            print(inner.__doc__)  # None
            return func()
        return inner
    
    @outer
    def function():
        """
        asdfasd
        :return:
        """
        print('func')
    
    

    开放封闭原则

    1.对扩展是开放的
      为什么要对扩展开放呢?
      我们说,任何一个程序,不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改。所以我们必须允许代码扩展、添加新功能。

    2.对修改是封闭的
      为什么要对修改封闭呢?
      因为我们写的一个函数,很有可能已经交付给其他人使用了,如果这个时候我们对其进行了修改,很有可能影响其他已经在使用该函数的用户。
    装饰器完美的遵循了这个开放封闭原则。

    闭包概念

    “闭包”的意思,望文知意,可以形象的把它理解为一个封闭的包裹,这个包裹就是一个函数,当然还有函数内部对应的逻辑,包裹里面的东西就是自由变量,自由变量可以在随着包裹到处游荡。当然还得有个前提,这个包裹是被创建出来的。
    在通过Python的语言介绍一下,一个闭包就是你调用了一个函数A,这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。你在调用函数A的时候传递的参数就是自由变量。
    

    举个栗子:

    def func(name):
        def inner_func(age):
            print 'name:', name, 'age:', age
        return inner_func
    
    bb = func('the5fire')
    bb(26)  # >>> name: the5fire age: 26

    这里面调用func的时候就产生了一个闭包——inner_func,并且该闭包持有自由变量——name,因此这也意味着,当函数func的生命周期结束之后,name这个变量依然存在,因为它被闭包引用了,所以不会被回收。
    另外再说一点,闭包并不是Python中特有的概念,所有把函数做为一等公民的语言均有闭包的概念。不过像Java这样以class为一等公民的语言中也可以使用闭包,只是它得用类或接口来实现。

    闭包的作用

    闭包的最大特点是可以将父函数的变量与内部函数绑定,并返回绑定变量后的函数(也即闭包),此时即便生成闭包的环境(父函数)已经释放,闭包仍然存在,这个过程很像类(父函数)生成实例(闭包),不同的是父函数只在调用时执行,执行完毕后其环境就会释放,而类则在文件执行时创建,一般程序执行完毕后作用域才释放,因此对一些需要重用的功能且不足以定义为类的行为,使用闭包会比使用类占用更少的资源,且更轻巧灵活。
    闭包还有很多其他功能,比如用于封装等,另外,闭包有效的减少了函数参数的数目,这对并行计算非常有价值,比如可以让每台电脑负责一个函数,然后串起来,实现流水化的作业等。

    选择了奋斗,以后可以随时还有选择安逸的权力。 但选择了安逸,可能以后就不那么轻易还能有选择奋斗的权力。
  • 相关阅读:
    奖学金 题解
    大数加法
    删除倒数第 N 个节点
    css中行内元素默认间隙解决方案
    vuecli3项目中优化lodash/moment使用
    谷歌浏览器input输入框自动填充数据
    vuecli3首页白屏优化
    highcharts开发交易所的行情走势图
    react-native使用flatlist上拉加载下拉刷新
    放大预览图片不失真
  • 原文地址:https://www.cnblogs.com/wtli/p/7779689.html
Copyright © 2011-2022 走看看