精华内容
下载资源
问答
  • 在定义函数时,Python支持默认值参数,在定义函数时可以为形参设置默认值。在调用带有默认值参数的函数时,可以不用为设置了默认值的形参进行传值,此时函数将会直接使用函数定义时设置的默认值,...

    在定义函数时,Python支持默认值参数,在定义函数时可以为形参设置默认值。在调用带有默认值参数的函数时,可以不用为设置了默认值的形参进行传值,此时函数将会直接使用函数定义时设置的默认值,当然也可以通过显式赋值来替换其默认值。也就是说,在调用函数时是否为默认值参数传递实参是可选的,具有较大的灵活性。例如:

    >>> def say( message, times =1 ):
                 print((message+' ') * times)

    >>> say('hello')
    hello
    >>> say('hello', 3)
    hello hello hello

    好了,下面重点介绍默认值参数的坑,虽然说是两个坑,但实际上是一个意思。

    (1)默认值参数的值是在函数定义时确定的

    >>> i = 3
    >>> def f(n=i): #参数n的值仅取决于i的当前值
                 print(n)
    >>> f()
    3
    >>> i = 5 #函数定义后修改i的值不影响参数n的默认值
    >>> f()
    3
    >>> i = 7
    >>> f()
    3
    >>> def f(n=i): #重新定义函数
                print(n)
    >>> f()
    7

    (2)默认值参数只初始化一次

    如果参数的默认值是数字、字符串、元组或其他不可变类型的数据,并不会有什么影响,但是如果参数的默认值是列表、字典、集合等可变类型数据的话,这里有个大坑。

    >>> def demo(newitem, old_list=[]):
                old_list.append(newitem)
                return old_list

    >>> print(demo('5', [1, 2, 3, 4]))
    [1, 2, 3, 4, '5']
    >>> print(demo('aaa', ['a', 'b']))
    ['a', 'b', 'aaa']
    >>> print(demo('a'))
    ['a']
    >>> print(demo('b')) #注意这里的输出结果
    ['a', 'b']

    如果想得到正确结果,建议把函数写成下面的样子:

    def demo(newitem, old_list=None):
        if old_list is None:
            old_list = []
        old_list.append(newitem)
        return old_list

    展开全文
  • def add_list(ori_list=[], element=None): ori_list.append(element) return ori_list
  • 在stackoverflow上看到这样一个程序: ... /usr/bin/env python # -*- coding: utf-8 -*- class demo_list: def __init__(self, l=[]): self.l = l def add(self, ele): self.l.append(ele) def app

    在stackoverflow上看到这样一个程序:

    #! /usr/bin/env python
    # -*- coding: utf-8 -*-
    
    class demo_list:
        def __init__(self, l=[]):
            self.l = l
    
        def add(self, ele):
            self.l.append(ele)
    
    def appender(ele):
        obj = demo_list()
        obj.add(ele)
        print obj.l
    
    if __name__ == "__main__":
        for i in range(5):
            appender(i)
    

    输出结果是

    [0] 
    [0, 1] 
    [0, 1, 2] 
    [0, 1, 2, 3] 
    [0, 1, 2, 3, 4]

    有点奇怪,难道输出不应该是像下面这样吗?

    <!-- more -->

    [0] 
    [1] 
    [2] 
    [3] 
    [4]

    其实想要得到上面的输出,只需要将obj = intlist()替换为obj = intlist(l=[])

    默认参数工作机制

    上面怪异的输出简单来说是因为:

    Default values are computed once, then re-used.

    因此每次调用__init__(),返回的是同一个list。为了验证这一点,下面在__init__函数中添加一条语句,如下:

    def __init__(self, l=[]):
        print id(l),
        self.l = l
    

    输出结果为:

    4346933688 [0] 
    4346933688 [0, 1] 
    4346933688 [0, 1, 2] 
    4346933688 [0, 1, 2, 3] 
    4346933688 [0, 1, 2, 3, 4]

    可以清晰看出每次调用__init__函数时,默认参数l都是同一个对象,其id为4346933688。

    关于默认参数,文档中是这样说的:

    Default parameter values are evaluated when the function definition is executed. This means that the expression is evaluated once, when the function is defined, and that the same “pre-computed” value is used for each call.

    为了能够更好地理解文档内容,再来看一个例子:

    def a():
        print "a executed"
        return []
    
    def b(x=a()):
        print "id(x): ", id(x)
        x.append(5)
        print "x: ", x
    
    for i in range(2):
        print "-" * 15, "Call b()", "-" * 15
        b()
        print b.__defaults__
        print "id(b.__defaults__[0]): ", id(b.__defaults__[0])
    
    for i in range(2):
        print "-" * 15, "Call b(list())", "-" * 15
        b(list())
        print b.__defaults__
        print "id(b.__defaults__[0]): ", id(b.__defaults__[0])
    

    注意,当python执行def语句时,它会根据编译好的函数体字节码和命名空间等信息新建一个函数对象,并且会计算默认参数的值。函数的所有构成要素均可通过它的属性来访问,比如可以用func_name属性来查看函数的名称。所有默认参数值则存储在函数对象的__defaults__属性中,它的值为一个列表,列表中每一个元素均为一个默认参数的值。

    好了,你应该已经知道上面程序的输出内容了吧,一个可能的输出如下(id值可能为不同):

    a executed 
    --------------- Call b() --------------- 
    id(x): 4316528512 
    x: [5] 
    ([5],) 
    id(b.__defaults__[0]): 4316528512 
    --------------- Call b() --------------- 
    id(x): 4316528512 
    x: [5, 5] 
    ([5, 5],) 
    id(b.__defaults__[0]): 4316528512 
    --------------- Call b(list()) --------------- 
    id(x): 4316684872 
    x: [5] 
    ([5, 5],) 
    id(b.__defaults__[0]): 4316528512 
    --------------- Call b(list()) --------------- 
    id(x): 4316684944 
    x: [5] 
    ([5, 5],) 
    id(b.__defaults__[0]): 4316528512

    我们看到,在定义函数b(也就是执行def语句)时,已经计算出默认参数x的值,也就是执行了a函数,因此才会打印出a executed。之后,对b进行了4次调用,下面简单分析一下:

    1. 第一次不提供默认参数x的值进行调用,此时使用函数b定义时计算出来的值作为x的值。所以id(x)和id(b.__defaults__[0])相等,x追加数字后,函数属性中的默认参数值也变为[5];

    2. 第二次仍然没有提供参数值,x的值为经过第一次调用后的默认参数值[5],然后对x进行追加,同时也对函数属性中的默认参数值追加;

    3. 传递参数list()来调用b,此时新建一个列表作为x的值,所以id(x)不同于函数属性中默认参数的id值,追加5后x的值为[5];

    4. 再一次传递参数list()来调用b,仍然是新建列表作为x的值。

    如果上面的内容你已经搞明白了,那么你可能会觉得默认参数值的这种设计是python的设计缺陷,毕竟这也太不符合我们对默认参数的认知了。然而事实可能并非如此,更可能是因为:

    Functions in Python are first-class objects, and not only a piece of code.

    我们可以这样解读:函数也是对象,因此定义的时候就被执行,默认参数是函数的属性,它的值可能会随着函数被调用而改变。其他对象不都是如此吗?

    可变对象作为参数默认值?

    参数的默认值为可变对象时,多次调用将返回同一个可变对象,更改对象值可能会造成意外结果。参数的默认值为不可变对象时,虽然多次调用返回同一个对象,但更改对象值并不会造成意外结果。

    因此,在代码中我们应该避免将参数的默认值设为可变对象,上面例子中的初始化函数可以更改如下:

    def __init__(self, l=None):
           if not l:
                self.l = []
           else:
                self.l = l
    

    在这里将None用作占位符来控制参数l的默认值。不过,有时候参数值可能是任意对象(包括None),这时候就不能将None作为占位符。你可以定义一个object对象作为占位符,如下面例子:

    sentinel = object()
    
    def func(var=sentinel):
       if var is sentinel:
            pass
       else:
            print var
    

    虽然应该避免默认参数值为可变对象,不过有时候使用可变对象作为默认值会收到不错的效果。比如我们可以用可变对象作为参数默认值来统计函数调用次数,下面例子中使用collections.Counter()作为参数的默认值来统计斐波那契数列中每一个值计算的次数。

    def fib_direct(n, count=collections.Counter()):
        assert n > 0, 'invalid n'
        count[n] += 1
        if n < 3:
            return n
        else:
            return fib_direct(n - 1) + fib_direct(n - 2)
    
    print fib_direct(10)
    print fib_direct.__defaults__[0]
    

    运行结果如下:

    89 
    Counter({2: 34, 1: 21, 3: 21, 4: 13, 5: 8, 6: 5, 7: 3, 8: 2, 9: 1, 10: 1})

    我们还可以用默认参数来做简单的缓存,仍然以斐波那契数列作为例子,如下:

    def fib_direct(n, count=collections.Counter(), cache={}):
        assert n > 0, 'invalid n'
        count[n] += 1
        if n in cache:
            return cache[n]
        if n < 3:
            value = n
        else:
            value = fib_direct(n - 1) + fib_direct(n - 2)
        cache[n] = value
        return value
    
    print fib_direct(10)
    print fib_direct.__defaults__[0]
    

    结果为:

    89 
    Counter({2: 2, 3: 2, 4: 2, 5: 2, 6: 2, 7: 2, 8: 2, 1: 1, 9: 1, 10: 1})

    这样就快了太多了,fib_direct(n)调用次数为o(n),这里也可以用装饰器来实现计数和缓存功能。

    展开全文
  • return b print(pred(10)) print(pred(20)) print(pred(30)) def predd(a): b=[] b.insert(0,a) return b print(predd(10)) print(predd(20)) print(predd(30)) 结果: [10] [20, 10] [30, ...
  • 在固定长度参数中需要设置关键字参数的默认值, ```d=1, e=2```就是设置的默认值,不传入关键字参数的时候就是使用该默认值,也可以根据需要更改默认值

    前言

    python中函数的参数有两种:位置参数和关键字参数,其中又分为固定长度的位置参数、关键字参数和不定长位置参数、关键字参数。
    固定长度参数:

    In [01]: def fun1(a, b, c, d=1, e=2):
        		print(a, b, c, d, e)
    
    In [02]: fun1(1, 2, 3)
    Out[02]: 1 2 3 1 2
    

    不定长参数:

    In [04]: def fun1(*args, **kwargs):
    		    print(args)
    		    print(kwargs)
    
    In [05]: l1 = ['a', 'b', 'c']
    In [06]: l2 = {'a':1, 'b':2, 'c':3}
    
    In [07]: fun1(l1, **l2)
    Out[07]: (['a', 'b', 'c'],)
    		 {'a': 1, 'b': 2, 'c': 3}
    

    而在固定长度参数中需要设置关键字参数的默认值, d=1, e=2就是设置的默认值,不传入关键字参数的时候就是使用该默认值,也可以根据需要更改默认值,然后就有了下面的三种重新设置默认值的方法

    1.直接修改默认值

    这种方法很常见,也是众所周知的,那就是直接在传参的时候修改默认值

    In [08]: fun1(1, 2, 3, d=11, e=22)
    Out[08]: 1 2 3 11 22
    

    直接传入这次要更改的默认值即可,但是如果有100个默认值,而更改默认值后的函数我要使用100次,那不就是
    fun1(1, 2, 3, d=11, e=22 · · · · · ·)
    fun1(23432, 3423,4324, d=11, e=22 · · · · · ·)
    然后这样100次,这不还是重复造轮子嘛,不符合函数式编程的思想,有没有能修改默认值并且保存修改后默认值的方法呢?下面就是!

    2. _defaults_ 修改默认值并保存默认值

    如下函数,计算输入数据的多次项数,但是根据需求会计算3次方、10次方或其他项数的,这时候使用函数的自带属性__defaults__就可以修改默认的项数并且在之后也是使用该项数计算数据。

    In [09]: def fun2(x:"输入数据", dim:"项数"=2)->"返回一个数的多项数":
    		    "这是一个幂函数"
    		    print(x**dim)
    
    In [10]: fun2(3)
    Out[10]: 27
    In [11]: fun2(4)
    Out[11]: 64
    

    修改函数的__defaults__属性

    In [12]: fun2.__defaults__ = 3,
    In [13]: fun2(3)
    Out[13]: 27
    In [14]: fun2(4)
    Out[14]: 64
    

    这样就可以巧妙的一次重置默认值,以后方便使用。但是有个问题就是如果要再次使用之前的默认值还得改回来,那有没有什么方法可以复制函数并且更改默认值,然后就有了多个参数的默认值呢?下面就有!

    3. partial 偏函数固定部分参数

    现有字节转换函数

    In [15]: def calc(bytesizes, trans='KB'):
    		    if trans == 'KB': size=1024
    		    if trans == 'MB': size=1024**2
    		    if trans == 'GB': size=1024**3
    		    if trans == 'TB': size=1024**4
    		    return str(bytesizes//size)+' '+trans
    

    随意输入数字就可以按照指定的单位输出大小

    In [16]: calc(1024)
    Out[16]: '1 KB'
    In [17]: calc(1024*1024, trans='MB')
    Out[17]: '1 MB'
    

    如果是要另外使用功能TB的转换函数就可以使用functools.partial更改默认值,然后返回的仍然是函数,这样就可以建立一个新默认值的函数了,而且原函数并没有改变。

    In [18]: import functools
    In [19]: calc_tb = functools.partial(calc, trans='TB')
    Out[19]: calc_tb(1024**5)
    
    展开全文
  • 一下代码 def func(ls = []): ls.append(1) return ls a = func() b = func() print(a,b) 这个程序的运行结果为什么是[1,1] [1,1]
  • #在Python中,可以为函数的参数给予默认值 #一旦某个存在默认值,那么如果在调用的时候, #不传递这个参数,则按照默认值 #减少调用时的繁杂操作 注意:在定义函数时,如果存在有默认值的参数,一定要写在没有默认值...

    .函数的默认值
    #在Python中,可以为函数的参数给予默认值
    #一旦某个存在默认值,那么如果在调用的时候,
    #不传递这个参数,则按照默认值
    #减少调用时的繁杂操作
    注意:在定义函数时,如果存在有默认值的参数,一定要写在没有默认值的参数后面,
    否则在调用是,无法确定参数到底传给哪个参数。

    用一个函数的默认值来计算圆的面积:
    在这里插入图片描述
    可以在函数中用3.14这个默认值来定义一个3.14159,并在接下来的调用函数中,在计算面积时
    直接调用3.14159这个默认值来代入到计算圆的面积中
    在这里插入图片描述
    所以计算的结果也是浮点型,并有跟3.14159一样的小数位

    参数问题又分为四种参数
    参数问题
    默认值参数
    可变参数
    命名参数
    万能参数

    可变参数:
    def yi():
    return 6
    if name == ‘main’:
    #用引用传递来赋值
    x=yi
    #调用函数
    y=yi()
    print(x)
    print(y)

    z=x()
    print(z)

    x因为引用传递来被被赋值了6,用y来调用,z又调用了x
    输出结果为
    <function yi at 0x00000224147A3E18>
    6
    6
    在递归传递中:
    递归就是相当与自身调用自身的一个函数
    递归的两个必要条件:
    1.函数自身调用自己
    2.要有终止条件(死循环)
    3.用一个递归函数来运算1-100的加法

    例如:
    def digui(n):
    if n == 0:
    return 0
    else:
    return n + digui(n - 1)
    sun=digui(100)
    print(sum)
    用递归函数来完成一个循环:
    可以看除用了if语句来完成一个自身的循环,从100一直在递减,直到递减到1,
    用sum来完成一个自加,知道循环到0,来结束循环
    结果为:
    5050
    匿名函数:
    匿名函数是一种lambda表达式
    lambda则是一种语言
    格式为:

    def a()::
    print(“hello world”)
    lambda:print(“hello world”)
    def add(x,y):
    return x + y
    lambda x,y: x + y
    1
    2
    3
    4
    5
    6
    优点:简化代码书写
    缺点:降低了代码的可读性,增加代码的维护成本

    用匿名函数做一个加法的程序:

    def zhong(a,b):
    return a + b
    zhong = lambda x,y:x+y
    print(zhong(5,6))
    #命名一个a,b,给a,b赋一个值即可
    1
    2
    3
    4
    5
    结果为:

    11
    1
    .函数的默认值
    #在Python中,可以为函数的参数给予默认值
    #一旦某个存在默认值,那么如果在调用的时候,
    #不传递这个参数,则按照默认值
    #减少调用时的繁杂操作
    注意:在定义函数时,如果存在有默认值的参数,一定要写在没有默认值的参数后面,
    否则在调用是,无法确定参数到底传给哪个参数。

    用一个函数的默认值来计算圆的面积:
    在这里插入图片描述
    也可以在函数中用3.14这个默认值来定义一个3.14159,并在接下来的调用函数中,在计算面积时
    直接调用3.14159这个默认值来代入到计算圆的面积中
    在这里插入图片描述
    所以计算的结果也是浮点型,并有跟3.14159一样的小数位
    参数问题又分为四种参数
    参数问题
    默认值参数
    可变参数
    命名参数
    万能参数

    可变参数:

    def xing(name,age,sex,*args):
    print(“名字是”,name)
    print(“年龄是”,age)
    print(“性别是”,sex)
    print(args)
    xing(“YY”,19,“男”,180,“ning”,140)

    结果是

    名字是 YY
    年龄是 19
    性别是 男
    (180,'ning',140)
    

    可以看出在定义函数时加了一个*args这个可变参数,当输出一堆多出原有参数的无用参数时,
    会将这些多出的无用的参数会以元组的形式封装到最后一行。

    命名参数:

    def xing(name,age,sex,**kwargs):
    print(“名字是”,name)
    print(“年龄是”,age)
    print(“性别是”,sex)
    print(kwargs)
    xing(“YY”,19,“男”,add=“时代”,wei=“46”)

    可以看出在定义函数时加了一个**args这个命名参数,当输出原有中多出的变量参数时,
    会以容器中字典里面的键值对的形式来封装出这些变量参数

    名字是 YY
    年龄是 19
    性别是 男
    {'add':'时代','wei':46}
    

    万能参数:

    def xing(name,*args,**kwargs):
    print(name)
    print(args)
    print(kwargs)
    xing(“YY”,19,“男”,add=“WDNIMDCP”,wei=“CKBL”)

    可以看出,普通参数会以第一行的形式列出,可变参数还是会以元组的形式列出 在第二行,
    第三行则是命名参数以字典中键值对的形式列出赋有变量的参数
    当这两者同时运用时便是万能参数,并一一列出并封装好这些不同参数类型。

     TX
    (19, '男')
    {'add': 'WDNIMDCP', 'wei': 'CKBL'}
    
    展开全文
  • Programmer A writes the following function:def compute_value(threshold = sys.float_info.max):...return valuewhich has the optional parameter threshold which in a natural way has the maximum float valu...
  • python 默认值参数问题

    2021-08-26 19:50:57
    参数的默认值,只会在... return num_list print(append(1)) print(append(2)) # 输出 # [0, 0, 1] # [0, 0, 1, 2] # 奇怪的问题 对于以动态值作为实际默认值的关键字参数来说,应该把形式 上的默认值写为 None.
  • Python_02默认值

    2019-10-09 10:57:35
    默认值只有在最新定义的时候被评估一次 -Example 01 A=10 def myfun(a=A): print(a) A=20 myfun() print(A) 结果 10 20 Example 02 A=10 A=[0] def myfun(a=A): print(a) A=[1] myfun() print(A) 结果 [0] ...
  • Python使用函数默认值实现函数静态变量的方法,具体方法如下:一、Python函数默认值Python函数默认值的使用可以在函数调用时写代码提供方便,很多时候我们只要使用默认值就可以了。 所以函数默认值python中用到的...
  • 某些对象还支持以下形式的getattr访问: a = myobject.getattr('id', None) def deepgetattr(obj, attr): """Recurses through an attribute chain to get the ultimate value.""" return reduce(getattr, attr....
  • python函数参数默认值

    千次阅读 2017-01-25 18:41:54
    python函数默认参数
  • Python3 Enum 默认值

    2020-07-26 23:38:35
    line 310, in __call__ return cls.__new__(cls, value) File "/home/shaokaix/ENV/python3.7/lib/python3.7/enum.py", line 564, in __new__ raise exc File "/home/shaokaix/ENV/python3.7/lib/python3.7/enum.py...
  • Python函数默认值 Python函数默认值的使用可以在函数调用时写代码提供方便,很多时候我们只要使用默认值就可以了。 所以函数默认值python中用到的很多,尤其是在类中间,类的初始化函数中一帮都会用到默认值。 ...
  • 给参数设置默认值非常有用。 def passion(name,location=" 中国"): return name+location s = 'a23foiwe9owef0wfia2' ret1 = passion("thinking",) ret2 = passion("thinking"," 上海 浦东") print("ret1=%s"%...
  • python中参数默认值简例

    千次阅读 2019-06-12 22:50:38
    # 参数默认值只能放在最后的参数上 def test(a, b=False): # b带默认值 if b: return a else: return a*a print(test(a=2)) # 输出:4 print(test(a=2, b=True)) # 输出:2 # 如果有两个参数拥有默...
  • 如果使用的参数默认值是可变的(例如列表),则可能引发烦人的问题。当执行def时,默认参数值只能使用一次,在函数调用期间将保留此关联。这意味着参数名相关联的默认对象的变化,将在函数调用间保持一致。如下例子...
  • Python函数参数默认值的陷阱 博客分类:  Python基础 阅读下面一段Python代码   Python代码  def testMutablePara1(a,l=[]):   l.append(a)   return l  print ...
  • 默认值参数是可变的类型,使用的都是一个,其内存地址不变 def place(x,list=[]): list.append(x) return list list1=place(10) list2=place(123,[]) list3=place("a") print("list1=%s"%list1) print("list2=%s...
  • python configparser中默认值的设定

    千次阅读 2020-01-07 14:57:18
    在做某一个项目时,在读配置文件中,当出现配置文件中没有对应项目时,如果要设置默认值,以前的做法是如下的: try: apple = config.get(section, 'apple') except NoSectionError, NoOptionError: apple = None ...
  • 本文将介绍使用mutable对象作为Python函数参数默认值潜在的危害,以及其实现原理和设计目的
  • 本篇文章给大家带来的内容是关于python函数参数默认值的用法及注意要点,有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。最有用的形式是对一个或多个参数指定一个默认值。这样创建的函数,可以用比...
  • 您可以使用先前编译的代码和新的默认值动态实例化一个新函数: >>> default = 1 >>> class Cl(object): ... def __init__(self, a=default): ... print a ... >>> from types import FunctionType >>> default = 2 ...
  • 本文实例展示了Python使用函数默认值实现函数静态变量的方法,具体方法如下: 一、Python函数默认值 Python函数默认值的使用可以在函数调用时写代码提供www.fanyaylc.com方便,很多时候我们只要使用默认值...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 71,947
精华内容 28,778
关键字:

pythonreturn默认值

python 订阅