美文网首页
第七章:函数

第七章:函数

作者: overad | 来源:发表于2018-03-09 10:43 被阅读0次

    用def语句定义的函数是所有程序的基石;

    1.编写可接受任意数量参数的函数

    解决方案:要编写一个可接受任意数量的位置参数的函数,可以使用以*开头的参数;

    >>> def avg(first,*rest):
    ...     return (first + sum(rest)) / (1 + len(rest))
    ...
    >>> avg(1,2,3,4,5,6,7)
    4.0
    >>> avg(1,2)
    1.5
    

    如果要接受任意数量的关键字参数(字典),可以使用**开头的参数;

    def make_element(name,value,attrs):
    如果想要函数能同时接受任意梳理的位置参数和关键字参数,只要联合使用
    即可
    def anyargs(
    args,**attrs):

    在函数定义中,以打头的参数只能作为最后一个位置参数出现,而以打头的参数只能作为最后一个参数出现。在函数定义中存在一种很微妙的特性,那就是在打头的参数后仍然可以有其他参数出现;def fn(x,*arg,y):

    2.编写只接受关键字参数的函数

    3.将元数据信息附加到函数参数上

    问题:我们已将编写好了一个函数,但是希望能为参数附加上一些额外的信息,这样其他人可以对函数的使用方法有更多的认识和了解;

    解决方案:函数的参数注释可以提示程序员该函数该如何使用,这是很有帮助的。

    >>> def add(x:int,y:int)->int:
    ...     return x + y
    ...
    >>> add(3,4)
    7
    #函数的注释只会保存在函数的__annotations__属性中。
    >>> add.__annotations__
    {'x': <class 'int'>, 'y': <class 'int'>, 'return': <class 'int'>}
    >>>
    

    4.从函数中返回多个值

    解决方案:要从函数中返回多个值,只要简单地返回一个元组即可。

    >>> def myfun():
    ...     return 1,2,3
    ...
    >>> a,b,c = myfun()
    >>> a
    1
    >>> b
    2
    >>> c
    3
    >>>
    

    尽管看起来myfun()返回了多个值,但实际上它只创建了一个元组而已;当调用的函数返回了元组,通常会将结果复制给多个变量,就是示例中的那样。实际上这就是简单的元祖解包,

    5.定义带有默认参数的函数

    解决方案:表明上看定义一个带有可选参数的函数是非常简单的--只需要在定义中为参数赋值,并确保默认参数出现在最后即可;

    >>> def spam(a,b=43):
    ...     print(a,b)
    ...
    >>> spam(1)
    1 43
    >>> spam(1,32)
    1 32
    

    如果默认值是可变容器的话,比如说列表,集合或者字典,那么应该吧None作为默认值。

    #Using a list as a default value
    >>>def spam(a,b=None):
    >>>      if b is None:
    >>>              b = []
    ...
    

    如果不打算提供一个默认值的话,只是想编写代码来检测可选参数是否被赋予了某个特定的值,可以采用下面的惯用手法:

    >>> _no_value = object()
    >>> def spam(a,b=_no_value):
    ...     if b is _no_value:
    ...             print('No b value supplied')
    ...     print(a,b)
    ...
    >>> spam(1)
    No b value supplied
    1 <object object at 0x0000000001D69110>
    >>> spam(1,2)
    1 2
    >>>
    

    6.定义匿名或内联函数

    解决方案:简单的函数可以通过lambda表达式来完成;

    >>> add = lambda x ,y:x+y
    >>> add(2,3)
    5
    >>> add("hello","world")
    'helloworld'
    

    7.在匿名函数中绑定参数的值

    >>> x = 10
    >>> a = lambda y : x+y
    >>> x = 20
    >>> b = lambda y:x+y
    >>> a(10)
    30
    >>> b(10)
    30
    

    这里的问题在于lambda表达式中用到的x是一个自由变量,在运行时才进行绑定而不是定义的时候绑定,
    如果希望匿名函数可以在定义的时候绑定参数,并保持不变,那么可以将那个值作为默认参数实现;

    >>> a = lambda y,x=x:x+y
    >>> a(10)
    20
    
    #实例一:lambda x,n=n:x+n for n in range(5)
    >>> funcs = [lambda x,n=n:x+n for n in range(5)]
    >>> for f in funcs:
    ...     print(f(0))
    ...
    0
    1
    2
    3
    4
    
    #实例二:lambda x:x+n for n in range(5)
    >>> funcs = [lambda x:x+n for n in range(5)]
    >>> for f in funcs:
    ...     print(f(0))
    ...
    4
    4
    4
    4
    4
    

    8.让带有N个参数的可调用对象以教学少的参数形式调用

    9.让函数替换只有单个方法的类

    10.在回调函数中携带额外的状态

    11.内联回调函数

    12.访问定义在闭包内的变量

    相关文章

      网友评论

          本文标题:第七章:函数

          本文链接:https://www.haomeiwen.com/subject/ipbjfftx.html